pax_global_header00006660000000000000000000000064126356700160014520gustar00rootroot0000000000000052 comment=5779b83807f368192275a7d5ae37facfd5f85737 axe-0.3.1/000077500000000000000000000000001263567001600122765ustar00rootroot00000000000000axe-0.3.1/.gitattributes000066400000000000000000000000401263567001600151630ustar00rootroot00000000000000docs/gitversion.py export-subst axe-0.3.1/.gitignore000066400000000000000000000001251263567001600142640ustar00rootroot00000000000000# Editor temp files *.swp *.bak *~ # compiled build *.pyc *.o *.a *.so tags version axe-0.3.1/.gitmodules000066400000000000000000000001341263567001600144510ustar00rootroot00000000000000[submodule "src/libqes"] path = src/libqes url = https://github.com/kdmurray91/libqes.git axe-0.3.1/.travis.yml000066400000000000000000000013651263567001600144140ustar00rootroot00000000000000language: c env: matrix: - BUILD_TYPE=Release - BUILD_TYPE=Debug compiler: - clang - gcc sudo: false notifications: email: - spam@kdmurray.id.au addons: apt: sources: - kalakris-cmake packages: - cmake - lcov - libgsl0-dev - python - python-sphinx install: - pushd $HOME - wget http://zlib.net/zlib-1.2.8.tar.xz - tar xvf zlib-1.2.8.tar.xz - cd zlib-1.2.8 - ./configure --prefix=$HOME - make - make install - popd - git submodule update --init - mkdir build - mkdir target - cd build script: - cmake .. -DCMAKE_INSTALL_PREFIX=../target -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DZLIB_ROOT=$HOME - make - python ../tests/axe_cli_tests.py . - ./bin/test_axe - make install - test -f ../target/bin/axe-demux axe-0.3.1/CMakeLists.txt000066400000000000000000000055511263567001600150440ustar00rootroot00000000000000CMAKE_MINIMUM_REQUIRED(VERSION 2.8) PROJECT(axe C) LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake-modules") # Cmake options SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) ENABLE_TESTING() IF (NOT CMAKE_BUILD_TYPE) SET(CMAKE_BUILD_TYPE Release) ENDIF() IF (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/version") FILE(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/version" AXE_VERSION) ELSE() # git describe as versioning EXECUTE_PROCESS(COMMAND git describe WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} OUTPUT_VARIABLE AXE_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE) ENDIF() MESSAGE(STATUS "${CMAKE_BUILD_TYPE} build of axe version: ${AXE_VERSION}") ############################### ## Find Packages and Headers ## ############################### FIND_PACKAGE(ZLIB 1.2.5 REQUIRED) FIND_PACKAGE(GSL) IF (GSL_FOUND) SET(AXE_DEP_INCLUDES ${GSL_INCLUDE_DIRS}) SET(AXE_DEP_LIBS ${GSL_LIBRARIES}) ENDIF() ########################## ## Set Compiler Options ## ########################## IF (CMAKE_COMPILER_IS_GNUCC) SET(AXEWRN "${AXEWRN} -Woverride-init -Wnormalized=id -Wlogical-op") EXECUTE_PROCESS(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION) IF (GCC_VERSION VERSION_GREATER 4.9 OR GCC_VERSION VERSION_EQUAL 4.9) SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fdiagnostics-color=always") ENDIF() ENDIF() # Set CFLAGS SET(AXEWRN "${AXEWRN} -fstack-protector-all -Wstack-protector -Wfloat-equal") SET(AXEWRN "${AXEWRN} -Wundef -Wpointer-arith -Wstrict-prototypes") SET(AXEWRN "${AXEWRN} -Wmissing-prototypes -Wwrite-strings -Wredundant-decls") SET(AXEWRN "${AXEWRN} -Wchar-subscripts -Wcomment -Wformat=2 -Wwrite-strings") SET(AXEWRN "${AXEWRN} -Wmissing-declarations -Wredundant-decls -Wnested-externs") SET(AXEWRN "${AXEWRN} -Wbad-function-cast -Wswitch-enum -Winit-self") SET(AXEWRN "${AXEWRN} -Wmissing-field-initializers -Wdeclaration-after-statement") SET(AXEWRN "${AXEWRN} -Wold-style-definition -Waddress -Wmissing-noreturn ") SET(AXEWRN "${AXEWRN} -Wstrict-overflow=1 -Wextra -Warray-bounds -Wall -D_FORTIFY_SOURCE=2") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${AXEWRN}") INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/src ${CMAKE_SOURCE_DIR}/src/datrie ${CMAKE_SOURCE_DIR}/src/libqes/src ${CMAKE_SOURCE_DIR}/src/gsl) LINK_DIRECTORIES(${CMAKE_BINARY_DIR}/lib) INCLUDE_DIRECTORIES(${CMAKE_BINARY_DIR}) CONFIGURE_FILE(${CMAKE_SOURCE_DIR}/src/axe_config.h.in ${CMAKE_BINARY_DIR}/axe_config.h) ADD_SUBDIRECTORY(docs) ADD_SUBDIRECTORY(tests) ADD_SUBDIRECTORY(src) SET(LIBQES_AS_SUBMODULE True) # stop libqes installing itself ADD_SUBDIRECTORY(src/libqes) axe-0.3.1/LICENSE.txt000066400000000000000000000772461263567001600141410ustar00rootroot00000000000000 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. axe-0.3.1/README.md000066400000000000000000000123451263567001600135620ustar00rootroot00000000000000AXE === > De-multiplex NGS reads using trie data structures. It's fast, and made of tries! [![DOI](https://zenodo.org/badge/6357/kdmurray91/axe.png)](https://zenodo.org/record/12278) [![Documentation Status](https://readthedocs.org/projects/axe-demultiplexer/badge/?version=latest)](https://readthedocs.org/projects/axe-demultiplexer/?badge=latest) AXE very rapidly selects the optimal barcode present in a sequence read, even in the presence of sequencing errors. The algorithm is able to handle combinatorial barcoding, barcodes of differing length, and several mismatches per barcode. Early results indicate far improved accuracy and speed over existing de-multiplexers. Unscientific trials show AXE processes more than 500,000 reads per second. **Warning**: Axe has not yet been comprehensively tested. However, in the spirit of "release early and often", here it is. ###Tests: | Jenkins GNU/Linux | [![Build Status](http://biojenkins.anu.edu.au/job/axe/badge/icon)](http://biojenkins.anu.edu.au/job/axe/) | | ----------------- | --- | | TravisCI | [![Build Status](https://travis-ci.org/kdmurray91/axe.svg?branch=master)](https://travis-ci.org/kdmurray91/axe) | | Test Coverage | [![Coverage Status](https://img.shields.io/coveralls/kdmurray91/axe.svg)](https://coveralls.io/r/kdmurray91/axe?branch=master) | | Coverity Scans | [![Coverity Scan Build Status](https://scan.coverity.com/projects/2666/badge.svg)](https://scan.coverity.com/projects/2666) | Important Note -------------- **For arcane reasons, the name of the ``axe`` binary changed to ``axe-demux`` with version 0.3.0. Apologies for the inconvenience, this was required to make ``axe`` installable in Debian and its derivatives. Command-line usage did not change.** Installation: ------------- Currently, only recent GNU/Linux systems are officially supported. All code and the build system is portable, so compilation and use on other systems should be possible, I just don't have machines available to test. Please report any installation issues on any system as GitHub bugs and I'll do my best to sort them out. In short, on *NIX, get the dependencies (see below), and: git clone --recursive https://github.com/kdmurray91/axe.git axe cd axe mkdir -p build && cd build cmake .. make sudo make install To install to a prefix, as you would with `./configure --prefix` with the autotools build system, please use the following cmake command in place of the one above: cmake -DCMAKE_INSTALL_PREFIX=/path/to/your/prefix .. e.g.: cmake -DCMAKE_INSTALL_PREFIX=$HOME .. For me, using `~/` as the prefix will install `axe` under `/home/kevin/bin` on GNU/Linux, and (if I had one) `/Users/kevin/bin` on Mac OSX.It's also wise to use `make install` not `sudo make install` when installing to a home directory. ###Dependencies: - cmake. This is installable via `sudo apt-get install cmake` on Debian based systems, or `brew install cmake` using homebrew on OS X. - zlib version >= 1.2.5. On Debian, use the package `zlib1g-dev`. - libqes, tinytest, libgsl and libdatrie (bundled in source, if you used `git clone --recursive` or an installation tarball. Otherwise, run `git submodule update --init`). You'll possibly need to install zlib to your chosen prefix (e.g. `~/`) on supercomputers, which often have very old versions of zlib. To do so: wget http://zlib.net/zlib-1.2.8.tar.gz tar xvf zlib-1.2.8.tar.gz cd zlib-1.2.8 ./configure --prefix= # e.g. --prefix=$HOME make && make install And then, use the following cmake command, assuming your prefix is `~/`: cmake -DCMAKE_INSTALL_PREFIX=$HOME -DZLIB_ROOT=$HOME .. Usage: ------ Full documentation, including a basic description of the algorithm, is hosted at https://axe-demultiplexer.readthedocs.org/en/latest/ . Implementation Progress: ------------------------ - [x] Single ended read de-multiplexing - [x] Interleaved/Paired input and output with single-ended de-multiplexing - [x] Combinatorial de-multiplexing - [ ] CLI integration tests - [ ] Comprehensive `libaxe` tests - [ ] Comprehensive CLI tests See also TODO.md Publication ----------- A publication is coming soon, if the reviewer gods decide to smile upon us. Versioning ---------- We use Semantic Versioning. See [semver.org](http://semver.org) LICENSE ------- The source of axe itself, namely `src/axe*.[ch]` and `tests/*.[ch]`, is Copyright 2014-2015 Kevin Murray. All axe source code is licensed under the GNU GPL version 3 or greater, a copy of which is included with this source as `LICENCE.txt` The source of `tinytest`, located in `tests/tinytest`, is Copyright 2009-2012 Nick Matthewson; `tinytest` is distributed under the 3-clause BSD license. `tinytest` is hosted at [Nick's github page](https://github.com/nmathewson/tinytest). The source of `libgsl`, located in `src/gsl`, is Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman and Brian Gough. It is licensed under the GNU General Public License, vesion 3 or greater. The source of `libdatrie`, located in `src/datrie`, is Copyright 2006 Theppitak Karoonboonyanan, and is licensed under the GNU LGPL version 2.1 per `src/datrie/COPYING`. `libdatrie` is hosted at Theppitak Karoonboonyanan's website, [here](http://linux.thai.net/~thep/datrie/datrie.html). axe-0.3.1/TODO.md000066400000000000000000000004441263567001600133670ustar00rootroot00000000000000TODO list: ========== - Re-read documentation; fix errors - Exhaustive CLI tests - Refactor trie lookups to hide all datrie operations from main body of code - Summary info - Valgrind integration tests - maybe a CLI flag to enable - Investigate shipping the gsl functions bundled in source. axe-0.3.1/cmake-modules/000077500000000000000000000000001263567001600150245ustar00rootroot00000000000000axe-0.3.1/cmake-modules/FindGSL.cmake000066400000000000000000000077021263567001600172620ustar00rootroot00000000000000# Try to find gnu scientific library GSL # See # http://www.gnu.org/software/gsl/ and # http://gnuwin32.sourceforge.net/packages/gsl.htm # # Based on a script of Felix Woelk and Jan Woetzel # (www.mip.informatik.uni-kiel.de) # # It defines the following variables: # GSL_FOUND - system has GSL lib # GSL_INCLUDE_DIRS - where to find headers # GSL_LIBRARIES - full path to the libraries # GSL_LIBRARY_DIRS, the directory where the PLplot library is found. # CMAKE_GSL_CXX_FLAGS = Unix compiler flags for GSL, essentially "`gsl-config --cxxflags`" # GSL_LINK_DIRECTORIES = link directories, useful for rpath on Unix # GSL_EXE_LINKER_FLAGS = rpath on Unix set( GSL_FOUND OFF ) set( GSL_CBLAS_FOUND OFF ) # Windows, but not for Cygwin and MSys where gsl-config is available if( WIN32 AND NOT CYGWIN AND NOT MSYS ) # look for headers find_path( GSL_INCLUDE_DIR NAMES gsl/gsl_cdf.h gsl/gsl_randist.h ) if( GSL_INCLUDE_DIR ) # look for gsl library find_library( GSL_LIBRARY NAMES gsl ) if( GSL_LIBRARY ) set( GSL_INCLUDE_DIRS ${GSL_INCLUDE_DIR} ) get_filename_component( GSL_LIBRARY_DIRS ${GSL_LIBRARY} PATH ) set( GSL_FOUND ON ) endif( GSL_LIBRARY ) # look for gsl cblas library find_library( GSL_CBLAS_LIBRARY NAMES gslcblas ) if( GSL_CBLAS_LIBRARY ) set( GSL_CBLAS_FOUND ON ) endif( GSL_CBLAS_LIBRARY ) set( GSL_LIBRARIES ${GSL_LIBRARY} ${GSL_CBLAS_LIBRARY} ) endif( GSL_INCLUDE_DIR ) mark_as_advanced( GSL_INCLUDE_DIR GSL_LIBRARY GSL_CBLAS_LIBRARY ) else( WIN32 AND NOT CYGWIN AND NOT MSYS ) if( UNIX OR MSYS ) find_program( GSL_CONFIG_EXECUTABLE gsl-config /usr/bin/ /usr/local/bin ) if( GSL_CONFIG_EXECUTABLE ) set( GSL_FOUND ON ) # run the gsl-config program to get cxxflags execute_process( COMMAND sh "${GSL_CONFIG_EXECUTABLE}" --cflags OUTPUT_VARIABLE GSL_CFLAGS RESULT_VARIABLE RET ERROR_QUIET ) if( RET EQUAL 0 ) string( STRIP "${GSL_CFLAGS}" GSL_CFLAGS ) separate_arguments( GSL_CFLAGS ) # parse definitions from cflags; drop -D* from CFLAGS string( REGEX MATCHALL "-D[^;]+" GSL_DEFINITIONS "${GSL_CFLAGS}" ) string( REGEX REPLACE "-D[^;]+;" "" GSL_CFLAGS "${GSL_CFLAGS}" ) # parse include dirs from cflags; drop -I prefix string( REGEX MATCHALL "-I[^;]+" GSL_INCLUDE_DIRS "${GSL_CFLAGS}" ) string( REPLACE "-I" "" GSL_INCLUDE_DIRS "${GSL_INCLUDE_DIRS}") string( REGEX REPLACE "-I[^;]+;" "" GSL_CFLAGS "${GSL_CFLAGS}") else( RET EQUAL 0 ) set( GSL_FOUND FALSE ) endif( RET EQUAL 0 ) # run the gsl-config program to get the libs execute_process( COMMAND sh "${GSL_CONFIG_EXECUTABLE}" --libs OUTPUT_VARIABLE GSL_LIBRARIES RESULT_VARIABLE RET ERROR_QUIET ) if( RET EQUAL 0 ) string(STRIP "${GSL_LIBRARIES}" GSL_LIBRARIES ) separate_arguments( GSL_LIBRARIES ) # extract linkdirs (-L) for rpath (i.e., LINK_DIRECTORIES) string( REGEX MATCHALL "-L[^;]+" GSL_LIBRARY_DIRS "${GSL_LIBRARIES}" ) string( REPLACE "-L" "" GSL_LIBRARY_DIRS "${GSL_LIBRARY_DIRS}" ) else( RET EQUAL 0 ) set( GSL_FOUND FALSE ) endif( RET EQUAL 0 ) MARK_AS_ADVANCED( GSL_CFLAGS ) else( GSL_CONFIG_EXECUTABLE ) message( STATUS "FindGSL: gsl-config not found.") endif( GSL_CONFIG_EXECUTABLE ) endif( UNIX OR MSYS ) endif( WIN32 AND NOT CYGWIN AND NOT MSYS ) if( GSL_FOUND ) if( NOT GSL_FIND_QUIETLY ) message( STATUS "FindGSL: Found both GSL headers and library" ) endif( NOT GSL_FIND_QUIETLY ) else( GSL_FOUND ) if( GSL_FIND_REQUIRED ) message( FATAL_ERROR "FindGSL: Could not find GSL headers or library" ) endif( GSL_FIND_REQUIRED ) endif( GSL_FOUND ) axe-0.3.1/cmake-modules/FindLIBQES.cmake000066400000000000000000000067611263567001600176200ustar00rootroot00000000000000# - Find libqes # Find the native libqes includes and library. # Once done this will define # # LIBQES_INCLUDE_DIRS - where to find qes.h, etc. # LIBQES_LIBRARIES - List of libraries when using libqes. # LIBQES_FOUND - True if libqes found. # # LIBQES_VERSION_STRING - The version of libqes found (x.y.z) # LIBQES_VERSION_MAJOR - The major version of libqes # LIBQES_VERSION_MINOR - The minor version of libqes # LIBQES_VERSION_PATCH - The patch version of libqes # LIBQES_VERSION_PREREL - The pre-release version of libqes # LIBQES_VERSION_GIT - The git version of libqes # # An includer may set LIBQES_ROOT to a libqes installation root to tell # this module where to look. #============================================================================= # Copyright 2014 Kevin Murray. Adapted from FindZLIB.cmake # # Distributed under the OSI-approved BSD License (the "License"); # see accompanying file Copyright.txt for details. # # This software is distributed WITHOUT ANY WARRANTY; without even the # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the License for more information. #============================================================================= # (To distribute this file outside of CMake, substitute the full # License text for the above reference.) set(_LIBQES_SEARCHES) # Search LIBQES_ROOT first if it is set. if(LIBQES_ROOT) set(_LIBQES_SEARCH_ROOT PATHS ${LIBQES_ROOT} NO_DEFAULT_PATH) list(APPEND _LIBQES_SEARCHES _LIBQES_SEARCH_ROOT) endif() # Normal search. set(_LIBQES_SEARCH_NORMAL PATHS "$ENV{PROGRAMFILES}/libqes" ) list(APPEND _LIBQES_SEARCHES _LIBQES_SEARCH_NORMAL) # Try each search configuration. foreach(search ${_LIBQES_SEARCHES}) find_path(LIBQES_INCLUDE_DIR NAMES qes.h ${${search}} PATH_SUFFIXES include) find_library(LIBQES_LIBRARY NAMES qes ${${search}} PATH_SUFFIXES lib) endforeach() mark_as_advanced(LIBQES_LIBRARY LIBQES_INCLUDE_DIR) # Handle version. Again, flogged from zlib if(LIBQES_INCLUDE_DIR AND EXISTS "${LIBQES_INCLUDE_DIR}/qes_config.h") file(STRINGS "${LIBQES_INCLUDE_DIR}/qes_config.h" LIBQES_H REGEX "^#define LIBQES_VERSION \"[^\"]*\"") string(REGEX REPLACE "^.*LIBQES_VERSION \"[Vv]?([0-9]+).*$" "\\1" LIBQES_VERSION_MAJOR "${LIBQES_H}") string(REGEX REPLACE "^.*LIBQES_VERSION \"[Vv]?[0-9]+\\.([0-9]+).*$" "\\1" LIBQES_VERSION_MINOR "${LIBQES_H}") string(REGEX REPLACE "^.*LIBQES_VERSION \"[Vv]?[0-9]+\\.[0-9]+\\.([0-9]+).*$" "\\1" LIBQES_VERSION_PATCH "${LIBQES_H}") set(LIBQES_VERSION_STRING "${LIBQES_VERSION_MAJOR}.${LIBQES_VERSION_MINOR}.${LIBQES_VERSION_PATCH}") # only append a EXTRA version if it exists: set(LIBQES_VERSION_EXTRA "") if( "${LIBQES_H}" MATCHES "^.*LIBQES_VERSION \"[Vv]?[0-9]+\\.[0-9]+\\.[0-9]+(.+)\\+git.*$") set(LIBQES_VERSION_PREREL "${CMAKE_MATCH_1}") endif() if( "${LIBQES_H}" MATCHES "^.*LIBQES_VERSION \"[Vv]?[0-9]+\\.[0-9]+\\.[0-9]+.*\\+git\\.(.+)$") set(LIBQES_VERSION_git "${CMAKE_MATCH_1}") endif() set(LIBQES_VERSION_STRING "${LIBQES_VERSION_STRING}${LIBQES_VERSION_PREREL}") endif() # handle the QUIETLY and REQUIRED arguments and set LIBQES_FOUND to TRUE if # all listed variables are TRUE include(FindPackageHandleStandardArgs) FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBQES REQUIRED_VARS LIBQES_LIBRARY LIBQES_INCLUDE_DIR VERSION_VAR LIBQES_VERSION_STRING) if(LIBQES_FOUND) set(LIBQES_INCLUDE_DIRS ${LIBQES_INCLUDE_DIR}) set(LIBQES_LIBRARIES ${LIBQES_LIBRARY}) endif() axe-0.3.1/docs/000077500000000000000000000000001263567001600132265ustar00rootroot00000000000000axe-0.3.1/docs/.gitignore000066400000000000000000000000071263567001600152130ustar00rootroot00000000000000.build axe-0.3.1/docs/CMakeLists.txt000066400000000000000000000022531263567001600157700ustar00rootroot00000000000000FIND_PROGRAM(SPHINXBUILD sphinx-build) IF(SPHINXBUILD) SET(ALLSPHINXOPTS -q -D latex_paper_size=a4) ADD_CUSTOM_TARGET(doc_html COMMAND ${SPHINXBUILD} -b html ${ALLSPHINXOPTS} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_BINARY_DIR}/doc/html WORKING_DIRECTORY ${CMAKE_BINARY_DIR} ) ADD_CUSTOM_TARGET(doc_onehtml COMMAND ${SPHINXBUILD} -b singlehtml ${ALLSPHINXOPTS} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_BINARY_DIR}/doc/single WORKING_DIRECTORY ${CMAKE_BINARY_DIR} ) ADD_CUSTOM_TARGET(doc_man COMMAND ${SPHINXBUILD} -b man ${ALLSPHINXOPTS} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_BINARY_DIR}/doc/man WORKING_DIRECTORY ${CMAKE_BINARY_DIR} ) ADD_CUSTOM_TARGET(doc_clean COMMAND ${CMAKE_COMMAND} -E remove_directory "${CMAKE_BINARY_DIR}/doc" WORKING_DIRECTORY ${CMAKE_BINARY_DIR} ) ADD_CUSTOM_TARGET(doc ALL DEPENDS doc_man doc_onehtml) INSTALL(FILES ${CMAKE_BINARY_DIR}/doc/man/axe.1 DESTINATION "share/man/man1" RENAME "axe-demux.1") SET_DIRECTORY_PROPERTIES(PROPERTY ADDITIONAL_MAKE_CLEAN_FILES doc/) ELSE() MESSAGE(WARNING "Cannot build documenation, sphinx isn't installed") ENDIF() axe-0.3.1/docs/Makefile000066400000000000000000000151361263567001600146740ustar00rootroot00000000000000# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = .build # User-friendly check for sphinx-build ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1) $(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/) endif # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . # the i18n builder cannot share the environment and doctrees with the others I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " singlehtml to make a single large HTML file" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " devhelp to make HTML files and a Devhelp project" @echo " epub to make an epub" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " latexpdf to make LaTeX files and run them through pdflatex" @echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx" @echo " text to make text files" @echo " man to make manual pages" @echo " texinfo to make Texinfo files" @echo " info to make Texinfo files and run them through makeinfo" @echo " gettext to make PO message catalogs" @echo " changes to make an overview of all changed/added/deprecated items" @echo " xml to make Docutils-native XML files" @echo " pseudoxml to make pseudoxml-XML files for display purposes" @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" clean: rm -rf $(BUILDDIR)/* html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." singlehtml: $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml @echo @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle @echo @echo "Build finished; now you can process the pickle files." json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json @echo @echo "Build finished; now you can process the JSON files." htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in $(BUILDDIR)/htmlhelp." qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in $(BUILDDIR)/qthelp, like this:" @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/axe.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/axe.qhc" devhelp: $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp @echo @echo "Build finished." @echo "To view the help file:" @echo "# mkdir -p $$HOME/.local/share/devhelp/axe" @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/axe" @echo "# devhelp" epub: $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub @echo @echo "Build finished. The epub file is in $(BUILDDIR)/epub." latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." @echo "Run \`make' in that directory to run these through (pdf)latex" \ "(use \`make latexpdf' here to do that automatically)." latexpdf: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through pdflatex..." $(MAKE) -C $(BUILDDIR)/latex all-pdf @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." latexpdfja: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through platex and dvipdfmx..." $(MAKE) -C $(BUILDDIR)/latex all-pdf-ja @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." text: $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text @echo @echo "Build finished. The text files are in $(BUILDDIR)/text." man: $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man @echo @echo "Build finished. The manual pages are in $(BUILDDIR)/man." texinfo: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." @echo "Run \`make' in that directory to run these through makeinfo" \ "(use \`make info' here to do that automatically)." info: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo "Running Texinfo files through makeinfo..." make -C $(BUILDDIR)/texinfo info @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." gettext: $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale @echo @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes @echo @echo "The overview file is in $(BUILDDIR)/changes." linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." doctest: $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest @echo "Testing of doctests in the sources finished, look at the " \ "results in $(BUILDDIR)/doctest/output.txt." xml: $(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml @echo @echo "Build finished. The XML files are in $(BUILDDIR)/xml." pseudoxml: $(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml @echo @echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml." axe-0.3.1/docs/algorithm.rst000066400000000000000000000077111263567001600157540ustar00rootroot00000000000000************************ Axe's matching algorithm ************************ Axe uses an algorithm based on longest-prefix-in-trie matching to match a variable length from the start of each read against a set of 'mutated' barcodes. Hamming distance matching ------------------------- While for most applications in high-throughput sequencing hamming distances are a frowned-upon metric, it is typical for HTS read barcodes to be designed to tolerate a certain level of hamming mismatches. Given these sequences are short and typically occur at the 5' end of reads, insertions and deletions rarely need be considered, and the increased rate of assignment of reads with many errors is offset by the risk of falsely assigning barcodes to an incorrect sample. In any case, reads with more than 1-2 sequencing errors in their first several bases are likely to be poor quality, and will simply be filtered out during downstream quality control. Hamming mismatch tries ---------------------- Typically, reads are matched to a set of barcodes by calculating the hamming distance between the barcode, and the first :math:`l` bases of a read for a barcode of length :math:`l`. The "correct" barcode is then selected by recording either the barcode with the lowest hamming distance to the read (competitive matching) or by simply accepting the first barcode with a hamming distance below a certain threshold. These approaches are both very computationally expensive, and can have lower accuracy than the algorithm I propose. Additionally, implementations of these methods rarely handle barcodes of differing length and combinatorial barcoding well, if at all. Central to Axe's algorithm is the concept of hamming-mismatch tries. A trie is a N-ary tree for an N letter alphabet. In the case of high-throughput sequencing reads, we have the alphabet ``AGCT``, corresponding to the four nucleotides of DNA, plus ``N``, used to represent ambiguous base calls. Instead of matching each barcode to each read, we pre-calculate all allowable sequences at each mismatch level, and store these in level-wise tries. For example, to match to a hamming distance of 2, we create three tries: One containing all barcodes, verbatim, and two tries where every sequence within a hamming distance of 1 and 2 of each barcode respectively. Hereafter, these tries are referred to as the 0, 1 and 2-mm tries, for a hamming distance (mismatch) of 0, 1 and 2. Then, we find the longest prefix in each sequence read in the 0mm trie. If this prefix is not a valid leaf in the 0mm trie, we find the longest prefix in the 1mm trie, and so on for all tries in ascending order. If no prefix of the read is a complete sequence in any trie, the read is assigned to an "non-barcoded" output file. This algorithm ensures optimal barcode matching in many ways, but is also extremely fast. In situations with barcodes of differing length, we ensure that the *longest* acceptable barcode at a given hamming distance is chosen; assuming that sequence is random after the barcode, the probability of false assignments using this method is low. We also ensure that short perfect matches are preferred to longer inexact matches, as we firstly only consider barcodes with no error, then 1 error, and so on. This ensures that reads with barcodes that are followed by random sequence that happens to inexactly match a longer barcode in the set are not falsely assigned to this longer barcode. The speed of this algorithm is largely due to the constant time matching algorithm with respect to the number of barcodes to match. The time taken to match each read is proportional instead to the length of the barcodes, as for a barcode of length :math:`l`, at most :math:`l + 1` trie level descents are required to find an entry in the trie. As this length is more-or-less constant and small, the overall complexity of axe's algorithm is :math:`O(n)` for :math:`n` reads, as opposed to :math:`O(nm)` for :math:`n` reads and :math:`m` barcodes as is typical for traditional matching algorithms axe-0.3.1/docs/conf.py000066400000000000000000000240271263567001600145320ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # axe documentation build configuration file, created by # sphinx-quickstart on Fri Jul 25 09:16:47 2014. # # This file is execfile()d with the current directory set to its # containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import sys import os # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. sys.path.insert(0, os.path.abspath('.')) import gitversion # -- General configuration ------------------------------------------------ # If your documentation needs a minimal Sphinx version, state it here. #needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ 'sphinx.ext.todo', 'sphinx.ext.pngmath', 'sphinx.ext.ifconfig', ] # Add any paths that contain templates here, relative to this directory. templates_path = ['.templates'] # The suffix of source filenames. source_suffix = '.rst' # The encoding of source files. #source_encoding = 'utf-8-sig' # The master toctree document. master_doc = 'index' # General information about the project. project = u'axe' copyright = u'2014, Kevin Murray' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = gitversion.get_versions()['version'] # The full version, including alpha/beta/rc tags. release = version # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. #language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = ['.build'] # The reST default role (used for this markup: `text`) to use for all # documents. #default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. #add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. #show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # If true, keep warnings as "system message" paragraphs in the built documents. #keep_warnings = False # -- Options for HTML output ---------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. html_theme = 'default' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. #html_theme_options = {} # Add any paths that contain custom themes here, relative to this directory. #html_theme_path = [] # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". #html_title = None # A shorter title for the navigation bar. Default is the same as html_title. #html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. #html_logo = None # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. #html_favicon = None # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['.static'] # Add any extra paths that contain custom files (such as robots.txt or # .htaccess) here, relative to this directory. These files are copied # directly to the root of the documentation. #html_extra_path = [] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. #html_domain_indices = True # If false, no index is generated. #html_use_index = True # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. #html_show_sourcelink = True # If true, "Created using Sphinx" is shown in the HTML footer. Default is True. #html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. #html_show_copyright = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = None # Output file base name for HTML help builder. htmlhelp_basename = 'axedoc' # -- Options for LaTeX output --------------------------------------------- latex_elements = { # The paper size ('letterpaper' or 'a4paper'). 'papersize': 'a4paper', # The font size ('10pt', '11pt' or '12pt'). 'pointsize': '11pt', # Additional stuff for the LaTeX preamble. #'preamble': '', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, # author, documentclass [howto, manual, or own class]). latex_documents = [ ('index', 'axe.tex', u'axe Documentation', u'Kevin Murray', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. #latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. #latex_use_parts = False # If true, show page references after internal links. #latex_show_pagerefs = False # If true, show URL addresses after external links. #latex_show_urls = False # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_domain_indices = True # -- Options for manual page output --------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ ('index', 'axe', u'axe Documentation', [u'Kevin Murray'], 1) ] # If true, show URL addresses after external links. #man_show_urls = False # -- Options for Texinfo output ------------------------------------------- # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ ('index', 'axe', u'axe Documentation', u'Kevin Murray', 'axe', 'One line description of project.', 'Miscellaneous'), ] # Documents to append as an appendix to all manuals. #texinfo_appendices = [] # If false, no module index is generated. #texinfo_domain_indices = True # How to display URL addresses: 'footnote', 'no', or 'inline'. #texinfo_show_urls = 'footnote' # If true, do not generate a @detailmenu in the "Top" node's menu. #texinfo_no_detailmenu = False # -- Options for Epub output ---------------------------------------------- # Bibliographic Dublin Core info. epub_title = u'axe' epub_author = u'Kevin Murray' epub_publisher = u'Kevin Murray' epub_copyright = u'2014, Kevin Murray' # The basename for the epub file. It defaults to the project name. #epub_basename = u'axe' # The HTML theme for the epub output. Since the default themes are not optimized # for small screen space, using the same theme for HTML and epub output is # usually not wise. This defaults to 'epub', a theme designed to save visual # space. #epub_theme = 'epub' # The language of the text. It defaults to the language option # or en if the language is not set. #epub_language = '' # The scheme of the identifier. Typical schemes are ISBN or URL. #epub_scheme = '' # The unique identifier of the text. This can be a ISBN number # or the project homepage. #epub_identifier = '' # A unique identification for the text. #epub_uid = '' # A tuple containing the cover image and cover page html template filenames. #epub_cover = () # A sequence of (type, uri, title) tuples for the guide element of content.opf. #epub_guide = () # HTML files that should be inserted before the pages created by sphinx. # The format is a list of tuples containing the path and title. #epub_pre_files = [] # HTML files shat should be inserted after the pages created by sphinx. # The format is a list of tuples containing the path and title. #epub_post_files = [] # A list of files that should not be packed into the epub file. epub_exclude_files = ['search.html'] # The depth of the table of contents in toc.ncx. #epub_tocdepth = 3 # Allow duplicate toc entries. #epub_tocdup = True # Choose between 'default' and 'includehidden'. #epub_tocscope = 'default' # Fix unsupported image types using the PIL. #epub_fix_images = False # Scale large images. #epub_max_image_width = 0 # How to display URL addresses: 'footnote', 'no', or 'inline'. #epub_show_urls = 'inline' # If false, no index is generated. #epub_use_index = True axe-0.3.1/docs/gitversion.py000066400000000000000000000165121263567001600157760ustar00rootroot00000000000000# This file helps to compute a version number in source trees obtained from # git-archive tarball (such as those provided by githubs download-from-tag # feature). Distribution tarballs (built by setup.py sdist) and build # directories (produced by setup.py build) will contain a much shorter file # that just contains the computed version number. # This file is released into the public domain. Generated by # versioneer-0.13 (https://github.com/warner/python-versioneer) # these strings will be replaced by git during git-archive git_refnames = " (HEAD -> master, tag: 0.3.1)" git_full = "5779b83807f368192275a7d5ae37facfd5f85737" # these strings are filled in when 'setup.py versioneer' creates _version.py tag_prefix = "" parentdir_prefix = "" versionfile_source = "docs/version.py" import errno import os import re import subprocess import sys def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False): assert isinstance(commands, list) p = None for c in commands: try: # remember shell=False, so use git.cmd on windows, not just git p = subprocess.Popen([c] + args, cwd=cwd, stdout=subprocess.PIPE, stderr=(subprocess.PIPE if hide_stderr else None)) break except EnvironmentError: e = sys.exc_info()[1] if e.errno == errno.ENOENT: continue if verbose: print("unable to run %s" % args[0]) print(e) return None else: if verbose: print("unable to find command, tried %s" % (commands,)) return None stdout = p.communicate()[0].strip() if sys.version >= '3': stdout = stdout.decode() if p.returncode != 0: if verbose: print("unable to run %s (error)" % args[0]) return None return stdout def versions_from_parentdir(parentdir_prefix, root, verbose=False): # Source tarballs conventionally unpack into a directory that includes # both the project name and a version string. dirname = os.path.basename(root) if not dirname.startswith(parentdir_prefix): if verbose: print("guessing rootdir is '%s', but '%s' doesn't start with " "prefix '%s'" % (root, dirname, parentdir_prefix)) return None return {"version": dirname[len(parentdir_prefix):], "full": ""} def git_get_keywords(versionfile_abs): # the code embedded in _version.py can just fetch the value of these # keywords. When used from setup.py, we don't want to import _version.py, # so we do it with a regexp instead. This function is not used from # _version.py. keywords = {} try: f = open(versionfile_abs, "r") for line in f.readlines(): if line.strip().startswith("git_refnames ="): mo = re.search(r'=\s*"(.*)"', line) if mo: keywords["refnames"] = mo.group(1) if line.strip().startswith("git_full ="): mo = re.search(r'=\s*"(.*)"', line) if mo: keywords["full"] = mo.group(1) f.close() except EnvironmentError: pass return keywords def git_versions_from_keywords(keywords, tag_prefix, verbose=False): if not keywords: return {} # keyword-finding function failed to find keywords refnames = keywords["refnames"].strip() if refnames.startswith("$Format"): if verbose: print("keywords are unexpanded, not using") return {} # unexpanded, so not in an unpacked git-archive tarball refs = set([r.strip() for r in refnames.strip("()").split(",")]) # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of # just "foo-1.0". If we see a "tag: " prefix, prefer those. TAG = "tag: " tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) if not tags: # Either we're using git < 1.8.3, or there really are no tags. We use # a heuristic: assume all version tags have a digit. The old git %d # expansion behaves like git log --decorate=short and strips out the # refs/heads/ and refs/tags/ prefixes that would let us distinguish # between branches and tags. By ignoring refnames without digits, we # filter out many common branch names like "release" and # "stabilization", as well as "HEAD" and "master". tags = set([r for r in refs if re.search(r'\d', r)]) if verbose: print("discarding '%s', no digits" % ",".join(refs-tags)) if verbose: print("likely tags: %s" % ",".join(sorted(tags))) for ref in sorted(tags): # sorting will prefer e.g. "2.0" over "2.0rc1" if ref.startswith(tag_prefix): r = ref[len(tag_prefix):] if verbose: print("picking %s" % r) return {"version": r, "full": keywords["full"].strip()} # no suitable tags, so we use the full revision id if verbose: print("no suitable tags, using full revision id") return {"version": keywords["full"].strip(), "full": keywords["full"].strip()} def git_versions_from_vcs(tag_prefix, root, verbose=False): # this runs 'git' from the root of the source tree. This only gets called # if the git-archive 'subst' keywords were *not* expanded, and # _version.py hasn't already been rewritten with a short version string, # meaning we're inside a checked out source tree. if not os.path.exists(os.path.join(root, ".git")): if verbose: print("no .git in %s" % root) return {} GITS = ["git"] if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] stdout = run_command(GITS, ["describe", "--tags", "--dirty", "--always"], cwd=root) if stdout is None: return {} if not stdout.startswith(tag_prefix): if verbose: fmt = "tag '%s' doesn't start with prefix '%s'" print(fmt % (stdout, tag_prefix)) return {} tag = stdout[len(tag_prefix):] stdout = run_command(GITS, ["rev-parse", "HEAD"], cwd=root) if stdout is None: return {} full = stdout.strip() if tag.endswith("-dirty"): full += "-dirty" return {"version": tag, "full": full} def get_versions(default={"version": "unknown", "full": ""}, verbose=False): # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have # __file__, we can work backwards from there to the root. Some # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which # case we can only use expanded keywords. keywords = {"refnames": git_refnames, "full": git_full} ver = git_versions_from_keywords(keywords, tag_prefix, verbose) if ver: return ver try: root = os.path.realpath(__file__) # versionfile_source is the relative path from the top of the source # tree (where the .git directory might live) to this file. Invert # this to find the root from __file__. for i in range(len(versionfile_source.split('/'))): root = os.path.dirname(root) except NameError: return default return (git_versions_from_vcs(tag_prefix, root, verbose) or versions_from_parentdir(parentdir_prefix, root, verbose) or default) axe-0.3.1/docs/index.rst000066400000000000000000000013341263567001600150700ustar00rootroot00000000000000.. axe documentation master file, created by sphinx-quickstart on Fri Jul 25 09:16:47 2014. You can adapt this file completely to your liking, but it should at least contain the root `toctree` directive. Welcome to axe's documentation! =============================== Axe is a read de-multiplexer, useful in situations where sequence reads contain the barcodes that uniquely distinguish samples. Axe uses a rapid and accurate algorithm based on hamming mismatch tries to competitively match the prefix of a sequencing read against a set of barcodes. Axe supports combinatorial barcoding schemes. Contents: .. toctree:: :maxdepth: 2 usage algorithm Indices and tables ================== * :ref:`genindex` axe-0.3.1/docs/usage.rst000066400000000000000000000126171263567001600150730ustar00rootroot00000000000000********* Axe Usage ********* .. note:: For arcane reasons, the name of the ``axe`` binary changed to ``axe-demux`` with version 0.3.0. Apologies for the inconvenience, this was required to make ``axe`` installable in Debian and its derivatives. Command-line usage did not change. Axe has several usage modes. The primary distinction is between the two alternate barcoding schemes, single and combinatorial barcoding. Single barcode matching is used when only the first read contains barcode sequences. Combinatorial barcoding is used when both reads in a read pair contain independent (typically different) barcode sequences. For concise reference, the command-line usage of ``axe-demux`` is reproduced below: .. literalinclude:: usage.txt Inputs and Outputs ------------------ Regardless of read mode, three input and output schemes are supported: single-end reads, paired reads (separate R1 and R2 files) and interleaved paired reads (one file, with R1 and R2 as consecutive reads). If single end reads are inputted, they must be output as single end reads. If either paired or interleaved paired reads are read, they can be output as either paired reads or interleaved paired reads. This applies to both successfully de-multiplexed reads and reads that could not be de-multiplexed. The ``-z`` flag can be used to specify that outputs should be compressed using gzip compression. The ``-z`` flag takes an integer argument between 0 (the default) and 9, where 0 indicates plain text output (``gzopen`` mode "wT"), and 1-9 indicate that the respective compression level should be used, where 1 is fastest and 9 is most compact. The output flags should be prefixes that are used to generate the output file name based on the barcode's (or barcode pair's) ID. The names are generated as: ``prefix`` + ``_`` + ``barcode ID`` + ``_`` + ``read number`` + ``.extension``. The output file for reads that could not be demultiplexed is ``prefix`` + ``_`` + ``unknown`` + ``_`` + ``read number`` + ``.extension``. The read number is omitted unless the paired read file scheme is used, and is "il" for interleaved output. The extension is "fastq"; ".gz" is appended to the extension if the ``-z`` flag is used. The corresponding CLI flags are: - ``-f`` and ``-F``: Single end or paired R1 file input and output respectively. - ``-r`` and ``-R``: Paired R2 file input and output. - ``-i`` and ``-I``: Interleaved paired input and output. The barcode file ---------------- The barcode file is a tab-separated file with an optional header. It is mandatory, and is always supplied using the ``-b`` command line flag. The exact format is dependent on barcoding mode, and is described further in the sections below. If a header is present, the header line must start with either `Barcode` or ``barcode``, or it will be interpreted as a barcode line, leading to a parsing error. Any line starting with ';' or '#' is ignored, allowing comments to be added in line with barcodes. Please ensure that the software used to produce the barcode uses ASCII encoding, and does not insert a Byte-order Mark (BoM) as many text editors can silently use Unicode-based encoding schemes. I recommend the use of `LibreOffice Calc `_ (part of a free and open source office suite) to generate barcode tables; Microsoft Excel can also be used. Mismatch level selection ------------------------ Independent of barcode mode, the ``-m`` flag is used to select the maximum allowable hamming distance between a read's prefix and a barcode to be considered as a match. As "mutated" barcodes must be unique, a hamming distance of one is the default as typically barcodes are designed to differ by a hamming distance of at least two. Optionally, (using the ``-p`` flag), axe will allow selective mismatch levels, where, if clashes are observed, the barcode will only be matched exactly. This allows one to process datasets with barcodes that don't have a sufficiently high distance between them. Single barcode mode ------------------- Single barcode mode is the default mode of operation. Barcodes are matched against read one (hereafter the forward read), and the barcode is trimmed from only the forward read, unless the ``-2`` command line flag is given, in which case a prefix the same length as the matched barcode is also trimmed from the second or reverse read. Note that sequence of this second read is not checked before trimming. In single barcode mode, the barcode file has two columns: ``Barcode`` and ``ID``. Combinatorial barcode mode -------------------------- Combinatorial barcode mode is activated by giving the ``-c`` flag on the command line. Forward read barcodes are matched against the forward read, and reverse read barcodes are matched against the reverse read. The optimal barcodes are selected independently, and the barcode pair is selected from these two barcodes. The respective barcodes are trimmed from both reads; the ``-2`` command line flag has no effect in combinatorial barcode mode. In combinatorial barcode mode, the barcode file has three columns: ``Barcode1``, ``Barcode2`` and ``ID``. Individual barcodes can occur many times within the forward and reverse barcodes, but barcode pairs must be unique combinations. The Demultipexing Statistics File --------------------------------- The ``-t`` option allows the output of per-sample read counts to a tab-separated file. The file will have a header describing its format, and includes a line for unbarcoded reads. axe-0.3.1/docs/usage.txt000066400000000000000000000023121263567001600150710ustar00rootroot00000000000000USAGE: axe-demux [-mzc2pt] -b (-f [-r] | -i) (-F [-R] | -I) axe-demux -h axe-demux -v OPTIONS: -m, --mismatch Maximum hamming distance mismatch. [int, default 1] -z, --ziplevel Gzip compression level, or 0 for plain text [int, default 0] -c, --combinatorial Use combinatorial barcode matching. [flag, default OFF] -p, --permissive Don't error on barcode mismatch confict, matching only exactly for conficting barcodes. [flag, default OFF] -2, --trim-r2 Trim barcode from R2 read as well as R1. [flag, default OFF] -b, --barcodes Barcode file. See --help for example. [file] -f, --fwd-in Input forward read. [file] -F, --fwd-out Output forward read prefix. [file] -r, --rev-in Input reverse read. [file] -R, --rev-out Output reverse read prefix. [file] -i, --ilfq-in Input interleaved paired reads. [file] -I, --ilfq-out Output interleaved paired reads prefix. [file] -t, --table-file Output a summary table of demultiplexing statistics to file. [file] -h, --help Print this usage plus additional help. -V, --version Print version string. -v, --verbose Be more verbose. Additive, -vv is more vebose than -v. -q, --quiet Be very quiet. axe-0.3.1/src/000077500000000000000000000000001263567001600130655ustar00rootroot00000000000000axe-0.3.1/src/CMakeLists.txt000066400000000000000000000024341263567001600156300ustar00rootroot00000000000000# Copyright 2014-2015 Kevin Murray # # This program is free software: you can 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 . # Axe library (libaxe.a) FILE(GLOB DATRIE_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/datrie/*.c) FILE(GLOB GSL_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/gsl/*.c) SET(AXELIB_SRCS ${DATRIE_SRCS} axe.c) IF (NOT GSL_FOUND) MESSAGE(STATUS "Using bundled GSL sources") SET(AXELIB_SRCS ${AXELIB_SRCS} ${GSL_SRCS}) ENDIF() ADD_LIBRARY(axelib STATIC ${AXELIB_SRCS}) TARGET_LINK_LIBRARIES(axelib qes_static ${AXE_DEP_LIBS}) SET_TARGET_PROPERTIES(axelib PROPERTIES OUTPUT_NAME axe) # Executable ADD_EXECUTABLE(axe-demux main.c) TARGET_LINK_LIBRARIES(axe-demux ${AXE_DEPENDS_LIBS} axelib) INSTALL(TARGETS axe-demux DESTINATION "bin") axe-0.3.1/src/axe.c000066400000000000000000001451251263567001600140160ustar00rootroot00000000000000/* * ============================================================================ * * Filename: axe.c * Description: Demultiplex reads by 5' barcodes * Copyright: 2014-2015 Kevin Murray * License: GNU GPL v3+ * * This program is free software: you can 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 . * * ============================================================================ */ #include "axe.h" #include "gsl_combination.h" /* Holds the current timestamp, so we don't have to free the returned string * from now(). */ char _time_now[10] = ""; const char *progress_bar_chars = "|/-\\"; unsigned int format_call_number; char * axe_formatter(struct qes_log_entry *entry) { char *buf = NULL; const char *colour = ANSIRST; const char *reset = ANSIRST; char marker = ' '; int res = 0; if (entry == NULL || entry->message == NULL) return NULL; if (entry->level <= QES_LOG_DEBUG) { marker = '.'; colour = ANSIBEG ATDIM FGCYN BGBLK ANSIEND; reset = ""; } else if (entry->level == AXE_LOG_PROGRESS) { marker = progress_bar_chars[format_call_number++ % 4]; colour = ANSIBEG ATNRM FGGRN BGBLK ANSIEND; } else if (entry->level == AXE_LOG_BOLD) { marker = '\0'; colour = ANSIBEG ATBLD FGCYN BGBLK ANSIEND; } else if (entry->level <= QES_LOG_INFO) { marker = '\0'; colour = ANSIBEG ATNRM FGGRN BGBLK ANSIEND; } else if (entry->level <= QES_LOG_WARNING) { marker = '!'; colour = ANSIBEG ATULN FGYEL BGBLK ANSIEND; } else if (entry->level <= QES_LOG_ERROR) { marker = 'E'; colour = ANSIBEG ATBLD FGMAG BGBLK ANSIEND; } else { marker = 'F'; colour = ANSIBEG ATBLD ATBNK FGRED BGBLK ANSIEND; } if (marker == '\0') { res = asprintf(&buf, "%s%s%s", colour, entry->message, reset); } else { res = asprintf(&buf, "%s[%c] %s%s", colour, marker, entry->message, reset); } if (res > 0) { return buf; } else { return NULL; } } /* Axe barcode struct ctor/dtor */ struct axe_barcode * axe_barcode_create(void) { struct axe_barcode *bcd = NULL; bcd = qes_calloc(1, sizeof(*bcd)); return bcd; } void axe_barcode_destroy_(struct axe_barcode *barcode) { if (!axe_barcode_ok(barcode)) return; qes_free(barcode->seq1); qes_free(barcode->seq2); qes_free(barcode->id); barcode->len1 = 0; barcode->len2 = 0; qes_free(barcode); } /* Axe config struct ctor/dtor */ struct axe_config * axe_config_create(void) { struct axe_config *config = qes_calloc(1, sizeof(*config)); config->logger = qes_logger_create(); /* qes_calloc never returns null, we use errprintexit as the err handler */ return config; } void axe_config_destroy_(struct axe_config *config) { size_t iii = 0; if (config == NULL) { return; } qes_log_message_debug(config->logger, "Destroying config structure\n"); /* File names */ qes_free(config->barcode_file); qes_free(config->table_file); qes_free(config->out_prefixes[0]); qes_free(config->out_prefixes[1]); qes_free(config->infiles[0]); qes_free(config->infiles[1]); /* outputs */ if (config->outputs != NULL) { for (iii = 0; iii < config->n_barcode_pairs; iii ++) { axe_output_destroy(config->outputs[iii]); } } qes_free(config->outputs); axe_output_destroy(config->unknown_output); /* barcode pairs */ if (config->barcodes != NULL) { for (iii = 0; iii < config->n_barcode_pairs; iii++) { axe_barcode_destroy(config->barcodes[iii]); } } qes_free(config->barcodes); /* barcode lookup */ if (config->barcode_lookup != NULL) { for (iii = 0; iii < config->n_barcodes_1; iii++) { qes_free(config->barcode_lookup[iii]); } } qes_free(config->barcode_lookup); /* Tries */ axe_trie_destroy(config->fwd_trie); axe_trie_destroy(config->rev_trie); /* Logger */ qes_logger_destroy(config->logger); /* config stuct */ qes_free(config); } static char * _axe_format_outfile_path (const char *prefix, const char *id, int read, const char *ext) { char buf[4096]; int res = 0; char *our_prefix = NULL; char lastchr = '\0'; size_t prefix_len = 0; if (prefix == NULL || id == NULL) { return NULL; } prefix_len = strlen(prefix); lastchr = prefix[prefix_len - 1]; if (lastchr == '/' || lastchr == '\\') { /* Our prefix is a directory, don't add '_' */ our_prefix = strdup(prefix); } else { /* Duplicate and append an underscore to prefix */ our_prefix = qes_malloc(prefix_len + 2); our_prefix[prefix_len + 1] = '\0'; strncpy(our_prefix, prefix, prefix_len); our_prefix[prefix_len] = '_'; } if (read > 0) { res = snprintf(buf, 4096, "%s%s_R%d.%s", our_prefix, id, read, ext); } else { res = snprintf(buf, 4096, "%s%s_il.%s", our_prefix, id, ext); } if (res >= 4096) { qes_free(our_prefix); return NULL; } qes_free(our_prefix); return strndup(buf, 4096); } struct axe_output * axe_output_create(const char *fwd_fpath, const char *rev_fpath, enum read_mode mode, const char *fp_mode) { struct axe_output *out = NULL; if (mode == READS_UNKNOWN || fwd_fpath == NULL || \ (mode == READS_PAIRED && rev_fpath == NULL)) { return NULL; } out = qes_calloc(1, sizeof(*out)); out->mode = mode; out->fwd_file = qes_seqfile_create(fwd_fpath, fp_mode); if (out->fwd_file == NULL) { qes_free(out); return NULL; } qes_seqfile_set_format(out->fwd_file, FASTQ_FMT); if (rev_fpath != NULL) { out->rev_file = qes_seqfile_create(rev_fpath, fp_mode); if (out->rev_file == NULL) { qes_seqfile_destroy(out->fwd_file); qes_free(out); return NULL; } qes_seqfile_set_format(out->rev_file, FASTQ_FMT); } else { out->rev_file = NULL; } return out; } void axe_output_destroy_(struct axe_output *output) { if (output != NULL) { qes_seqfile_destroy(output->fwd_file); qes_seqfile_destroy(output->rev_file); output->mode = READS_UNKNOWN; qes_free(output); } } static inline struct axe_barcode * read_barcode_combo(char *line) { char seq1[100] = ""; char seq2[100] = ""; char id[100] = ""; int res = 0; struct axe_barcode *barcode = NULL; if (line == NULL) { return NULL; } res = sscanf(line, "%99s\t%99s\t%99s", seq1, seq2, id); if (res < 3) { return NULL; } barcode = axe_barcode_create(); if (barcode == NULL) { return NULL; } /* Duplicate on the heap the R1 seq */ barcode->seq1 = strndup(seq1, 100); if (barcode->seq1 == NULL) goto error; barcode->len1 = strnlen(seq1, 100); /* Second barcode too */ barcode->seq2 = strndup(seq2, 100); if (barcode->seq2 == NULL) goto error; barcode->len2 = strnlen(seq2, 100); /* And the ID */ barcode->id = strndup(id, 100); if (barcode->id == NULL) goto error; barcode->idlen = strnlen(id, 100); return barcode; error: axe_barcode_destroy(barcode); return NULL; } static inline struct axe_barcode * read_barcode_single(char *line) { char seq[100] = ""; char id[100] = ""; int res = 0; struct axe_barcode * barcode = NULL; if (line == NULL) { return NULL; } res = sscanf(line, "%99s\t%99s", seq, id); if (res < 2) { return NULL; } barcode = axe_barcode_create(); if (barcode == NULL) { return NULL; } /* Duplicate on the heap the R1 seq */ barcode->seq1 = strndup(seq, 100); if (barcode->seq1 == NULL) goto error; barcode->len1 = strnlen(seq, 100); /* And the ID */ barcode->id = strndup(id, 100); if (barcode->id == NULL) goto error; barcode->idlen = strnlen(id, 100); return barcode; error: axe_barcode_destroy(barcode); return NULL; } int axe_read_barcodes(struct axe_config *config) { struct qes_file *qf = NULL; struct axe_barcode *this_barcode = NULL; struct axe_barcode **barcodes = NULL; size_t n_barcode_pairs = 0; /* Entries in file */ size_t n_barcodes_alloced = 8; const char *bad_fname_chars = "'\"!@#$%^&*()+=~`[]{}\\|;:/?><,"; char *line = NULL; char *tmp = NULL; size_t linesz = 128; ssize_t linelen = 0; size_t iii = 0; if (!axe_config_ok(config)) { return -1; } barcodes = qes_calloc(n_barcodes_alloced, sizeof(*barcodes)); qf = qes_file_open(config->barcode_file, "r"); line = qes_malloc(linesz); while ((linelen = qes_file_readline_realloc(qf, &line, &linesz)) > 0) { /* Skip an optional header line */ if (strncmp(line, "Barcode", 7) == 0 || \ strncmp(line, "barcode", 7) == 0) { continue; } /* Skip #-comment or ;-comment */ if (line[0] == '#' || line[0] == ';') { continue; } /* Reallocate the array if we need to */ if (n_barcode_pairs == n_barcodes_alloced) { n_barcodes_alloced *= 2; barcodes = qes_realloc(barcodes, n_barcodes_alloced * sizeof(*barcodes)); } /* Read the barcode line into a ``struct axe_barcode`` */ if (config->match_combo) { this_barcode = read_barcode_combo(line); } else { this_barcode = read_barcode_single(line); } if (this_barcode == NULL) { qes_log_format_fatal(config->logger, "Couldn't parse barcode line '%s'\n", line); qes_log_message_warning(config->logger, "Check that the format is correct and has " "UNIX line endings."); goto error; } /* Replace all bad chars with '-' */ tmp = strpbrk(this_barcode->id, bad_fname_chars); while (tmp != NULL) { *tmp = '-'; /* Replace with dash */ tmp = strpbrk(tmp + 1, bad_fname_chars); } /* Add the barcode to the array */ barcodes[n_barcode_pairs++] = this_barcode; } /* Save the array to the config struct */ config->barcodes = barcodes; config->n_barcode_pairs = n_barcode_pairs; qes_file_close(qf); qes_free(line); if (config->verbosity > 0) { qes_log_format_info(config->logger, "read_barcodes -- (%s) Read in barcodes\n", nowstr()); } return 0; error: if (barcodes != NULL) { for (iii = 0; iii < n_barcode_pairs; iii++) { axe_barcode_destroy(barcodes[iii]); } } qes_file_close(qf); qes_free(line); return 1; } static int setup_barcode_lookup_single(struct axe_config *config) { size_t iii = 0; if (!axe_config_ok(config)) { return -1; } config->n_barcodes_1 = config->n_barcode_pairs; config->n_barcodes_2 = 0; config->barcode_lookup = qes_malloc(config->n_barcodes_1 * sizeof(*config->barcode_lookup)); for (iii = 0; iii < config->n_barcode_pairs; iii++) { config->barcode_lookup[iii] = qes_malloc( sizeof(**config->barcode_lookup)); config->barcode_lookup[iii][0] = iii; } return 0; } static int setup_barcode_lookup_combo(struct axe_config *config) { struct axe_barcode *this_barcode = NULL; size_t n_barcodes_1 = 0; /* R1 barcodes */ size_t n_barcodes_2 = 0; size_t iii = 0; intptr_t tmp = 0; int ret = -1; int res = 0; size_t bcd1 = 0; size_t bcd2 = 0; struct axe_trie *seq1_trie = NULL; struct axe_trie *seq2_trie = NULL; if (!axe_config_ok(config)) { return -1; } /* Make "hash table" of barcode => unique bcd num. We use tries, as they work fine as a associatve map, and we've already got the headers, lib etc in the system. */ seq1_trie = axe_trie_create(); seq2_trie = axe_trie_create(); assert(seq1_trie != NULL && seq2_trie != NULL); for (iii = 0; iii < config->n_barcode_pairs; iii++) { this_barcode = config->barcodes[iii]; if (!axe_barcode_ok(this_barcode)) { qes_log_format_fatal(config->logger, "setup_lookup -- Bad barcode at %zu\n", iii); goto error; } if (!axe_trie_get(seq1_trie, this_barcode->seq1, &tmp)) { axe_trie_add(seq1_trie, this_barcode->seq1, n_barcodes_1++); } if (!axe_trie_get(seq2_trie, this_barcode->seq2, &tmp)) { axe_trie_add(seq2_trie, this_barcode->seq2, n_barcodes_2++); } } config->n_barcodes_1 = n_barcodes_1; config->n_barcodes_2 = n_barcodes_2; /* Make barcode lookup */ config->barcode_lookup = qes_malloc(n_barcodes_1 * sizeof(*config->barcode_lookup)); for (bcd1 = 0; bcd1 < config->n_barcodes_1; bcd1++) { config->barcode_lookup[bcd1] = qes_calloc(n_barcodes_2, sizeof(**config->barcode_lookup)); memset(config->barcode_lookup[bcd1], -1, n_barcodes_2 * sizeof(**config->barcode_lookup)); } /* Setup barcode lookup */ for (iii = 0; iii < config->n_barcode_pairs; iii++) { this_barcode = config->barcodes[iii]; /* already checked barcode above */ res = axe_trie_get(seq1_trie, this_barcode->seq1, (intptr_t *)(&bcd1)); if (!res) goto error; res = axe_trie_get(seq2_trie, this_barcode->seq2, (intptr_t *)(&bcd2)); if (!res) goto error; config->barcode_lookup[bcd1][bcd2] = iii; } ret = 0; exit: axe_trie_destroy(seq1_trie); axe_trie_destroy(seq2_trie); return ret; error: ret = 1; goto exit; } int axe_setup_barcode_lookup(struct axe_config *config) { if (!axe_config_ok(config)) { return -1; } if (config->match_combo) { return setup_barcode_lookup_combo(config); } return setup_barcode_lookup_single(config); } int axe_make_tries(struct axe_config *config) { if (!axe_config_ok(config)) { return -1; } config->fwd_trie = axe_trie_create(); if (config->fwd_trie == NULL) { goto error; } if (config->match_combo) { config->rev_trie = axe_trie_create(); if (config->rev_trie == NULL) { goto error; } } return 0; error: qes_log_message_fatal( config->logger, "make_tries -- ERROR: axe_trie_create returned NULL\n"); axe_trie_destroy(config->fwd_trie); if (config->match_combo) { axe_trie_destroy(config->rev_trie); } return 1; } static char * axe_make_file_ext(const struct axe_config *config) { if (!axe_config_ok(config)) { return NULL; } if (config->out_compress_level > 0 && config->out_compress_level < 10) { return strdup("fastq.gz"); } return strdup("fastq"); } static char * axe_make_zmode(const struct axe_config *config) { if (!axe_config_ok(config)) { return NULL; } if (config->out_compress_level > 0 && config->out_compress_level < 10) { char tmp[3] = ""; snprintf(tmp, 3, "w%d", config->out_compress_level); return strdup(tmp); } return strdup("wT"); } static inline int load_tries_combo(struct axe_config *config) { int bcd1 = -1; int bcd2 = -1; int retval = 0; char **mutated = NULL; size_t num_mutated = 0; int ret = 0; size_t iii = 0; size_t jjj = 0; size_t mmm = 0; struct axe_barcode *this_bcd = NULL; intptr_t tmp = 0; if (!axe_config_ok(config)) { fprintf(stderr, "[load_tries] Bad config\n"); ret = -1; goto exit; } /* Make mutated barcodes and add to trie */ for (iii = 0; iii < config->n_barcode_pairs; iii++) { this_bcd = config->barcodes[iii]; if (!axe_barcode_ok(this_bcd)) { qes_log_format_fatal(config->logger, "load_tries -- Bad R1 barcode at %zu\n", iii); ret = -1; goto exit; } /* Either lookup the index of the first read in the barcode table, or * insert this barcode into the table, storing its index. * Note the NOT here. */ if (!axe_trie_get(config->fwd_trie, this_bcd->seq1, &tmp)) { ret = axe_trie_add(config->fwd_trie, this_bcd->seq1, ++bcd1); if (ret != 0) { qes_log_format_fatal(config->logger, "load_tries -- Could not load barcode %s into trie %zu\n", this_bcd->seq1, iii); ret = 1; goto exit; } } else { continue; } for (jjj = 1; jjj <= config->mismatches; jjj++) { /* Do the forwards read barcode */ mutated = hamming_mutate_dna(&num_mutated, this_bcd->seq1, this_bcd->len1, jjj, 0); if (mutated == NULL) { ret = 1; goto exit; } for (mmm = 0; mmm < num_mutated; mmm++) { ret = axe_trie_add(config->fwd_trie, mutated[mmm], bcd1); if (ret != 0) { if (config->permissive) { if (config->verbosity >= 0) { qes_log_format_warning(config->logger, "load_tries -- warning: Will only match to %dmm\n", (int)jjj - 1); } axe_trie_delete(config->fwd_trie, mutated[mmm]); qes_free(mutated[mmm]); continue; } qes_log_format_fatal(config->logger, "load_tries -- Barcode %s already in fwd trie (%dmm) %s\n", mutated[mmm], (int)jjj, this_bcd->seq1); retval = 1; goto exit; } qes_free(mutated[mmm]); } qes_free(mutated); } } /* Ditto for the reverse read */ for (iii = 0; iii < config->n_barcode_pairs; iii++) { this_bcd = config->barcodes[iii]; /* Likewise for the reverse read index */ if (!axe_trie_get(config->rev_trie, this_bcd->seq2, &tmp)) { ret = axe_trie_add(config->rev_trie, this_bcd->seq2, ++bcd2); if (ret != 0) { qes_log_format_fatal(config->logger, "load_tries -- Could not load barcode %s into trie %zu\n", this_bcd->seq2, iii); retval = 1; goto exit; } } else { continue; } for (jjj = 1; jjj <= config->mismatches; jjj++) { num_mutated = 0; mutated = hamming_mutate_dna(&num_mutated, this_bcd->seq2, this_bcd->len2, jjj, 0); if (mutated == NULL) { ret = 1; goto exit; } for (mmm = 0; mmm < num_mutated; mmm++) { ret = axe_trie_add(config->rev_trie, mutated[mmm], bcd2); if (ret != 0) { if (config->permissive) { if (config->verbosity >= 0) { qes_log_format_warning(config->logger, "load_tries -- Will only match %s to %dmm\n", this_bcd->id, (int)jjj - 1); } trie_delete(config->rev_trie->trie, mutated[mmm]); qes_free(mutated[mmm]); continue; } qes_log_format_fatal(config->logger, "load_tries -- Barcode %s already in rev trie (%dmm) %s\n", mutated[mmm], (int)jjj, this_bcd->seq1); retval = 1; goto exit; } qes_free(mutated[mmm]); } qes_free(mutated); } } /* we got here, so we succeeded. set retval accordingly */ retval = 0; exit: if (mutated != NULL) { for (mmm = 0; mmm < num_mutated; mmm++) { qes_free(mutated[mmm]); } qes_free(mutated); } return retval; } static inline int load_tries_single(struct axe_config *config) { char **mutated = NULL; size_t num_mutated = 0; int ret = 0; size_t iii = 0; size_t jjj = 0; size_t mmm = 0; intptr_t tmp = 0; int retval = -1; struct axe_barcode *this_bcd = NULL; if (!axe_config_ok(config)) { fprintf(stderr, "[load_tries] Bad config\n"); return -1; } /* Make mutated barcodes and add to trie */ for (iii = 0; iii < config->n_barcode_pairs; iii++) { this_bcd = config->barcodes[iii]; if (!axe_barcode_ok(this_bcd)) { fprintf(stderr, "[load_tries] Bad barcode at %zu\n", iii); return -1; } /* Either lookup the index of the first read in the barcode table, or * insert this barcode into the table, storing its index. * Note the NOT here. */ if (!axe_trie_get(config->fwd_trie, this_bcd->seq1, &tmp)) { ret = axe_trie_add(config->fwd_trie, this_bcd->seq1, (int)iii); if (ret != 0) { fprintf(stderr, "ERROR: Could not load barcode %s into trie %zu\n", this_bcd->seq1, iii); return 1; } } else { fprintf(stderr, "ERROR: Duplicate barcode %s\n", this_bcd->seq1); return 1; } for (jjj = 1; jjj <= config->mismatches; jjj++) { mutated = hamming_mutate_dna(&num_mutated, this_bcd->seq1, this_bcd->len1, jjj, 0); if (mutated == NULL) { ret = 1; goto exit; } for (mmm = 0; mmm < num_mutated; mmm++) { ret = axe_trie_add(config->fwd_trie, mutated[mmm], iii); if (ret != 0) { if (config->permissive) { if (config->verbosity >= 0) { fprintf(stderr, "[%s] warning: Will only match to %dmm\n", __func__, (int)jjj - 1); } trie_delete(config->fwd_trie->trie, mutated[mmm]); qes_free(mutated[mmm]); continue; } fprintf(stderr, "[%s] ERROR: Barcode %s already in trie (%dmm)\n", __func__, mutated[mmm], (int)jjj); retval = 1; goto exit; } qes_free(mutated[mmm]); } qes_free(mutated); num_mutated = 0; } } /* we got here, so we succeeded */ retval = 0; exit: if (mutated != NULL) { for (mmm = 0; mmm < num_mutated; mmm++) { qes_free(mutated[mmm]); } qes_free(mutated); } return retval; } int axe_make_outputs(struct axe_config *config) { size_t iii = 0; char *name_fwd = NULL; char *name_rev = NULL; char *file_ext = NULL; char *zmode = NULL; struct axe_barcode *this_bcd = NULL; if (!axe_config_ok(config)) { fprintf(stderr, "[make_outputs] Bad config\n"); return -1; } file_ext = axe_make_file_ext(config); zmode = axe_make_zmode(config); config->outputs = qes_calloc(config->n_barcode_pairs, sizeof(*config->outputs)); /* For each sample, make the filename, make an output */ for (iii = 0; iii < config->n_barcode_pairs; iii++) { this_bcd = config->barcodes[iii]; /* Open barcode files */ switch (config->out_mode) { case READS_SINGLE: name_fwd = _axe_format_outfile_path(config->out_prefixes[0], this_bcd->id, 1, file_ext); name_rev = NULL; break; case READS_PAIRED: name_fwd = _axe_format_outfile_path(config->out_prefixes[0], this_bcd->id, 1, file_ext); name_rev = _axe_format_outfile_path(config->out_prefixes[1], this_bcd->id, 2, file_ext); break; case READS_INTERLEAVED: name_fwd = _axe_format_outfile_path(config->out_prefixes[0], this_bcd->id, 0, file_ext); name_rev = NULL; break; case READS_UNKNOWN: default: fprintf(stderr, "[make_outputs] Error: bad output mode %ui\n", config->out_mode); goto error; } config->outputs[iii] = axe_output_create(name_fwd, name_rev, config->out_mode, zmode); if (config->outputs[iii] == NULL) { fprintf(stderr, "[make_outputs] couldn't create file at %s\n", name_fwd); goto error; } qes_free(name_fwd); qes_free(name_rev); } /* Generate the unknown file in the same manner, using id == unknown */ switch (config->out_mode) { case READS_SINGLE: name_fwd = _axe_format_outfile_path(config->out_prefixes[0], "unknown", 1, file_ext); name_rev = NULL; break; case READS_PAIRED: name_fwd = _axe_format_outfile_path(config->out_prefixes[0], "unknown", 1, file_ext); name_rev = _axe_format_outfile_path(config->out_prefixes[1], "unknown", 2, file_ext); break; case READS_INTERLEAVED: name_fwd = _axe_format_outfile_path(config->out_prefixes[0], "unknown", 0, file_ext); name_rev = NULL; break; case READS_UNKNOWN: default: fprintf(stderr, "[make_outputs] Error: bad output mode %ui\n", config->out_mode); goto error; } config->unknown_output = axe_output_create(name_fwd, name_rev, config->out_mode, zmode); if (config->unknown_output == NULL) { fprintf(stderr, "[make_outputs] couldn't create file at %s\n", name_fwd); goto error; } qes_free(file_ext); qes_free(zmode); return 0; error: qes_free(name_fwd); qes_free(name_rev); qes_free(file_ext); qes_free(zmode); return 1; } int axe_load_tries(struct axe_config *config) { int ret = 1; if (!axe_config_ok(config)) { return -1; } if (config->match_combo) { ret = load_tries_combo(config); } else { ret = load_tries_single(config); } if (config->verbosity > 0) { fprintf(stderr, "[load_tries] (%s) Barcode tries loaded\n", nowstr()); } return ret; } static inline int write_barcoded_read_combo(struct axe_output *out, struct qes_seq *seq1, struct qes_seq *seq2, size_t bcd1_len, size_t bcd2_len) { int ret = 0; if (seq1->seq.len <= bcd1_len) { /* Truncate seqs to N */ seq1->seq.str[0] = 'N'; seq1->seq.str[1] = '\0'; seq1->seq.len = 1; /* Keep first qual 'base' */ seq1->qual.str[1] = '\0'; seq1->qual.len = 1; } if (seq2->seq.len <= bcd2_len) { /* Truncate seqs to N */ seq2->seq.str[0] = 'N'; seq2->seq.str[1] = '\0'; seq2->seq.len = 1; /* Keep first qual 'base' */ seq2->qual.str[1] = '\0'; seq2->qual.len = 1; } /* Bit of the ol' switcheroo. We keep the seq's char pointers, so we need to switch them back to their orig. values, but don't want to copy. Kludgy, I know. */ seq1->seq.str += bcd1_len; seq1->seq.len -= bcd1_len; seq1->qual.str += bcd1_len; seq1->qual.len -= bcd1_len; ret = qes_seqfile_write(out->fwd_file, seq1); if (ret < 1) { fprintf(stderr, "[process_file] Error: writing to fwd file %s failed\n%s\n", out->fwd_file->qf->path, qes_file_error(out->fwd_file->qf)); seq1->seq.str -= bcd1_len; seq1->seq.len += bcd1_len; seq1->qual.str -= bcd1_len; seq1->qual.len += bcd1_len; return 1; } seq1->seq.str -= bcd1_len; seq1->seq.len += bcd1_len; seq1->qual.str -= bcd1_len; seq1->qual.len += bcd1_len; seq2->seq.str += bcd2_len; seq2->seq.len -= bcd2_len; seq2->qual.str += bcd2_len; seq2->qual.len -= bcd2_len; if (out->mode == READS_INTERLEAVED) { ret = qes_seqfile_write(out->fwd_file, seq2); if (ret < 1) { fprintf(stderr, "[process_file] Error: writing to il file %s failed\n%s\n", out->fwd_file->qf->path, qes_file_error(out->fwd_file->qf)); return 1; } } else if (out->mode == READS_PAIRED) { ret = qes_seqfile_write(out->rev_file, seq2); if (ret < 1) { fprintf(stderr, "process_file -- Error: writing to rev file %s failed\n%s\n", out->rev_file->qf->path, qes_file_error(out->rev_file->qf)); return 1; } } seq2->seq.str -= bcd2_len; seq2->seq.len += bcd2_len; seq2->qual.str -= bcd2_len; seq2->qual.len += bcd2_len; return 0; } static inline void increment_reads_print_progress(struct axe_config *config) { config->reads_processed++; if (config->reads_processed % 100000 == 0) { if (config->verbosity >= 0) { axe_format_progress(config->logger, "%s: Processed %.1fM %s\r", nowstr(), (float)(config->reads_processed/1000000.0), config->out_mode == READS_SINGLE ? "reads" : "read pairs"); } } } static inline int process_read_pair_single(struct axe_config *config, struct qes_seq *seq1, struct qes_seq *seq2) { int ret = 0; ssize_t bcd = -1; size_t barcode_pair_index = 0; struct axe_output *outfile = NULL; size_t bcd_len = 0; ret = axe_match_read(config, &bcd, config->fwd_trie, seq1); increment_reads_print_progress(config); if (ret != 0) { /* No match */ qes_seqfile_write(config->unknown_output->fwd_file, seq1); if (seq2 != NULL) { if (config->out_mode == READS_INTERLEAVED) { qes_seqfile_write(config->unknown_output->fwd_file, seq2); } else { qes_seqfile_write(config->unknown_output->rev_file, seq2); } } config->reads_failed++; return 0; } /* Found a match */ config->reads_demultiplexed++; /* FIXME: we need to check bcd doesn't cause segfault */ barcode_pair_index = config->barcode_lookup[bcd][0]; outfile = config->outputs[barcode_pair_index]; bcd_len = config->barcodes[barcode_pair_index]->len1; config->barcodes[bcd]->count++; if (seq1->seq.len <= bcd_len) { /* Don't write out seqs shorter than the barcode */ return 0; } /* Bit of the ol' switcheroo. We keep the seq's char pointers, so we need * to switch them back to their orig. values, but don't want to copy. * Kludgy, I know. */ seq1->seq.str += bcd_len; seq1->seq.len -= bcd_len; seq1->qual.str += bcd_len; seq1->qual.len -= bcd_len; ret = qes_seqfile_write(outfile->fwd_file, seq1); if (ret < 1) { fprintf(stderr, "[write_read_single] Error: writing to R1 file %s failed\n%s\n", outfile->fwd_file->qf->path, qes_file_error(outfile->fwd_file->qf)); seq1->seq.str -= bcd_len; seq1->seq.len += bcd_len; seq1->qual.str -= bcd_len; seq1->qual.len += bcd_len; return 1; } seq1->seq.str -= bcd_len; seq1->seq.len += bcd_len; seq1->qual.str -= bcd_len; seq1->qual.len += bcd_len; /* And do the same with seq2, if we have one */ if (seq2 != NULL) { if (config->trim_rev) { seq2->seq.str += bcd_len; seq2->seq.len -= bcd_len; seq2->qual.str += bcd_len; seq2->qual.len -= bcd_len; } if (outfile->mode == READS_INTERLEAVED) { ret = qes_seqfile_write(outfile->fwd_file, seq2); if (ret < 1) { qes_log_format_fatal( config->logger, "process_file -- Writing to file %s failed\n%s\n", outfile->fwd_file->qf->path, qes_file_error(outfile->fwd_file->qf)); return 1; } } else if (outfile->mode == READS_PAIRED) { ret = qes_seqfile_write(outfile->rev_file, seq2); if (ret < 1) { qes_log_format_fatal( config->logger, "process_file -- Writing to file %s failed\n%s\n", outfile->rev_file->qf->path, qes_file_error(outfile->rev_file->qf)); return 1; } } if (config->trim_rev) { seq2->seq.str -= bcd_len; seq2->seq.len += bcd_len; seq2->qual.str -= bcd_len; seq2->qual.len += bcd_len; } } return 0; } static int process_file_single(struct axe_config *config) { struct qes_seqfile *fwdsf = NULL; struct qes_seqfile *revsf = NULL; int ret = 0; int retval = -1; if (!axe_config_ok(config)) { return -1; } fwdsf = qes_seqfile_create(config->infiles[0], "r"); if (fwdsf == NULL) { qes_log_format_fatal(config->logger, "process_file -- Couldn't open seqfile %s\n", config->infiles[0]); goto exit; } switch(config->in_mode) { case READS_SINGLE: goto single; break; case READS_INTERLEAVED: goto interleaved; break; case READS_PAIRED: revsf = qes_seqfile_create(config->infiles[1], "r"); if (revsf == NULL) { qes_log_format_fatal(config->logger, "process_file -- Couldn't open seqfile %s\n", config->infiles[1]); goto exit; } goto paired; break; case READS_UNKNOWN: default: qes_log_format_fatal(config->logger, "process_file_single -- Bad infile mode %u\n", config->in_mode); goto exit; break; } single: QES_SEQFILE_ITER_SINGLE_BEGIN(fwdsf, seq, seqlen) { ret = process_read_pair_single(config, seq, NULL); } QES_SEQFILE_ITER_SINGLE_END(seq); retval = ret == 0 ? 0 : 1; goto exit; interleaved: QES_SEQFILE_ITER_INTERLEAVED_BEGIN(fwdsf, seq1, seq2, seqlen1, seqlen2) { ret = process_read_pair_single(config, seq1, seq2); } QES_SEQFILE_ITER_INTERLEAVED_END(seq1, seq2); retval = ret == 0 ? 0 : 1; goto exit; paired: QES_SEQFILE_ITER_PAIRED_BEGIN(fwdsf, revsf, seq1, seq2, seqlen1, seqlen2) { ret = process_read_pair_single(config, seq1, seq2); } QES_SEQFILE_ITER_PAIRED_END(seq1, seq2); retval = ret == 0 ? 0 : 1; goto exit; exit: qes_seqfile_destroy(fwdsf); qes_seqfile_destroy(revsf); return retval; } static int process_read_pair_combo(struct axe_config *config, struct qes_seq *seq1, struct qes_seq *seq2) { ssize_t barcode_pair_index = 0; intptr_t bcd1 = -1; intptr_t bcd2 = -1; int r1_ret = 0; int r2_ret = 0; size_t bcd1_len = 0; size_t bcd2_len = 0; struct axe_output *outfile = NULL; r1_ret = axe_match_read(config, &bcd1, config->fwd_trie, seq1); r2_ret = axe_match_read(config, &bcd2, config->rev_trie, seq2); increment_reads_print_progress(config); if (r1_ret != 0 || r2_ret != 0) { /* No match */ qes_seqfile_write(config->unknown_output->fwd_file, seq1); if (config->out_mode == READS_INTERLEAVED) { qes_seqfile_write(config->unknown_output->fwd_file, seq2); } else { qes_seqfile_write(config->unknown_output->rev_file, seq2); } config->reads_failed++; return 0; } /* Found a match */ barcode_pair_index = config->barcode_lookup[bcd1][bcd2]; if (barcode_pair_index < 0) { /* Invalid match */ qes_seqfile_write(config->unknown_output->fwd_file, seq1); if (config->out_mode == READS_INTERLEAVED) { qes_seqfile_write(config->unknown_output->fwd_file, seq2); } else { qes_seqfile_write(config->unknown_output->rev_file, seq2); } config->reads_failed++; return 0; } config->reads_demultiplexed++; outfile = config->outputs[barcode_pair_index]; bcd1_len = config->barcodes[barcode_pair_index]->len1; bcd2_len = config->barcodes[barcode_pair_index]->len2; config->barcodes[barcode_pair_index]->count++; return write_barcoded_read_combo(outfile, seq1, seq2, bcd1_len, bcd2_len); } static int process_file_combo(struct axe_config *config) { struct qes_seqfile *fwdsf = NULL; struct qes_seqfile *revsf = NULL; int have_error = 0; if (!axe_config_ok(config)) { return -1; } fwdsf = qes_seqfile_create(config->infiles[0], "r"); if (fwdsf == NULL) { qes_log_format_fatal(config->logger, "process_file -- Couldn't open seqfile %s\n", config->infiles[0]); goto error; } switch(config->in_mode) { case READS_INTERLEAVED: goto interleaved; break; case READS_PAIRED: revsf = qes_seqfile_create(config->infiles[1], "r"); if (revsf == NULL) { qes_log_format_fatal(config->logger, "process_file -- Couldn't open seqfile %s\n", config->infiles[0]); goto error; } goto paired; break; case READS_SINGLE: case READS_UNKNOWN: default: qes_log_format_fatal(config->logger, "process_file_combo -- Bad infile mode %u\n", config->in_mode); goto error; break; } interleaved: QES_SEQFILE_ITER_INTERLEAVED_BEGIN(fwdsf, seq1, seq2, seqlen1, seqlen2) if (process_read_pair_combo(config, seq1, seq2)) { have_error = 1; break; } QES_SEQFILE_ITER_INTERLEAVED_END(seq1, seq2) if (!have_error) goto clean_exit; else goto error; paired: QES_SEQFILE_ITER_PAIRED_BEGIN(fwdsf, revsf, seq1, seq2, seqlen1, seqlen2) if (process_read_pair_combo(config, seq1, seq2)) { have_error = 1; break; } QES_SEQFILE_ITER_PAIRED_END(seq1, seq2) if (!have_error) goto clean_exit; else goto error; clean_exit: qes_seqfile_destroy(fwdsf); qes_seqfile_destroy(revsf); return 0; error: qes_seqfile_destroy(fwdsf); qes_seqfile_destroy(revsf); return 1; } int axe_process_file(struct axe_config *config) { int ret = 0; clock_t start = 0; if (!axe_config_ok(config)) { return -1; } start = clock(); if (config->verbosity >= 0) { axe_format_bold(config->logger, "process_file -- (%s) Starting demultiplexing\n", nowstr()); } if (config->match_combo) { ret = process_file_combo(config); } else { ret = process_file_single(config); } config->time_taken = (float)(clock() - start) / CLOCKS_PER_SEC; if (config->verbosity >= 0) { /* Jump to new line so we don't clobber the progress bar */ fprintf(stderr, "\n"); axe_format_bold(config->logger, "process_file -- (%s) Finished demultiplexing\n", nowstr()); } return ret; } int product(int64_t len, int64_t elem, uintptr_t *choices, int at_start) { ssize_t iii = 0; if (len < elem || choices == NULL) { /* error value, so don't use (!ret) as your test for the end of the enclosing while loop, or on error you'll have an infinite loop */ return -1; } if (at_start) { /* [0, 0, ..., 0] is a valid set */ return 1; } iii = elem - 1; while (iii >= 0) { if (choices[iii] < (uintptr_t)(len - 1)) { /* Woo, we've found something to increment. */ ssize_t jjj; /* Increment this choice */ choices[iii]++; /* fill forwards with 0. */ for (jjj = iii + 1; jjj < elem; jjj++) { choices[jjj] = 0; } return 1; } iii--; } for (iii = 0; iii < elem; iii++) { choices[iii] = 0llu; } return 0; } char ** hamming_mutate_dna(size_t *n_results_o, const char *str, size_t len, unsigned int dist, int keep_original) { const char alphabet[] = "ACGT"; const size_t n_letters = 4; char *tmp = NULL; char **result = NULL; size_t results = 0; size_t results_alloced = 64; size_t iii; uintptr_t *alphabet_indicies; int alpha_ret = 0; gsl_combination *mut_idx_comb; if (str == NULL || len < 1 || dist < 1) { return NULL; } result = qes_malloc(results_alloced * sizeof(*result)); alphabet_indicies = qes_calloc(dist, sizeof(*alphabet_indicies)); mut_idx_comb = gsl_combination_calloc(len, dist); do { while ((alpha_ret = product(n_letters, dist, alphabet_indicies, !alpha_ret)) == 1) { tmp = strndup(str, len+1); for (iii = 0; iii < dist; iii++) { char replacement = alphabet[alphabet_indicies[iii]]; size_t mut_idx = gsl_combination_get(mut_idx_comb, iii); if (tmp[mut_idx] == replacement) { continue; } tmp[mut_idx] = replacement; } if (strncmp(str, tmp, len) == 0 && !keep_original) { qes_free(tmp); continue; } else { if (results + 1 > results_alloced) { results_alloced = qes_roundupz(results_alloced); result = qes_realloc(result, results_alloced * sizeof(*result)); } result[results++] = strndup(tmp, len); qes_free(tmp); } } } while (gsl_combination_next(mut_idx_comb) == GSL_SUCCESS); gsl_combination_free(mut_idx_comb); qes_free(alphabet_indicies); *n_results_o = results; return result; } struct axe_trie * axe_trie_create(void) { struct axe_trie *trie = NULL; AlphaMap *map = alpha_map_new(); int ret = 0; /* Make trie AlphaMap */ if (map == NULL) { return NULL; } #define _AM_ADD(chr) \ ret = alpha_map_add_range(map, chr, chr); \ if (ret != 0) { \ fprintf(stderr, "[trie_create] Failed to add char %c to alphamap\n",\ chr); \ alpha_map_free(map); \ return NULL; \ } _AM_ADD('A') _AM_ADD('C') _AM_ADD('G') _AM_ADD('T') _AM_ADD('N') #undef _AM_ADD trie = qes_calloc(1, sizeof(*trie)); trie->trie = trie_new(map); if (trie->trie == NULL) { qes_free(trie); alpha_map_free(map); return NULL; } alpha_map_free(map); return trie; } void axe_trie_destroy_(struct axe_trie *trie) { if (trie != NULL) { /* trie_free doesn't check for null, so we better */ if (trie->trie != NULL) { trie_free(trie->trie); } qes_free(trie); } } inline int axe_trie_get(struct axe_trie *trie, const char *str, intptr_t *data) { if (!axe_trie_ok(trie) || str == NULL) return -1; return trie_retrieve(trie->trie, str, data); } inline int axe_trie_delete(struct axe_trie *trie, const char *str) { if (!axe_trie_ok(trie) || str == NULL) return -1; return trie_delete(trie->trie, str); } inline int axe_trie_add(struct axe_trie *trie, const char *str, intptr_t data) { if (!axe_trie_ok(trie) || str == NULL) return -1; if (trie_store_if_absent(trie->trie, str, data)) { return 0; } return 1; } inline int axe_match_read (struct axe_config *config, ssize_t *value, struct axe_trie *trie, const struct qes_seq *seq) { TrieState *trie_iter = NULL; TrieState *last_good_state = NULL; size_t seq_pos = 0; /* value is set to -1 on anything bad happening including failed lookup */ if (value == NULL || !axe_trie_ok(trie) || !qes_seq_ok(seq)) { return -1; } /* Set *value here, then we just don't update it on error */ *value = -1; if (seq->seq.len < trie->min_len) { return 1; } /* Only look until the maximum of the largest barcode, or seq len */ /* Grab tree root iter, and check it. */ trie_iter = trie_root(trie->trie); if (trie_iter == NULL) { qes_log_message_fatal(config->logger, "match_read -- trie_root() returned NULL!\n"); return -1; } /* Consume seq until we can't */ do { trie_state_walk(trie_iter, seq->seq.str[seq_pos]); if (trie_state_is_terminal(trie_iter)) { if (last_good_state != NULL) { trie_state_free(last_good_state); } last_good_state = trie_state_clone(trie_iter); } } while (trie_state_is_walkable(trie_iter, seq->seq.str[++seq_pos])); /* If we get to a terminal state, then great! */ if (trie_state_is_terminal(trie_iter)) { trie_state_walk(trie_iter, '\0'); trie_state_free(last_good_state); *value = (ssize_t) trie_state_get_data(trie_iter); trie_state_free(trie_iter); return 0; } else if (last_good_state != NULL) { trie_state_free(trie_iter); trie_state_walk(last_good_state, '\0'); *value = (ssize_t) trie_state_get_data(last_good_state); trie_state_free(last_good_state); return 0; } trie_state_free(trie_iter); if (last_good_state != NULL) { trie_state_free(last_good_state); } return 1; } int axe_write_table(const struct axe_config *config) { FILE *tab_fp = NULL; struct axe_barcode *this_bcd = NULL; size_t iii = 0; int res = 0; if (!axe_config_ok(config)) { return -1; } if (config->table_file == NULL) { /* we always call this function in the main loop, so we bail out here if we don't have a file to write it to. */ return 0; } tab_fp = fopen(config->table_file, "w"); if (tab_fp == NULL) { qes_log_format_fatal(config->logger, "write_table -- ERROR: Could not open %s\n%s\n", config->table_file, strerror(errno)); return 1; } if (config->match_combo) { fprintf(tab_fp, "R1Barcode\tR2Barcode\tSample\tCount\n"); } else { fprintf(tab_fp, "Barcode\tSample\tCount\n"); } for (iii = 0; iii < config->n_barcode_pairs; iii++) { this_bcd = config->barcodes[iii]; if (config->match_combo) { fprintf(tab_fp, "%s\t%s\t%s\t%" PRIu64 "\n", this_bcd->seq1, this_bcd->seq2, this_bcd->id, this_bcd->count); } else { fprintf(tab_fp, "%s\t%s\t%" PRIu64 "\n", this_bcd->seq1, this_bcd->id, this_bcd->count); } } if (config->match_combo) { fprintf(tab_fp, "N\tN\tNo Barcode\t%" PRIu64 "\n", config->reads_failed); } else { fprintf(tab_fp, "N\tNo Barcode\t%" PRIu64 "\n", config->reads_failed); } res = fclose(tab_fp); if (res != 0) { qes_log_format_error(config->logger, "[write_table] Couldn't close tab file %s\n%s\n", config->table_file, strerror(errno)); return 1; } return 0; } int axe_print_summary(const struct axe_config *config) { const char *tmp; #define million(r) ((float)(r / 1000000.0)) if (!axe_config_ok(config)) { return -1; } if (config->verbosity < 0) { /* Say nothing if we're being quiet */ return 0; } axe_message_bold(config->logger, "\nRun Summary:\n"); if (config->verbosity > 1) { qes_log_message_debug(config->logger, "Being verbose (not that you'll notice)\n"); } tmp = config->out_mode == READS_SINGLE ? "reads" : "read pairs"; axe_format_bold(config->logger, "Processed %.2fM %s in %0.1f seconds (%0.1fK %s/sec)\n", million(config->reads_processed), tmp, config->time_taken, (float)(config->reads_processed / 1000) / config->time_taken, tmp); axe_format_bold(config->logger, "%.2fM %s contained valid barcodes\n", million(config->reads_demultiplexed), tmp); axe_format_bold(config->logger, "%.2fM %s could not be demultiplexed (%0.1f%%)\n", million(config->reads_failed), tmp, ((float)config->reads_failed/(float)(config->reads_processed)*100.0)); return 0; } axe-0.3.1/src/axe.h000066400000000000000000000241541263567001600140210ustar00rootroot00000000000000/* * ============================================================================ * * Filename: axe.h * Description: Demultiplex reads by 5' barcodes * Copyright: 2014-2015 Kevin Murray * License: GNU GPL v3+ * * This program is free software: you can 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 . * * ============================================================================ */ #ifndef AXE_H #define AXE_H #include #include #include #include #include #include #include #include #include #include "datrie/trie.h" #include "datrie/alpha-map.h" #include "axe_config.h" /* General rules: * Most functions are declared as `int X(...);`. These functions return: * -1 on parameter error (NULLs, bad values etc) * 0 on success * 1 on failure * Thus, one can check success with ret = X(...); if (ret != 0) {panic();} * If a function returns a pointer, NULL is the error value. */ enum read_mode { READS_UNKNOWN = 0, READS_SINGLE = 1, READS_PAIRED = 2, READS_INTERLEAVED = 3, }; struct axe_output { struct qes_seqfile *fwd_file; struct qes_seqfile *rev_file; enum read_mode mode; }; struct axe_trie { Trie *trie; /* From datrie.h */ int mismatch_level; size_t max_len; size_t min_len; }; struct axe_barcode { char *seq1; char *seq2; char *id; size_t len1; size_t len2; size_t idlen; uint64_t count; }; struct axe_config { char *barcode_file; char *table_file; char *infiles[2]; char *out_prefixes[2]; struct axe_barcode **barcodes; struct axe_output **outputs; /* Array of output files. Access by bcd_lookup[1st_bcd_idx][2nd_bcd_idx] Values will be 0 <= x < n_barcode_pairs. barcodes or outputs can then be indexed w/ this number */ ssize_t **barcode_lookup; size_t *mismatch_counts; size_t n_barcodes_1; /* Number of first read barcodes */ size_t n_barcodes_2; /* Number of second read barcodes */ size_t n_barcode_pairs; struct axe_output *unknown_output; /* output for unknown files */ struct axe_trie *fwd_trie; struct axe_trie *rev_trie; struct qes_logger *logger; enum read_mode in_mode; enum read_mode out_mode; int out_compress_level; size_t mismatches; uint64_t reads_processed; uint64_t reads_demultiplexed; uint64_t reads_failed; float time_taken; int verbosity; int have_cli_opts :1; /* Set to 1 once CLI is parsed */ int match_combo :1; /* Match using combinatorial strategy */ int permissive :1; /* Don't error on mutated bcd confict */ int trim_rev :1; /* Trim rev read same as fwd read */ int debug :1; /* Enable debug mode */ }; extern unsigned int format_call_number; char * axe_formatter(struct qes_log_entry *entry); #define AXE_LOG_PROGRESS 11 #define axe_format_progress(log, fmt, ...) \ qes_log_format(log, AXE_LOG_PROGRESS, fmt, __VA_ARGS__) #define axe_message_progress(log, msg) \ qes_log_message(log, AXE_LOG_PROGRESS, msg) #define AXE_LOG_BOLD 12 #define axe_format_bold(log, fmt, ...) \ qes_log_format(log, AXE_LOG_BOLD, fmt, __VA_ARGS__) #define axe_message_bold(log, msg) \ qes_log_message(log, AXE_LOG_BOLD, msg) static inline int axe_config_ok(const struct axe_config *config) { if (config == NULL) return 0; return 1; } static inline int axe_trie_ok(const struct axe_trie *trie) { if (trie == NULL) return 0; if (trie->trie == NULL) return 0; if (trie->min_len > trie->max_len) return 0; return 1; } static inline int axe_barcode_ok(const struct axe_barcode *barcode) { if (barcode == NULL) return 0; if (barcode->seq1 == NULL || barcode->len1 == 0) return 0; if (barcode->id == NULL || barcode->idlen == 0) return 0; return 1; } static inline int axe_barcode_ok_combo(const struct axe_barcode *barcode) { if (barcode == NULL) return 0; if (barcode->seq1 == NULL || barcode->len1 == 0) return 0; if (barcode->seq2 == NULL || barcode->len2 == 0) return 0; if (barcode->id == NULL || barcode->idlen == 0) return 0; return 1; } static inline int axe_output_ok(const struct axe_output *output) { if (output == NULL) return 0; if (output->mode == READS_UNKNOWN) return 0; if (output->fwd_file == NULL) return 0; if (output->mode == READS_PAIRED && output->rev_file == NULL) return 0; return 1; } /*=== FUNCTION ============================================================* Name: axe_config_create Parameters: void Description: Create a struct axe_config on the heap and initialise members to empty/null values. Returns: struct axe_config *: A valid, empty struct axe_config, or NULL on any error. *===========================================================================*/ struct axe_config *axe_config_create(void); /*=== FUNCTION ============================================================* Name: axe_config_destroy Parameters: struct axe_config *: config struct on heap to destroy. Description: Destroy a ``struct axe_config`` on the heap, and set its pointer variable to NULL; Returns: void *===========================================================================*/ void axe_config_destroy_(struct axe_config *config); #define axe_config_destroy(cfg) STMT_BEGIN \ axe_config_destroy_(cfg); \ cfg = NULL; \ STMT_END /*=== FUNCTION ============================================================* Name: axe_output_create Parameters: const char *fwd_fpath: Forwards/interleaved read filepath const char *rev_fpath: Reverse read filepath enum read_mode mode: Output mode const char *fp_mode: qes_fopen() mode specifier. See /usr/include/zlib.h for valid values. Description: Creates and opens file members of a struct axe_output Returns: struct axe_output *: A valid struct axe_output, or NULL on failure of any kind *===========================================================================*/ struct axe_output *axe_output_create(const char *fwd_fpath, const char *rev_fpath, enum read_mode mode, const char *fp_mode); /*=== FUNCTION ============================================================* Name: axe_output_destroy Parameters: struct axe_output *: output struct on heap to destroy. Description: Destroy a ``struct axe_output`` on the heap, and set its pointer variable to NULL; Returns: void *===========================================================================*/ void axe_output_destroy_(struct axe_output *output); #define axe_output_destroy(out) STMT_BEGIN \ axe_output_destroy_(out); \ out = NULL; \ STMT_END struct axe_trie *axe_trie_create(void); extern int axe_trie_get(struct axe_trie *trie, const char *str, intptr_t *data); extern int axe_trie_add(struct axe_trie *trie, const char *str, intptr_t data); extern int axe_trie_delete(struct axe_trie *trie, const char *str); /*=== FUNCTION ============================================================* Name: axe_trie_destroy Parameters: struct axe_trie *: trie struct on heap to destroy. Description: Destroy a ``struct axe_trie`` on the heap, and set its pointer variable to NULL; Returns: void *===========================================================================*/ void axe_trie_destroy_(struct axe_trie *trie); #define axe_trie_destroy(trie) STMT_BEGIN \ axe_trie_destroy_(trie); \ trie = NULL; \ STMT_END struct axe_barcode *axe_barcode_create(void); void axe_barcode_destroy_(struct axe_barcode *barcode); #define axe_barcode_destroy(barcode) STMT_BEGIN \ axe_barcode_destroy_(barcode); \ barcode = NULL; \ STMT_END /* This is the processing pipeline. These functions should be run in this order */ int axe_read_barcodes(struct axe_config *config); int axe_setup_barcode_lookup(struct axe_config *config); int axe_make_tries(struct axe_config *config); int axe_load_tries(struct axe_config *config); int axe_make_outputs(struct axe_config *config); int axe_process_file(struct axe_config *config); int axe_write_table(const struct axe_config *config); int axe_print_summary(const struct axe_config *config); /* Libraries or inner functions */ extern int axe_match_read(struct axe_config *config, intptr_t *value, struct axe_trie *trie, const struct qes_seq *seq); int product(int64_t len, int64_t elem, uintptr_t *choices, int at_start); char **hamming_mutate_dna(size_t *n_results_o, const char *str, size_t len, unsigned int dist, int keep_original); extern char _time_now[]; static inline const char * nowstr(void) { time_t rawtime; time(&rawtime); strftime(_time_now, 10, "%H:%M:%S", localtime(&rawtime)); return _time_now; } #endif /* AXE_H */ axe-0.3.1/src/axe_config.h.in000066400000000000000000000021341263567001600157450ustar00rootroot00000000000000/* * ============================================================================ * * Filename: axe_config.h.in * Description: Pull in build system definitions * Copyright: 2014-2015 Kevin Murray * License: GNU GPL v3+ * * This program is free software: you can 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 . * * ============================================================================ */ #ifndef AXE_CONFIG_H #define AXE_CONFIG_H #define AXE_VERSION "${AXE_VERSION}" #endif /* AXE_CONFIG_H */ axe-0.3.1/src/datrie/000077500000000000000000000000001263567001600143355ustar00rootroot00000000000000axe-0.3.1/src/datrie/alpha-map-private.h000066400000000000000000000033351263567001600200220ustar00rootroot00000000000000/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * libdatrie - Double-Array Trie Library * Copyright (C) 2006 Theppitak Karoonboonyanan * * 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 */ /* * alpha-map-private.h - private APIs for alpha-map * Created: 2008-12-04 * Author: Theppitak Karoonboonyanan */ #ifndef __ALPHA_MAP_PRIVATE_H #define __ALPHA_MAP_PRIVATE_H #include #include "alpha-map.h" TrieIndex alpha_map_char_to_trie (const AlphaMap *alpha_map, AlphaChar ac); AlphaChar alpha_map_trie_to_char (const AlphaMap *alpha_map, TrieChar tc); TrieChar * alpha_map_char_to_trie_str (const AlphaMap *alpha_map, const AlphaChar *str); AlphaChar * alpha_map_trie_to_char_str (const AlphaMap *alpha_map, const TrieChar *str); #endif /* __ALPHA_MAP_PRIVATE_H */ /* vi:ts=4:ai:expandtab */ axe-0.3.1/src/datrie/alpha-map.c000066400000000000000000000220161263567001600163420ustar00rootroot00000000000000/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * libdatrie - Double-Array Trie Library * Copyright (C) 2006 Theppitak Karoonboonyanan * * 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 */ /* * alpha-map.c - map between character codes and trie alphabet * Created: 2006-08-19 * Author: Theppitak Karoonboonyanan */ #include #include #include #include #include #include "alpha-map.h" #include "alpha-map-private.h" /** * @brief Alphabet string length * * @param str : the array of null-terminated AlphaChar string to measure * * @return the total characters in @a str. */ int alpha_char_strlen (const AlphaChar *str) { const AlphaChar *p; for (p = str; *p; p++) ; return p - str; } /** * @brief Compare alphabet strings * * @param str1, str2 : the arrays of null-terminated AlphaChar strings * to compare * * @return negative if @a str1 < @a str2; * 0 if @a str1 == @a str2; * positive if @a str1 > @a str2 * * Available since: 0.2.7 */ int alpha_char_strcmp (const AlphaChar *str1, const AlphaChar *str2) { while (*str1 && *str1 == *str2) { str1++; str2++; } if (*str1 < *str2) return -1; if (*str1 > *str2) return 1; return 0; } /*------------------------------* * PRIVATE DATA DEFINITONS * *------------------------------*/ typedef struct _AlphaRange { struct _AlphaRange *next; AlphaChar begin; AlphaChar end; } AlphaRange; struct _AlphaMap { AlphaRange *first_range; }; /*-----------------------------* * METHODS IMPLEMENTAIONS * *-----------------------------*/ #define ALPHAMAP_SIGNATURE 0xD9FCD9FC /* AlphaMap Header: * - INT32: signature * - INT32: total ranges * * Ranges: * - INT32: range begin * - INT32: range end */ /** * @brief Create new alphabet map * * @return a pointer to the newly created alphabet map, NULL on failure * * Create a new empty alphabet map. The map contents can then be added with * alpha_map_add_range(). * * The created object must be freed with alpha_map_free(). */ AlphaMap * alpha_map_new (void) { AlphaMap *alpha_map; alpha_map = (AlphaMap *) malloc (sizeof (AlphaMap)); if (!alpha_map) return NULL; alpha_map->first_range = NULL; return alpha_map; } /** * @brief Create a clone of alphabet map * * @param a_map : the source alphabet map to clone * * @return a pointer to the alphabet map clone, NULL on failure * * The created object must be freed with alpha_map_free(). */ AlphaMap * alpha_map_clone (const AlphaMap *a_map) { AlphaMap *alpha_map; AlphaRange *range; alpha_map = alpha_map_new (); if (!alpha_map) return NULL; for (range = a_map->first_range; range; range = range->next) { if (alpha_map_add_range (alpha_map, range->begin, range->end) != 0) { alpha_map_free (alpha_map); return NULL; } } return alpha_map; } /** * @brief Free an alphabet map object * * @param alpha_map : the alphabet map object to free * * Destruct the @a alpha_map and free its allocated memory. */ void alpha_map_free (AlphaMap *alpha_map) { AlphaRange *p, *q; p = alpha_map->first_range; while (p) { q = p->next; free (p); p = q; } free (alpha_map); } /** * @brief Add a range to alphabet map * * @param alpha_map : the alphabet map object * @param begin : the first character of the range * @param end : the last character of the range * * @return 0 on success, non-zero on failure * * Add a range of character codes from @a begin to @a end to the * alphabet set. */ int alpha_map_add_range (AlphaMap *alpha_map, AlphaChar begin, AlphaChar end) { AlphaRange *q, *r, *begin_node, *end_node; if (begin > end) return -1; begin_node = end_node = 0; /* Skip first ranges till 'begin' is covered */ for (q = 0, r = alpha_map->first_range; r && r->begin <= begin; q = r, r = r->next) { if (begin <= r->end) { /* 'r' covers 'begin' -> take 'r' as beginning point */ begin_node = r; break; } if (r->end + 1 == begin) { /* 'begin' is next to 'r'-end * -> extend 'r'-end to cover 'begin' */ r->end = begin; begin_node = r; break; } } if (!begin_node && r && r->begin <= end + 1) { /* ['begin', 'end'] overlaps into 'r'-begin * or 'r' is next to 'end' if r->begin == end + 1 * -> extend 'r'-begin to include the range */ r->begin = begin; begin_node = r; } /* Run upto the first range that exceeds 'end' */ while (r && r->begin <= end + 1) { if (end <= r->end) { /* 'r' covers 'end' -> take 'r' as ending point */ end_node = r; } else if (r != begin_node) { /* ['begin', 'end'] covers the whole 'r' -> remove 'r' */ if (q) { q->next = r->next; free (r); r = q->next; } else { alpha_map->first_range = r->next; free (r); r = alpha_map->first_range; } continue; } q = r; r = r->next; } if (!end_node && q && begin <= q->end) { /* ['begin', 'end'] overlaps 'q' at the end * -> extend 'q'-end to include the range */ q->end = end; end_node = q; } if (begin_node && end_node) { if (begin_node != end_node) { /* Merge begin_node and end_node ranges together */ assert (begin_node->next == end_node); begin_node->end = end_node->end; begin_node->next = end_node->next; free (end_node); } } else if (!begin_node && !end_node) { /* ['begin', 'end'] overlaps with none of the ranges * -> insert a new range */ AlphaRange *range = (AlphaRange *) malloc (sizeof (AlphaRange)); if (!range) return -1; range->begin = begin; range->end = end; /* insert it between 'q' and 'r' */ if (q) { q->next = range; } else { alpha_map->first_range = range; } range->next = r; } return 0; } TrieIndex alpha_map_char_to_trie (const AlphaMap *alpha_map, AlphaChar ac) { TrieIndex alpha_begin; AlphaRange *range; if (0 == ac) return 0; alpha_begin = 1; for (range = alpha_map->first_range; range; range = range->next) { if (range->begin <= ac && ac <= range->end) return alpha_begin + (ac - range->begin); alpha_begin += range->end - range->begin + 1; } return TRIE_INDEX_MAX; } AlphaChar alpha_map_trie_to_char (const AlphaMap *alpha_map, TrieChar tc) { TrieChar alpha_begin; AlphaRange *range; if (0 == tc) return 0; alpha_begin = 1; for (range = alpha_map->first_range; range; range = range->next) { if (tc <= alpha_begin + (range->end - range->begin)) return range->begin + (tc - alpha_begin); alpha_begin += range->end - range->begin + 1; } return ALPHA_CHAR_ERROR; } TrieChar * alpha_map_char_to_trie_str (const AlphaMap *alpha_map, const AlphaChar *str) { TrieChar *trie_str, *p; trie_str = (TrieChar *) malloc (alpha_char_strlen (str) + 1); if (!trie_str) return NULL; for (p = trie_str; *str; p++, str++) { TrieIndex tc = alpha_map_char_to_trie (alpha_map, *str); if (TRIE_INDEX_MAX == tc) goto error_str_allocated; *p = (TrieChar) tc; } *p = 0; return trie_str; error_str_allocated: free (trie_str); return NULL; } AlphaChar * alpha_map_trie_to_char_str (const AlphaMap *alpha_map, const TrieChar *str) { AlphaChar *alpha_str, *p; alpha_str = (AlphaChar *) malloc ((strlen ((const char *)str) + 1) * sizeof (AlphaChar)); if (!alpha_str) return NULL; for (p = alpha_str; *str; p++, str++) { *p = (AlphaChar) alpha_map_trie_to_char (alpha_map, *str); } *p = 0; return alpha_str; } /* vi:ts=4:ai:expandtab */ axe-0.3.1/src/datrie/alpha-map.h000066400000000000000000000055341263567001600163550ustar00rootroot00000000000000/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * libdatrie - Double-Array Trie Library * Copyright (C) 2006 Theppitak Karoonboonyanan * * 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 */ /* * alpha-map.h - map between character codes and trie alphabet * Created: 2006-08-19 * Author: Theppitak Karoonboonyanan */ #ifndef __ALPHA_MAP_H #define __ALPHA_MAP_H #include #include "typedefs.h" #include "triedefs.h" #ifdef __cplusplus extern "C" { #endif /** * @file alpha-map.h * @brief AlphaMap data type and functions * * AlphaMap is a mapping between AlphaChar and TrieChar. AlphaChar is the * alphabet character used in words of a target language, while TrieChar * is a small integer with packed range of values and is actually used in * trie state transition calculations. * * Since double-array trie relies on sparse state transition table, * a small set of input characters can make the table small, i.e. with * small number of columns. But in real life, alphabet characters can be * of non-continuous range of values. The unused slots between them can * waste the space in the table, and can increase the chance of unused * array cells. * * AlphaMap is thus defined for mapping between non-continuous ranges of * values of AlphaChar and packed and continuous range of Triechar. * * In this implementation, TrieChar is defined as a single-byte integer, * which means the largest AlphaChar set that is supported is of 255 * values, as the special value of 0 is reserved for null-termination code. */ /** * @brief AlphaMap data type */ typedef struct _AlphaMap AlphaMap; AlphaMap * alpha_map_new (void); AlphaMap * alpha_map_clone (const AlphaMap *a_map); void alpha_map_free (AlphaMap *alpha_map); int alpha_map_add_range (AlphaMap *alpha_map, AlphaChar begin, AlphaChar end); int alpha_char_strlen (const AlphaChar *str); int alpha_char_strcmp (const AlphaChar *str1, const AlphaChar *str2); #ifdef __cplusplus } #endif #endif /* __ALPHA_MAP_H */ /* vi:ts=4:ai:expandtab */ axe-0.3.1/src/datrie/darray.c000066400000000000000000000460431263567001600157720ustar00rootroot00000000000000/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * libdatrie - Double-Array Trie Library * Copyright (C) 2006 Theppitak Karoonboonyanan * * 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 */ /* * darray.c - Double-array trie structure * Created: 2006-08-13 * Author: Theppitak Karoonboonyanan */ #include #include #ifndef _MSC_VER /* for SIZE_MAX */ # include #endif #include #include "trie-private.h" #include "darray.h" /*----------------------------------* * INTERNAL TYPES DECLARATIONS * *----------------------------------*/ struct _Symbols { short num_symbols; TrieChar symbols[256]; }; #define symbols_add_fast(s,c) ((s)->symbols[(s)->num_symbols++] = c) /*-----------------------------------* * PRIVATE METHODS DECLARATIONS * *-----------------------------------*/ #define da_get_free_list(d) (1) static bool da_check_free_cell (DArray *d, TrieIndex s); static bool da_has_children (const DArray *d, TrieIndex s); static TrieIndex da_find_free_base (DArray *d, const Symbols *symbols); static bool da_fit_symbols (DArray *d, TrieIndex base, const Symbols *symbols); static void da_relocate_base (DArray *d, TrieIndex s, TrieIndex new_base); static bool da_extend_pool (DArray *d, TrieIndex to_index); static void da_alloc_cell (DArray *d, TrieIndex cell); static void da_free_cell (DArray *d, TrieIndex cell); /* ==================== BEGIN IMPLEMENTATION PART ==================== */ /*------------------------------------* * INTERNAL TYPES IMPLEMENTATIONS * *------------------------------------*/ Symbols * symbols_new (void) { Symbols *syms; syms = (Symbols *) malloc (sizeof (Symbols)); if (!syms) return NULL; syms->num_symbols = 0; return syms; } void symbols_free (Symbols *syms) { free (syms); } void symbols_add (Symbols *syms, TrieChar c) { short lower, upper; lower = 0; upper = syms->num_symbols; while (lower < upper) { short middle; middle = (lower + upper)/2; if (c > syms->symbols[middle]) lower = middle + 1; else if (c < syms->symbols[middle]) upper = middle; else return; } if (lower < syms->num_symbols) { memmove (syms->symbols + lower + 1, syms->symbols + lower, syms->num_symbols - lower); } syms->symbols[lower] = c; syms->num_symbols++; } int symbols_num (const Symbols *syms) { return syms->num_symbols; } TrieChar symbols_get (const Symbols *syms, int index) { return syms->symbols[index]; } /*------------------------------* * PRIVATE DATA DEFINITONS * *------------------------------*/ typedef struct { TrieIndex base; TrieIndex check; } DACell; struct _DArray { TrieIndex num_cells; DACell *cells; }; /*-----------------------------* * METHODS IMPLEMENTAIONS * *-----------------------------*/ #define DA_SIGNATURE 0xDAFCDAFC /* DA Header: * - Cell 0: SIGNATURE, number of cells * - Cell 1: free circular-list pointers * - Cell 2: root node * - Cell 3: DA pool begin */ #define DA_POOL_BEGIN 3 /** * @brief Create a new double-array object * * Create a new empty doubla-array object. */ DArray * da_new (void) { DArray *d; d = (DArray *) malloc (sizeof (DArray)); if (!d) return NULL; d->num_cells = DA_POOL_BEGIN; d->cells = (DACell *) malloc (d->num_cells * sizeof (DACell)); if (!d->cells) goto exit_da_created; d->cells[0].base = DA_SIGNATURE; d->cells[0].check = d->num_cells; d->cells[1].base = -1; d->cells[1].check = -1; d->cells[2].base = DA_POOL_BEGIN; d->cells[2].check = 0; return d; exit_da_created: free (d); return NULL; } /** * @brief Free double-array data * * @param d : the double-array data * * Free the given double-array data. */ void da_free (DArray *d) { free (d->cells); free (d); } /** * @brief Get root state * * @param d : the double-array data * * @return root state of the @a index set, or TRIE_INDEX_ERROR on failure * * Get root state for stepwise walking. */ TrieIndex da_get_root (const DArray *d) { (void) d; /* can be calculated value for multi-index trie */ return 2; } /** * @brief Get BASE cell * * @param d : the double-array data * @param s : the double-array state to get data * * @return the BASE cell value for the given state * * Get BASE cell value for the given state. */ TrieIndex da_get_base (const DArray *d, TrieIndex s) { return (s < d->num_cells) ? d->cells[s].base : TRIE_INDEX_ERROR; } /** * @brief Get CHECK cell * * @param d : the double-array data * @param s : the double-array state to get data * * @return the CHECK cell value for the given state * * Get CHECK cell value for the given state. */ TrieIndex da_get_check (const DArray *d, TrieIndex s) { return (s < d->num_cells) ? d->cells[s].check : TRIE_INDEX_ERROR; } /** * @brief Set BASE cell * * @param d : the double-array data * @param s : the double-array state to get data * @param val : the value to set * * Set BASE cell for the given state to the given value. */ void da_set_base (DArray *d, TrieIndex s, TrieIndex val) { if (s < d->num_cells) { d->cells[s].base = val; } } /** * @brief Set CHECK cell * * @param d : the double-array data * @param s : the double-array state to get data * @param val : the value to set * * Set CHECK cell for the given state to the given value. */ void da_set_check (DArray *d, TrieIndex s, TrieIndex val) { if (s < d->num_cells) { d->cells[s].check = val; } } /** * @brief Walk in double-array structure * * @param d : the double-array structure * @param s : current state * @param c : the input character * * @return boolean indicating success * * Walk the double-array trie from state @a *s, using input character @a c. * If there exists an edge from @a *s with arc labeled @a c, this function * returns true and @a *s is updated to the new state. Otherwise, it returns * false and @a *s is left unchanged. */ bool da_walk (const DArray *d, TrieIndex *s, TrieChar c) { TrieIndex next; next = da_get_base (d, *s) + c; if (da_get_check (d, next) == *s) { *s = next; return true; } return false; } /** * @brief Insert a branch from trie node * * @param d : the double-array structure * @param s : the state to add branch to * @param c : the character for the branch label * * @return the index of the new node * * Insert a new arc labelled with character @a c from the trie node * represented by index @a s in double-array structure @a d. * Note that it assumes that no such arc exists before inserting. */ TrieIndex da_insert_branch (DArray *d, TrieIndex s, TrieChar c) { TrieIndex base, next; base = da_get_base (d, s); if (base > 0) { next = base + c; /* if already there, do not actually insert */ if (da_get_check (d, next) == s) return next; /* if (base + c) > TRIE_INDEX_MAX which means 'next' is overflow, * or cell [next] is not free, relocate to a free slot */ if (base > TRIE_INDEX_MAX - c || !da_check_free_cell (d, next)) { Symbols *symbols; TrieIndex new_base; /* relocate BASE[s] */ symbols = da_output_symbols (d, s); symbols_add (symbols, c); new_base = da_find_free_base (d, symbols); symbols_free (symbols); if (TRIE_INDEX_ERROR == new_base) return TRIE_INDEX_ERROR; da_relocate_base (d, s, new_base); next = new_base + c; } } else { Symbols *symbols; TrieIndex new_base; symbols = symbols_new (); symbols_add (symbols, c); new_base = da_find_free_base (d, symbols); symbols_free (symbols); if (TRIE_INDEX_ERROR == new_base) return TRIE_INDEX_ERROR; da_set_base (d, s, new_base); next = new_base + c; } da_alloc_cell (d, next); da_set_check (d, next, s); return next; } static bool da_check_free_cell (DArray *d, TrieIndex s) { return da_extend_pool (d, s) && da_get_check (d, s) < 0; } static bool da_has_children (const DArray *d, TrieIndex s) { TrieIndex base; TrieIndex c, max_c; base = da_get_base (d, s); if (TRIE_INDEX_ERROR == base || base < 0) return false; max_c = MIN_VAL (TRIE_CHAR_MAX, d->num_cells - base); for (c = 0; c <= max_c; c++) { if (da_get_check (d, base + c) == s) return true; } return false; } Symbols * da_output_symbols (const DArray *d, TrieIndex s) { Symbols *syms; TrieIndex base; TrieIndex c, max_c; syms = symbols_new (); base = da_get_base (d, s); max_c = MIN_VAL (TRIE_CHAR_MAX, d->num_cells - base); for (c = 0; c <= max_c; c++) { if (da_get_check (d, base + c) == s) symbols_add_fast (syms, (TrieChar) c); } return syms; } static TrieIndex da_find_free_base (DArray *d, const Symbols *symbols) { TrieChar first_sym; TrieIndex s; /* find first free cell that is beyond the first symbol */ first_sym = symbols_get (symbols, 0); s = -da_get_check (d, da_get_free_list (d)); while (s != da_get_free_list (d) && s < (TrieIndex) first_sym + DA_POOL_BEGIN) { s = -da_get_check (d, s); } if (s == da_get_free_list (d)) { for (s = first_sym + DA_POOL_BEGIN; ; ++s) { if (!da_extend_pool (d, s)) return TRIE_INDEX_ERROR; if (da_get_check (d, s) < 0) break; } } /* search for next free cell that fits the symbols set */ while (!da_fit_symbols (d, s - first_sym, symbols)) { /* extend pool before getting exhausted */ if (-da_get_check (d, s) == da_get_free_list (d)) { if (!da_extend_pool (d, d->num_cells)) return TRIE_INDEX_ERROR; } s = -da_get_check (d, s); } return s - first_sym; } static bool da_fit_symbols (DArray *d, TrieIndex base, const Symbols *symbols) { int i; for (i = 0; i < symbols_num (symbols); i++) { TrieChar sym = symbols_get (symbols, i); /* if (base + sym) > TRIE_INDEX_MAX which means it's overflow, * or cell [base + sym] is not free, the symbol is not fit. */ if (base > TRIE_INDEX_MAX - sym || !da_check_free_cell (d, base + sym)) return false; } return true; } static void da_relocate_base (DArray *d, TrieIndex s, TrieIndex new_base) { TrieIndex old_base; Symbols *symbols; int i; old_base = da_get_base (d, s); symbols = da_output_symbols (d, s); for (i = 0; i < symbols_num (symbols); i++) { TrieIndex old_next, new_next, old_next_base; old_next = old_base + symbols_get (symbols, i); new_next = new_base + symbols_get (symbols, i); old_next_base = da_get_base (d, old_next); /* allocate new next node and copy BASE value */ da_alloc_cell (d, new_next); da_set_check (d, new_next, s); da_set_base (d, new_next, old_next_base); /* old_next node is now moved to new_next * so, all cells belonging to old_next * must be given to new_next */ /* preventing the case of TAIL pointer */ if (old_next_base > 0) { TrieIndex c, max_c; max_c = MIN_VAL (TRIE_CHAR_MAX, d->num_cells - old_next_base); for (c = 0; c <= max_c; c++) { if (da_get_check (d, old_next_base + c) == old_next) da_set_check (d, old_next_base + c, new_next); } } /* free old_next node */ da_free_cell (d, old_next); } symbols_free (symbols); /* finally, make BASE[s] point to new_base */ da_set_base (d, s, new_base); } static bool da_extend_pool (DArray *d, TrieIndex to_index) { TrieIndex new_begin; TrieIndex i; TrieIndex free_tail; if (to_index <= 0 || TRIE_INDEX_MAX <= to_index) return false; if (to_index < d->num_cells) return true; d->cells = (DACell *) realloc (d->cells, (to_index + 1) * sizeof (DACell)); new_begin = d->num_cells; d->num_cells = to_index + 1; /* initialize new free list */ for (i = new_begin; i < to_index; i++) { da_set_check (d, i, -(i + 1)); da_set_base (d, i + 1, -i); } /* merge the new circular list to the old */ free_tail = -da_get_base (d, da_get_free_list (d)); da_set_check (d, free_tail, -new_begin); da_set_base (d, new_begin, -free_tail); da_set_check (d, to_index, -da_get_free_list (d)); da_set_base (d, da_get_free_list (d), -to_index); /* update header cell */ d->cells[0].check = d->num_cells; return true; } /** * @brief Prune the single branch * * @param d : the double-array structure * @param s : the dangling state to prune off * * Prune off a non-separate path up from the final state @a s. * If @a s still has some children states, it does nothing. Otherwise, * it deletes the node and all its parents which become non-separate. */ void da_prune (DArray *d, TrieIndex s) { da_prune_upto (d, da_get_root (d), s); } /** * @brief Prune the single branch up to given parent * * @param d : the double-array structure * @param p : the parent up to which to be pruned * @param s : the dangling state to prune off * * Prune off a non-separate path up from the final state @a s to the * given parent @a p. The prunning stop when either the parent @a p * is met, or a first non-separate node is found. */ void da_prune_upto (DArray *d, TrieIndex p, TrieIndex s) { while (p != s && !da_has_children (d, s)) { TrieIndex parent; parent = da_get_check (d, s); da_free_cell (d, s); s = parent; } } static void da_alloc_cell (DArray *d, TrieIndex cell) { TrieIndex prev, next; prev = -da_get_base (d, cell); next = -da_get_check (d, cell); /* remove the cell from free list */ da_set_check (d, prev, -next); da_set_base (d, next, -prev); } static void da_free_cell (DArray *d, TrieIndex cell) { TrieIndex i, prev; /* find insertion point */ i = -da_get_check (d, da_get_free_list (d)); while (i != da_get_free_list (d) && i < cell) i = -da_get_check (d, i); prev = -da_get_base (d, i); /* insert cell before i */ da_set_check (d, cell, -i); da_set_base (d, cell, -prev); da_set_check (d, prev, -cell); da_set_base (d, i, -cell); } /** * @brief Find first separate node in a sub-trie * * @param d : the double-array structure * @param root : the sub-trie root to search from * @param keybuff : the TrieString buffer for incrementally calcuating key * * @return index to the first separate node; TRIE_INDEX_ERROR on any failure * * Find the first separate node under a sub-trie rooted at @a root. * * On return, @a keybuff is appended with the key characters which walk from * @a root to the separate node. This is for incrementally calculating the * transition key, which is more efficient than later totally reconstructing * key from the given separate node. * * Available since: 0.2.6 */ TrieIndex da_first_separate (DArray *d, TrieIndex root, TrieString *keybuff) { TrieIndex base; TrieIndex c, max_c; while ((base = da_get_base (d, root)) >= 0) { max_c = MIN_VAL (TRIE_CHAR_MAX, d->num_cells - base); for (c = 0; c <= max_c; c++) { if (da_get_check (d, base + c) == root) break; } if (c == max_c) return TRIE_INDEX_ERROR; trie_string_append_char (keybuff, c); root = base + c; } return root; } /** * @brief Find next separate node in a sub-trie * * @param d : the double-array structure * @param root : the sub-trie root to search from * @param sep : the current separate node * @param keybuff : the TrieString buffer for incrementally calcuating key * * @return index to the next separate node; TRIE_INDEX_ERROR if no more * separate node is found * * Find the next separate node under a sub-trie rooted at @a root starting * from the current separate node @a sep. * * On return, @a keybuff is incrementally updated from the key which walks * to previous separate node to the one which walks to the new separate node. * So, it is assumed to be initialized by at least one da_first_separate() * call before. This incremental key calculation is more efficient than later * totally reconstructing key from the given separate node. * * Available since: 0.2.6 */ TrieIndex da_next_separate (DArray *d, TrieIndex root, TrieIndex sep, TrieString *keybuff) { TrieIndex parent; TrieIndex base; TrieIndex c, max_c; while (sep != root) { parent = da_get_check (d, sep); base = da_get_base (d, parent); c = sep - base; trie_string_cut_last (keybuff); /* find next sibling of sep */ max_c = MIN_VAL (TRIE_CHAR_MAX, d->num_cells - base); while (++c <= max_c) { if (da_get_check (d, base + c) == parent) { trie_string_append_char (keybuff, c); return da_first_separate (d, base + c, keybuff); } } sep = parent; } return TRIE_INDEX_ERROR; } /* vi:ts=4:ai:expandtab */ axe-0.3.1/src/datrie/darray.h000066400000000000000000000057541263567001600160030ustar00rootroot00000000000000/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * libdatrie - Double-Array Trie Library * Copyright (C) 2006 Theppitak Karoonboonyanan * * 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 */ /* * darray.h - Double-array trie structure * Created: 2006-08-11 * Author: Theppitak Karoonboonyanan */ #ifndef __DARRAY_H #define __DARRAY_H #include "triedefs.h" #include "trie-string.h" /** * @file darray.h * @brief Double-array trie structure */ /** * @brief Symbol set structure type */ typedef struct _Symbols Symbols; Symbols * symbols_new (void); void symbols_free (Symbols *syms); void symbols_add (Symbols *syms, TrieChar c); int symbols_num (const Symbols *syms); TrieChar symbols_get (const Symbols *syms, int index); /** * @brief Double-array structure type */ typedef struct _DArray DArray; DArray * da_new (void); void da_free (DArray *d); TrieIndex da_get_root (const DArray *d); TrieIndex da_get_base (const DArray *d, TrieIndex s); TrieIndex da_get_check (const DArray *d, TrieIndex s); void da_set_base (DArray *d, TrieIndex s, TrieIndex val); void da_set_check (DArray *d, TrieIndex s, TrieIndex val); bool da_walk (const DArray *d, TrieIndex *s, TrieChar c); Symbols * da_output_symbols (const DArray *d, TrieIndex s); /** * @brief Test walkability in double-array structure * * @param d : the double-array structure * @param s : current state * @param c : the input character * * @return boolean indicating walkability * * Test if there is a transition from state @a s with input character @a c. */ /* bool da_is_walkable (DArray *d, TrieIndex s, TrieChar c); */ #define da_is_walkable(d,s,c) \ (da_get_check ((d), da_get_base ((d), (s)) + (c)) == (s)) TrieIndex da_insert_branch (DArray *d, TrieIndex s, TrieChar c); void da_prune (DArray *d, TrieIndex s); void da_prune_upto (DArray *d, TrieIndex p, TrieIndex s); TrieIndex da_first_separate (DArray *d, TrieIndex root, TrieString *keybuff); TrieIndex da_next_separate (DArray *d, TrieIndex root, TrieIndex sep, TrieString *keybuff); #endif /* __DARRAY_H */ /* vi:ts=4:ai:expandtab */ axe-0.3.1/src/datrie/dstring-private.h000066400000000000000000000024471263567001600176370ustar00rootroot00000000000000/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * libdatrie - Double-Array Trie Library * Copyright (C) 2006 Theppitak Karoonboonyanan * * 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 */ /* * dstring-private.h - Dynamic string type * Created: 2012-08-02 * Author: Theppitak Karoonboonyanan */ #ifndef __DSTRING_PRIVATE_H #define __DSTRING_PRIVATE_H #include "typedefs.h" struct _DString { int char_size; int str_len; int alloc_size; void * val; }; #endif /* __DSTRING_PRIVATE_H */ /* vi:ts=4:ai:expandtab */ axe-0.3.1/src/datrie/dstring.c000066400000000000000000000076361263567001600161670ustar00rootroot00000000000000/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * libdatrie - Double-Array Trie Library * Copyright (C) 2006 Theppitak Karoonboonyanan * * 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 */ /* * dstring.c - Dynamic string type * Created: 2012-08-01 * Author: Theppitak Karoonboonyanan */ #include "dstring.h" #include "dstring-private.h" #include "trie-private.h" #include #include DString * dstring_new (int char_size, int n_elm) { DString *ds; ds = (DString *) malloc (sizeof (DString)); if (!ds) return NULL; ds->alloc_size = char_size * n_elm; ds->val = malloc (ds->alloc_size); if (!ds->val) { free (ds); return NULL; } ds->char_size = char_size; ds->str_len = 0; return ds; } void dstring_free (DString *ds) { free (ds->val); free (ds); } int dstring_length (const DString *ds) { return ds->str_len; } const void * dstring_get_val (const DString *ds) { return ds->val; } void * dstring_get_val_rw (DString *ds) { return ds->val; } void dstring_clear (DString *ds) { ds->str_len = 0; } static bool dstring_ensure_space (DString *ds, int size) { if (ds->alloc_size < size) { int re_size = MAX_VAL (ds->alloc_size * 2, size); void *re_ptr = realloc (ds->val, re_size); if (!re_ptr) return false; ds->val = re_ptr; ds->alloc_size = re_size; } return true; } bool dstring_copy (DString *dst, const DString *src) { if (!dstring_ensure_space (dst, (src->str_len + 1) * src->char_size)) return false; memcpy (dst->val, src->val, (src->str_len + 1) * src->char_size); dst->char_size = src->char_size; dst->str_len = src->str_len; return true; } bool dstring_append (DString *dst, const DString *src) { if (dst->char_size != src->char_size) return false; if (!dstring_ensure_space (dst, (dst->str_len + src->str_len + 1) * dst->char_size)) { return false; } memcpy ((char *)dst->val + (dst->char_size * dst->str_len), src->val, (src->str_len + 1) * dst->char_size); dst->str_len += src->str_len; return true; } bool dstring_append_string (DString *ds, const void *data, int len) { if (!dstring_ensure_space (ds, (ds->str_len + len + 1) * ds->char_size)) return false; memcpy ((char *)ds->val + (ds->char_size * ds->str_len), data, ds->char_size * len); ds->str_len += len; return true; } bool dstring_append_char (DString *ds, const void *data) { if (!dstring_ensure_space (ds, (ds->str_len + 2) * ds->char_size)) return false; memcpy ((char *)ds->val + (ds->char_size * ds->str_len), data, ds->char_size); ds->str_len++; return true; } bool dstring_terminate (DString *ds) { if (!dstring_ensure_space (ds, (ds->str_len + 2) * ds->char_size)) return false; memset ((char *)ds->val + (ds->char_size * ds->str_len), 0, ds->char_size); return true; } bool dstring_cut_last (DString *ds) { if (0 == ds->str_len) return false; ds->str_len--; return true; } /* vi:ts=4:ai:expandtab */ axe-0.3.1/src/datrie/dstring.h000066400000000000000000000034551263567001600161670ustar00rootroot00000000000000/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * libdatrie - Double-Array Trie Library * Copyright (C) 2006 Theppitak Karoonboonyanan * * 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 */ /* * dstring.h - Dynamic string type * Created: 2012-08-01 * Author: Theppitak Karoonboonyanan */ #ifndef __DSTRING_H #define __DSTRING_H #include "typedefs.h" typedef struct _DString DString; DString * dstring_new (int char_size, int n_elm); void dstring_free (DString *ds); int dstring_length (const DString *ds); const void * dstring_get_val (const DString *ds); void * dstring_get_val_rw (DString *ds); void dstring_clear (DString *ds); bool dstring_copy (DString *dst, const DString *src); bool dstring_append (DString *dst, const DString *src); bool dstring_append_string (DString *ds, const void *data, int len); bool dstring_append_char (DString *ds, const void *data); bool dstring_terminate (DString *ds); bool dstring_cut_last (DString *ds); #endif /* __DSTRING_H */ /* vi:ts=4:ai:expandtab */ axe-0.3.1/src/datrie/tail.c000066400000000000000000000225371263567001600154430ustar00rootroot00000000000000/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * libdatrie - Double-Array Trie Library * Copyright (C) 2006 Theppitak Karoonboonyanan * * 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 */ /* * tail.c - trie tail for keeping suffixes * Created: 2006-08-15 * Author: Theppitak Karoonboonyanan */ #include #include #ifndef _MSC_VER /* for SIZE_MAX */ # include #endif #include #include "tail.h" /*----------------------------------* * INTERNAL TYPES DECLARATIONS * *----------------------------------*/ /*-----------------------------------* * PRIVATE METHODS DECLARATIONS * *-----------------------------------*/ static TrieIndex tail_alloc_block (Tail *t); static void tail_free_block (Tail *t, TrieIndex block); /* ==================== BEGIN IMPLEMENTATION PART ==================== */ /*------------------------------------* * INTERNAL TYPES IMPLEMENTATIONS * *------------------------------------*/ /*------------------------------* * PRIVATE DATA DEFINITONS * *------------------------------*/ typedef struct { TrieIndex next_free; TrieData data; TrieChar *suffix; } TailBlock; struct _Tail { TrieIndex num_tails; TailBlock *tails; TrieIndex first_free; }; /*-----------------------------* * METHODS IMPLEMENTAIONS * *-----------------------------*/ #define TAIL_SIGNATURE 0xDFFCDFFC #define TAIL_START_BLOCKNO 1 /* Tail Header: * INT32: signature * INT32: pointer to first free slot * INT32: number of tail blocks * * Tail Blocks: * INT32: pointer to next free block (-1 for allocated blocks) * INT32: data for the key * INT16: length * BYTES[length]: suffix string (no terminating '\0') */ /** * @brief Create a new tail object * * Create a new empty tail object. */ Tail * tail_new (void) { Tail *t; t = (Tail *) malloc (sizeof (Tail)); if (!t) return NULL; t->first_free = 0; t->num_tails = 0; t->tails = NULL; return t; } /** * @brief Free tail data * * @param t : the tail data * * @return 0 on success, non-zero on failure * * Free the given tail data. */ void tail_free (Tail *t) { TrieIndex i; if (t->tails) { for (i = 0; i < t->num_tails; i++) if (t->tails[i].suffix) free (t->tails[i].suffix); free (t->tails); } free (t); } /** * @brief Get suffix * * @param t : the tail data * @param index : the index of the suffix * * @return pointer to the indexed suffix string. * * Get suffix from tail with given @a index. The returned string is a pointer * to internal storage, which should be accessed read-only by the caller. * No need to free() it. */ const TrieChar * tail_get_suffix (const Tail *t, TrieIndex index) { index -= TAIL_START_BLOCKNO; return (index < t->num_tails) ? t->tails[index].suffix : NULL; } /** * @brief Set suffix of existing entry * * @param t : the tail data * @param index : the index of the suffix * @param suffix : the new suffix * * Set suffix of existing entry of given @a index in tail. */ bool tail_set_suffix (Tail *t, TrieIndex index, const TrieChar *suffix) { index -= TAIL_START_BLOCKNO; if (index < t->num_tails) { /* suffix and t->tails[index].suffix may overlap; * so, dup it before it's overwritten */ TrieChar *tmp = NULL; if (suffix) tmp = (TrieChar *) strdup ((const char *)suffix); if (t->tails[index].suffix) free (t->tails[index].suffix); t->tails[index].suffix = tmp; return true; } return false; } /** * @brief Add a new suffix * * @param t : the tail data * @param suffix : the new suffix * * @return the index of the newly added suffix. * * Add a new suffix entry to tail. */ TrieIndex tail_add_suffix (Tail *t, const TrieChar *suffix) { TrieIndex new_block; new_block = tail_alloc_block (t); tail_set_suffix (t, new_block, suffix); return new_block; } static TrieIndex tail_alloc_block (Tail *t) { TrieIndex block; if (0 != t->first_free) { block = t->first_free; t->first_free = t->tails[block].next_free; } else { block = t->num_tails; t->tails = (TailBlock *) realloc (t->tails, ++t->num_tails * sizeof (TailBlock)); } t->tails[block].next_free = -1; t->tails[block].data = TRIE_DATA_ERROR; t->tails[block].suffix = NULL; return block + TAIL_START_BLOCKNO; } static void tail_free_block (Tail *t, TrieIndex block) { TrieIndex i, j; block -= TAIL_START_BLOCKNO; if (block >= t->num_tails) return; t->tails[block].data = TRIE_DATA_ERROR; if (NULL != t->tails[block].suffix) { free (t->tails[block].suffix); t->tails[block].suffix = NULL; } /* find insertion point */ j = 0; for (i = t->first_free; i != 0 && i < block; i = t->tails[i].next_free) j = i; /* insert free block between j and i */ t->tails[block].next_free = i; if (0 != j) t->tails[j].next_free = block; else t->first_free = block; } /** * @brief Get data associated to suffix entry * * @param t : the tail data * @param index : the index of the suffix * * @return the data associated to the suffix entry * * Get data associated to suffix entry @a index in tail data. */ TrieData tail_get_data (const Tail *t, TrieIndex index) { index -= TAIL_START_BLOCKNO; return (index < t->num_tails) ? t->tails[index].data : TRIE_DATA_ERROR; } /** * @brief Set data associated to suffix entry * * @param t : the tail data * @param index : the index of the suffix * @param data : the data to set * * @return boolean indicating success * * Set data associated to suffix entry @a index in tail data. */ bool tail_set_data (Tail *t, TrieIndex index, TrieData data) { index -= TAIL_START_BLOCKNO; if (index < t->num_tails) { t->tails[index].data = data; return true; } return false; } /** * @brief Delete suffix entry * * @param t : the tail data * @param index : the index of the suffix to delete * * Delete suffix entry from the tail data. */ void tail_delete (Tail *t, TrieIndex index) { tail_free_block (t, index); } /** * @brief Walk in tail with a string * * @param t : the tail data * @param s : the tail data index * @param suffix_idx : pointer to current character index in suffix * @param str : the string to use in walking * @param len : total characters in @a str to walk * * @return total number of characters successfully walked * * Walk in the tail data @a t at entry @a s, from given character position * @a *suffix_idx, using @a len characters of given string @a str. On return, * @a *suffix_idx is updated to the position after the last successful walk, * and the function returns the total number of character succesfully walked. */ int tail_walk_str (const Tail *t, TrieIndex s, short *suffix_idx, const TrieChar *str, int len) { const TrieChar *suffix; int i; short j; suffix = tail_get_suffix (t, s); if (!suffix) return false; i = 0; j = *suffix_idx; while (i < len) { if (str[i] != suffix[j]) break; ++i; /* stop and stay at null-terminator */ if (0 == suffix[j]) break; ++j; } *suffix_idx = j; return i; } /** * @brief Walk in tail with a character * * @param t : the tail data * @param s : the tail data index * @param suffix_idx : pointer to current character index in suffix * @param c : the character to use in walking * * @return boolean indicating success * * Walk in the tail data @a t at entry @a s, from given character position * @a *suffix_idx, using given character @a c. If the walk is successful, * it returns true, and @a *suffix_idx is updated to the next character. * Otherwise, it returns false, and @a *suffix_idx is left unchanged. */ bool tail_walk_char (const Tail *t, TrieIndex s, short *suffix_idx, TrieChar c) { const TrieChar *suffix; TrieChar suffix_char; suffix = tail_get_suffix (t, s); if (!suffix) return false; suffix_char = suffix[*suffix_idx]; if (suffix_char == c) { if (0 != suffix_char) ++*suffix_idx; return true; } return false; } /* vi:ts=4:ai:expandtab */ axe-0.3.1/src/datrie/tail.h000066400000000000000000000056261263567001600154500ustar00rootroot00000000000000/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * libdatrie - Double-Array Trie Library * Copyright (C) 2006 Theppitak Karoonboonyanan * * 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 */ /* * tail.h - trie tail for keeping suffixes * Created: 2006-08-12 * Author: Theppitak Karoonboonyanan */ #ifndef __TAIL_H #define __TAIL_H #include "triedefs.h" /** * @file tail.h * @brief trie tail for keeping suffixes */ /** * @brief Double-array structure type */ typedef struct _Tail Tail; Tail * tail_new (void); void tail_free (Tail *t); const TrieChar * tail_get_suffix (const Tail *t, TrieIndex index); bool tail_set_suffix (Tail *t, TrieIndex index, const TrieChar *suffix); TrieIndex tail_add_suffix (Tail *t, const TrieChar *suffix); TrieData tail_get_data (const Tail *t, TrieIndex index); bool tail_set_data (Tail *t, TrieIndex index, TrieData data); void tail_delete (Tail *t, TrieIndex index); int tail_walk_str (const Tail *t, TrieIndex s, short *suffix_idx, const TrieChar *str, int len); bool tail_walk_char (const Tail *t, TrieIndex s, short *suffix_idx, TrieChar c); /** * @brief Test walkability in tail with a character * * @param t : the tail data * @param s : the tail data index * @param suffix_idx : current character index in suffix * @param c : the character to test walkability * * @return boolean indicating walkability * * Test if the character @a c can be used to walk from given character * position @a suffix_idx of entry @a s of the tail data @a t. */ /* bool tail_is_walkable_char (Tail *t, TrieIndex s, short suffix_idx, const TrieChar c); */ #define tail_is_walkable_char(t,s,suffix_idx,c) \ (tail_get_suffix ((t), (s)) [suffix_idx] == (c)) #endif /* __TAIL_H */ /* vi:ts=4:ai:expandtab */ axe-0.3.1/src/datrie/trie-private.h000066400000000000000000000027011263567001600171210ustar00rootroot00000000000000/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * libdatrie - Double-Array Trie Library * Copyright (C) 2006 Theppitak Karoonboonyanan * * 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 */ /* * trie-private.h - Private utilities for trie implementation * Created: 2007-08-25 * Author: Theppitak Karoonboonyanan */ #ifndef __TRIE_PRIVATE_H #define __TRIE_PRIVATE_H #include /** * @file trie-private.h * @brief Private utilities for trie implementation */ /** * @brief Minimum value macro */ #define MIN_VAL(a,b) ((a)<(b)?(a):(b)) /** * @brief Maximum value macro */ #define MAX_VAL(a,b) ((a)>(b)?(a):(b)) #endif /* __TRIE_PRIVATE_H */ /* vi:ts=4:ai:expandtab */ axe-0.3.1/src/datrie/trie-string.c000066400000000000000000000050331263567001600167510ustar00rootroot00000000000000/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * libdatrie - Double-Array Trie Library * Copyright (C) 2006 Theppitak Karoonboonyanan * * 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 */ /* * trie-string.c - Dynamic string type for Trie alphabets * Created: 2012-08-02 * Author: Theppitak Karoonboonyanan */ #include "trie-string.h" #include "dstring-private.h" #include "triedefs.h" #include struct _TrieString { DString ds; }; TrieString * trie_string_new (int n_elm) { return (TrieString *) dstring_new (sizeof (TrieChar), n_elm); } void trie_string_free (TrieString *ts) { dstring_free ((DString *)ts); } int trie_string_length (const TrieString *ts) { return dstring_length ((DString *)ts); } const void * trie_string_get_val (const TrieString *ts) { return dstring_get_val ((DString *)ts); } void * trie_string_get_val_rw (TrieString *ts) { return dstring_get_val_rw ((DString *)ts); } void trie_string_clear (TrieString *ts) { dstring_clear ((DString *)ts); } bool trie_string_copy (TrieString *dst, const TrieString *src) { return dstring_copy ((DString *)dst, (const DString *)src); } bool trie_string_append (TrieString *dst, const TrieString *src) { return dstring_append ((DString *)dst, (const DString *)src); } bool trie_string_append_string (TrieString *ts, const TrieChar *str) { return dstring_append_string ((DString *)ts, str, strlen ((const char *)str)); } bool trie_string_append_char (TrieString *ts, TrieChar tc) { return dstring_append_char ((DString *)ts, &tc); } bool trie_string_terminate (TrieString *ts) { return dstring_terminate ((DString *)ts); } bool trie_string_cut_last (TrieString *ts) { return dstring_cut_last ((DString *)ts); } /* vi:ts=4:ai:expandtab */ axe-0.3.1/src/datrie/trie-string.h000066400000000000000000000036551263567001600167660ustar00rootroot00000000000000/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * libdatrie - Double-Array Trie Library * Copyright (C) 2006 Theppitak Karoonboonyanan * * 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 */ /* * trie-string.h - Dynamic string type for Trie alphabets * Created: 2012-08-02 * Author: Theppitak Karoonboonyanan */ #ifndef __TRIE_STRING_H #define __TRIE_STRING_H #include "dstring.h" #include "triedefs.h" typedef struct _TrieString TrieString; TrieString * trie_string_new (int n_elm); void trie_string_free (TrieString *ts); int trie_string_length (const TrieString *ts); const void * trie_string_get_val (const TrieString *ts); void * trie_string_get_val_rw (TrieString *ts); void trie_string_clear (TrieString *ts); bool trie_string_copy (TrieString *dst, const TrieString *src); bool trie_string_append (TrieString *dst, const TrieString *src); bool trie_string_append_string (TrieString *ts, const TrieChar *str); bool trie_string_append_char (TrieString *ts, TrieChar tc); bool trie_string_terminate (TrieString *ts); bool trie_string_cut_last (TrieString *ts); #endif /* __TRIE_STRING_H */ /* vi:ts=4:ai:expandtab */ axe-0.3.1/src/datrie/trie.c000066400000000000000000000614141263567001600154520ustar00rootroot00000000000000/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * libdatrie - Double-Array Trie Library * Copyright (C) 2006 Theppitak Karoonboonyanan * * 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 */ /* * trie.c - Trie data type and functions * Created: 2006-08-11 * Author: Theppitak Karoonboonyanan */ #include #include #include "trie.h" #include "alpha-map.h" #include "alpha-map-private.h" #include "darray.h" #include "tail.h" #include "trie-string.h" /** * @brief Trie structure */ struct _Trie { AlphaMap *alpha_map; DArray *da; Tail *tail; bool is_dirty; }; /** * @brief TrieState structure */ struct _TrieState { const Trie *trie; /**< the corresponding trie */ TrieIndex index; /**< index in double-array/tail structures */ short suffix_idx; /**< suffix character offset, if in suffix */ short is_suffix; /**< whether it is currently in suffix part */ }; /** * @brief TrieIterator structure */ struct _TrieIterator { const TrieState *root; /**< the state to start iteration from */ TrieState *state; /**< the current state */ TrieString *key; /**< buffer for calculating the entry key */ }; /*------------------------* * INTERNAL FUNCTIONS * *------------------------*/ #define trie_da_is_separate(da,s) (da_get_base ((da), (s)) < 0) #define trie_da_get_tail_index(da,s) (-da_get_base ((da), (s))) #define trie_da_set_tail_index(da,s,v) (da_set_base ((da), (s), -(v))) static TrieState * trie_state_new (const Trie *trie, TrieIndex index, short suffix_idx, short is_suffix); static bool trie_store_conditionally (Trie *trie, const AlphaChar *key, TrieData data, bool is_overwrite); static bool trie_branch_in_branch (Trie *trie, TrieIndex sep_node, const TrieChar *suffix, TrieData data); static bool trie_branch_in_tail (Trie *trie, TrieIndex sep_node, const TrieChar *suffix, TrieData data); /*-----------------------* * GENERAL FUNCTIONS * *-----------------------*/ /** * @brief Create a new trie * * @param alpha_map : the alphabet set for the trie * * @return a pointer to the newly created trie, NULL on failure * * Create a new empty trie object based on the given @a alpha_map alphabet * set. The trie contents can then be added and deleted with trie_store() and * trie_delete() respectively. * * The created object must be freed with trie_free(). */ Trie * trie_new (const AlphaMap *alpha_map) { Trie *trie; trie = (Trie *) malloc (sizeof (Trie)); if (!trie) return NULL; trie->alpha_map = alpha_map_clone (alpha_map); if (!trie->alpha_map) goto exit_trie_created; trie->da = da_new (); if (!trie->da) goto exit_alpha_map_created; trie->tail = tail_new (); if (!trie->tail) goto exit_da_created; trie->is_dirty = true; return trie; exit_da_created: da_free (trie->da); exit_alpha_map_created: alpha_map_free (trie->alpha_map); exit_trie_created: free (trie); return NULL; } /** * @brief Free a trie object * * @param trie : the trie object to free * * Destruct the @a trie and free its allocated memory. */ void trie_free (Trie *trie) { alpha_map_free (trie->alpha_map); da_free (trie->da); tail_free (trie->tail); free (trie); } /** * @brief Check pending changes * * @param trie : the trie object * * @return true if there are pending changes, false otherwise * * Check if the @a trie is dirty with some pending changes and needs saving * to synchronize with the file. */ bool trie_is_dirty (const Trie *trie) { return trie->is_dirty; } /*------------------------------* * GENERAL QUERY OPERATIONS * *------------------------------*/ /** * @brief Retrieve an entry from trie * * @param trie : the trie * @param key : the key for the entry to retrieve * @param o_data : the storage for storing the entry data on return * * @return boolean value indicating the existence of the entry. * * Retrieve an entry for the given @a key from @a trie. On return, * if @a key is found and @a o_data is not NULL, @a *o_data is set * to the data associated to @a key. */ bool trie_retrieve (const Trie *trie, const AlphaChar *key, TrieData *o_data) { TrieIndex s; short suffix_idx; const AlphaChar *p; /* walk through branches */ s = da_get_root (trie->da); for (p = key; !trie_da_is_separate (trie->da, s); p++) { TrieIndex tc = alpha_map_char_to_trie (trie->alpha_map, *p); if (TRIE_INDEX_MAX == tc) return false; if (!da_walk (trie->da, &s, (TrieChar) tc)) return false; if (0 == *p) break; } /* walk through tail */ s = trie_da_get_tail_index (trie->da, s); suffix_idx = 0; for ( ; ; p++) { TrieIndex tc = alpha_map_char_to_trie (trie->alpha_map, *p); if (TRIE_INDEX_MAX == tc) return false; if (!tail_walk_char (trie->tail, s, &suffix_idx, (TrieChar) tc)) return false; if (0 == *p) break; } /* found, set the val and return */ if (o_data) *o_data = tail_get_data (trie->tail, s); return true; } /** * @brief Store a value for an entry to trie * * @param trie : the trie * @param key : the key for the entry to retrieve * @param data : the data associated to the entry * * @return boolean value indicating the success of the operation * * Store a @a data for the given @a key in @a trie. If @a key does not * exist in @a trie, it will be appended. If it does, its current data will * be overwritten. */ bool trie_store (Trie *trie, const AlphaChar *key, TrieData data) { return trie_store_conditionally (trie, key, data, true); } /** * @brief Store a value for an entry to trie only if the key is not present * * @param trie : the trie * @param key : the key for the entry to retrieve * @param data : the data associated to the entry * * @return boolean value indicating the success of the operation * * Store a @a data for the given @a key in @a trie. If @a key does not * exist in @a trie, it will be appended. If it does, the function will * return failure and the existing value will not be touched. * * This can be useful for multi-thread applications, as race condition * can be avoided. * * Available since: 0.2.4 */ bool trie_store_if_absent (Trie *trie, const AlphaChar *key, TrieData data) { return trie_store_conditionally (trie, key, data, false); } static bool trie_store_conditionally (Trie *trie, const AlphaChar *key, TrieData data, bool is_overwrite) { TrieIndex s, t; short suffix_idx; const AlphaChar *p, *sep; /* walk through branches */ s = da_get_root (trie->da); for (p = key; !trie_da_is_separate (trie->da, s); p++) { TrieIndex tc = alpha_map_char_to_trie (trie->alpha_map, *p); if (TRIE_INDEX_MAX == tc) return false; if (!da_walk (trie->da, &s, (TrieChar) tc)) { TrieChar *key_str; bool res; key_str = alpha_map_char_to_trie_str (trie->alpha_map, p); if (!key_str) return false; res = trie_branch_in_branch (trie, s, key_str, data); free (key_str); return res; } if (0 == *p) break; } /* walk through tail */ sep = p; t = trie_da_get_tail_index (trie->da, s); suffix_idx = 0; for ( ; ; p++) { TrieIndex tc = alpha_map_char_to_trie (trie->alpha_map, *p); if (TRIE_INDEX_MAX == tc) return false; if (!tail_walk_char (trie->tail, t, &suffix_idx, (TrieChar) tc)) { TrieChar *tail_str; bool res; tail_str = alpha_map_char_to_trie_str (trie->alpha_map, sep); if (!tail_str) return false; res = trie_branch_in_tail (trie, s, tail_str, data); free (tail_str); return res; } if (0 == *p) break; } /* duplicated key, overwrite val if flagged */ if (!is_overwrite) { return false; } tail_set_data (trie->tail, t, data); trie->is_dirty = true; return true; } static bool trie_branch_in_branch (Trie *trie, TrieIndex sep_node, const TrieChar *suffix, TrieData data) { TrieIndex new_da, new_tail; new_da = da_insert_branch (trie->da, sep_node, *suffix); if (TRIE_INDEX_ERROR == new_da) return false; if ('\0' != *suffix) ++suffix; new_tail = tail_add_suffix (trie->tail, suffix); tail_set_data (trie->tail, new_tail, data); trie_da_set_tail_index (trie->da, new_da, new_tail); trie->is_dirty = true; return true; } static bool trie_branch_in_tail (Trie *trie, TrieIndex sep_node, const TrieChar *suffix, TrieData data) { TrieIndex old_tail, old_da, s; const TrieChar *old_suffix, *p; /* adjust separate point in old path */ old_tail = trie_da_get_tail_index (trie->da, sep_node); old_suffix = tail_get_suffix (trie->tail, old_tail); if (!old_suffix) return false; for (p = old_suffix, s = sep_node; *p == *suffix; p++, suffix++) { TrieIndex t = da_insert_branch (trie->da, s, *p); if (TRIE_INDEX_ERROR == t) goto fail; s = t; } old_da = da_insert_branch (trie->da, s, *p); if (TRIE_INDEX_ERROR == old_da) goto fail; if ('\0' != *p) ++p; tail_set_suffix (trie->tail, old_tail, p); trie_da_set_tail_index (trie->da, old_da, old_tail); /* insert the new branch at the new separate point */ return trie_branch_in_branch (trie, s, suffix, data); fail: /* failed, undo previous insertions and return error */ da_prune_upto (trie->da, sep_node, s); trie_da_set_tail_index (trie->da, sep_node, old_tail); return false; } /** * @brief Delete an entry from trie * * @param trie : the trie * @param key : the key for the entry to delete * * @return boolean value indicating whether the key exists and is removed * * Delete an entry for the given @a key from @a trie. */ bool trie_delete (Trie *trie, const AlphaChar *key) { TrieIndex s, t; short suffix_idx; const AlphaChar *p; /* walk through branches */ s = da_get_root (trie->da); for (p = key; !trie_da_is_separate (trie->da, s); p++) { TrieIndex tc = alpha_map_char_to_trie (trie->alpha_map, *p); if (TRIE_INDEX_MAX == tc) return false; if (!da_walk (trie->da, &s, (TrieChar) tc)) return false; if (0 == *p) break; } /* walk through tail */ t = trie_da_get_tail_index (trie->da, s); suffix_idx = 0; for ( ; ; p++) { TrieIndex tc = alpha_map_char_to_trie (trie->alpha_map, *p); if (TRIE_INDEX_MAX == tc) return false; if (!tail_walk_char (trie->tail, t, &suffix_idx, (TrieChar) tc)) return false; if (0 == *p) break; } tail_delete (trie->tail, t); da_set_base (trie->da, s, TRIE_INDEX_ERROR); da_prune (trie->da, s); trie->is_dirty = true; return true; } /** * @brief Enumerate entries in trie * * @param trie : the trie * @param enum_func : the callback function to be called on each key * @param user_data : user-supplied data to send as an argument to @a enum_func * * @return boolean value indicating whether all the keys are visited * * Enumerate all entries in trie. For each entry, the user-supplied * @a enum_func callback function is called, with the entry key and data. * Returning false from such callback will stop enumeration and return false. */ bool trie_enumerate (const Trie *trie, TrieEnumFunc enum_func, void *user_data) { TrieState *root; TrieIterator *iter; bool cont = true; root = trie_root (trie); if (!root) return false; iter = trie_iterator_new (root); if (!iter) goto exit_root_created; while (cont && trie_iterator_next (iter)) { AlphaChar *key = trie_iterator_get_key (iter); TrieData data = trie_iterator_get_data (iter); cont = (*enum_func) (key, data, user_data); free (key); } trie_iterator_free (iter); trie_state_free (root); return cont; exit_root_created: trie_state_free (root); return false; } /*-------------------------------* * STEPWISE QUERY OPERATIONS * *-------------------------------*/ /** * @brief Get root state of a trie * * @param trie : the trie * * @return the root state of the trie * * Get root state of @a trie, for stepwise walking. * * The returned state is allocated and must be freed with trie_state_free() */ TrieState * trie_root (const Trie *trie) { return trie_state_new (trie, da_get_root (trie->da), 0, false); } /*----------------* * TRIE STATE * *----------------*/ static TrieState * trie_state_new (const Trie *trie, TrieIndex index, short suffix_idx, short is_suffix) { TrieState *s; s = (TrieState *) malloc (sizeof (TrieState)); if (!s) return NULL; s->trie = trie; s->index = index; s->suffix_idx = suffix_idx; s->is_suffix = is_suffix; return s; } /** * @brief Copy trie state to another * * @param dst : the destination state * @param src : the source state * * Copy trie state data from @a src to @a dst. All existing data in @a dst * is overwritten. */ void trie_state_copy (TrieState *dst, const TrieState *src) { /* May be deep copy if necessary, not the case for now */ *dst = *src; } /** * @brief Clone a trie state * * @param s : the state to clone * * @return an duplicated instance of @a s * * Make a copy of trie state. * * The returned state is allocated and must be freed with trie_state_free() */ TrieState * trie_state_clone (const TrieState *s) { return trie_state_new (s->trie, s->index, s->suffix_idx, s->is_suffix); } /** * @brief Free a trie state * * @param s : the state to free * * Free the trie state. */ void trie_state_free (TrieState *s) { free (s); } /** * @brief Rewind a trie state * * @param s : the state to rewind * * Put the state at root. */ void trie_state_rewind (TrieState *s) { s->index = da_get_root (s->trie->da); s->is_suffix = false; } /** * @brief Walk the trie from the state * * @param s : current state * @param c : key character for walking * * @return boolean value indicating the success of the walk * * Walk the trie stepwise, using a given character @a c. * On return, the state @a s is updated to the new state if successfully walked. */ bool trie_state_walk (TrieState *s, AlphaChar c) { TrieIndex tc = alpha_map_char_to_trie (s->trie->alpha_map, c); if (TRIE_INDEX_MAX == tc) return false; if (!s->is_suffix) { bool ret; ret = da_walk (s->trie->da, &s->index, (TrieChar) tc); if (ret && trie_da_is_separate (s->trie->da, s->index)) { s->index = trie_da_get_tail_index (s->trie->da, s->index); s->suffix_idx = 0; s->is_suffix = true; } return ret; } else { return tail_walk_char (s->trie->tail, s->index, &s->suffix_idx, (TrieChar) tc); } } /** * @brief Test walkability of character from state * * @param s : the state to check * @param c : the input character * * @return boolean indicating walkability * * Test if there is a transition from state @a s with input character @a c. */ bool trie_state_is_walkable (const TrieState *s, AlphaChar c) { TrieIndex tc = alpha_map_char_to_trie (s->trie->alpha_map, c); if (TRIE_INDEX_MAX == tc) return false; if (!s->is_suffix) return da_is_walkable (s->trie->da, s->index, (TrieChar) tc); else return tail_is_walkable_char (s->trie->tail, s->index, s->suffix_idx, (TrieChar) tc); } /** * @brief Get all walkable characters from state * * @param s : the state to get * @param chars : the storage for the result * @param chars_nelm : the size of @a chars[] in number of elements * * @return total walkable characters * * Get the list of all walkable characters from state @a s. At most * @a chars_nelm walkable characters are stored in @a chars[] on return. * * The function returns the actual number of walkable characters from @a s. * Note that this may not equal the number of characters stored in @a chars[] * if @a chars_nelm is less than the actual number. * * Available since: 0.2.6 */ int trie_state_walkable_chars (const TrieState *s, AlphaChar chars[], int chars_nelm) { int syms_num = 0; if (!s->is_suffix) { Symbols *syms = da_output_symbols (s->trie->da, s->index); int i; syms_num = symbols_num (syms); for (i = 0; i < syms_num && i < chars_nelm; i++) { TrieChar tc = symbols_get (syms, i); chars[i] = alpha_map_trie_to_char (s->trie->alpha_map, tc); } symbols_free (syms); } else { const TrieChar *suffix = tail_get_suffix (s->trie->tail, s->index); chars[0] = alpha_map_trie_to_char (s->trie->alpha_map, suffix[s->suffix_idx]); syms_num = 1; } return syms_num; } /** * @brief Check for single path * * @param s : the state to check * * @return boolean value indicating whether it is in a single path * * Check if the given state is in a single path, that is, there is no other * branch from it to leaf. */ bool trie_state_is_single (const TrieState *s) { return s->is_suffix; } /** * @brief Get data from leaf state * * @param s : a leaf state * * @return the data associated with the leaf state @a s, * or TRIE_DATA_ERROR if @a s is not a leaf state * * Get value from a leaf state of trie. Getting value from a non-leaf state * will result in TRIE_DATA_ERROR. */ TrieData trie_state_get_data (const TrieState *s) { return trie_state_is_leaf (s) ? tail_get_data (s->trie->tail, s->index) : TRIE_DATA_ERROR; } /*---------------------* * ENTRY ITERATION * *---------------------*/ /** * @brief Create a new trie iterator * * @param s : the TrieState to start iteration from * * @return a pointer to the newly created TrieIterator, or NULL on failure * * Create a new trie iterator for iterating entries of a sub-trie rooted at * state @a s. * * Use it with the result of trie_root() to iterate the whole trie. * * The created object must be freed with trie_iterator_free(). * * Available since: 0.2.6 */ TrieIterator * trie_iterator_new (TrieState *s) { TrieIterator *iter; iter = (TrieIterator *) malloc (sizeof (TrieIterator)); if (!iter) return NULL; iter->root = s; iter->state = NULL; iter->key = NULL; return iter; } /** * @brief Free a trie iterator * * @param iter : the trie iterator to free * * Destruct the iterator @a iter and free its allocated memory. * * Available since: 0.2.6 */ void trie_iterator_free (TrieIterator *iter) { if (iter->state) { trie_state_free (iter->state); } if (iter->key) { trie_string_free (iter->key); } free (iter); } /** * @brief Move trie iterator to the next entry * * @param iter : an iterator * * @return boolean value indicating the availability of the entry * * Move trie iterator to the next entry. * On return, the iterator @a iter is updated to reference to the new entry * if successfully moved. * * Available since: 0.2.6 */ bool trie_iterator_next (TrieIterator *iter) { TrieState *s = iter->state; TrieIndex sep; /* first iteration */ if (!s) { s = iter->state = trie_state_clone (iter->root); /* for tail state, we are already at the only entry */ if (s->is_suffix) return true; iter->key = trie_string_new (20); sep = da_first_separate (s->trie->da, s->index, iter->key); if (TRIE_INDEX_ERROR == sep) return false; s->index = sep; return true; } /* no next entry for tail state */ if (s->is_suffix) return false; /* iter->state is a separate node */ sep = da_next_separate (s->trie->da, iter->root->index, s->index, iter->key); if (TRIE_INDEX_ERROR == sep) return false; s->index = sep; return true; } /** * @brief Get key for a trie iterator * * @param iter : an iterator * * @return the allocated key string; NULL on failure * * Get key for the current entry referenced by the trie iterator @a iter. * * The return string must be freed with free(). * * Available since: 0.2.6 */ AlphaChar * trie_iterator_get_key (const TrieIterator *iter) { const TrieState *s; const TrieChar *tail_str; AlphaChar *alpha_key, *alpha_p; s = iter->state; if (!s) return NULL; /* if s is in tail, root == s */ if (s->is_suffix) { tail_str = tail_get_suffix (s->trie->tail, s->index); if (!tail_str) return NULL; tail_str += s->suffix_idx; alpha_key = (AlphaChar *) malloc (sizeof (AlphaChar) * (strlen ((const char *)tail_str) + 1)); alpha_p = alpha_key; } else { TrieIndex tail_idx; int i, key_len; const TrieChar *key_p; tail_idx = trie_da_get_tail_index (s->trie->da, s->index); tail_str = tail_get_suffix (s->trie->tail, tail_idx); if (!tail_str) return NULL; key_len = trie_string_length (iter->key); key_p = trie_string_get_val (iter->key); alpha_key = (AlphaChar *) malloc ( sizeof (AlphaChar) * (key_len + strlen ((const char *)tail_str) + 1) ); alpha_p = alpha_key; for (i = key_len; i > 0; i--) { *alpha_p++ = alpha_map_trie_to_char (s->trie->alpha_map, *key_p++); } } while (*tail_str) { *alpha_p++ = alpha_map_trie_to_char (s->trie->alpha_map, *tail_str++); } *alpha_p = 0; return alpha_key; } /** * @brief Get data for the entry referenced by an iterator * * @param iter : an iterator * * @return the data associated with the entry referenced by iterator @a iter, * or TRIE_DATA_ERROR if @a iter does not reference to a unique entry * * Get value for the entry referenced by an iterator. Getting value from an * un-iterated (or broken for any reason) iterator will result in * TRIE_DATA_ERROR. * * Available since: 0.2.6 */ TrieData trie_iterator_get_data (const TrieIterator *iter) { const TrieState *s = iter->state; TrieIndex tail_index; if (!s) return TRIE_DATA_ERROR; if (!s->is_suffix) { if (!trie_da_is_separate (s->trie->da, s->index)) return TRIE_DATA_ERROR; tail_index = trie_da_get_tail_index (s->trie->da, s->index); } else { tail_index = s->index; } return tail_get_data (s->trie->tail, tail_index); } /* vi:ts=4:ai:expandtab */ axe-0.3.1/src/datrie/trie.h000066400000000000000000000150001263567001600154450ustar00rootroot00000000000000/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * libdatrie - Double-Array Trie Library * Copyright (C) 2006 Theppitak Karoonboonyanan * * 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 */ /* * trie.h - Trie data type and functions * Created: 2006-08-11 * Author: Theppitak Karoonboonyanan */ #ifndef __TRIE_H #define __TRIE_H #include #include #ifdef __cplusplus extern "C" { #endif /** * @file trie.h * @brief Trie data type and functions * * Trie is a kind of digital search tree, an efficient indexing method with * O(1) time complexity for searching. Comparably as efficient as hashing, * trie also provides flexibility on incremental matching and key spelling * manipulation. This makes it ideal for lexical analyzers, as well as * spelling dictionaries. * * This library is an implementation of double-array structure for representing * trie, as proposed by Junichi Aoe. The details of the implementation can be * found at http://linux.thai.net/~thep/datrie/datrie.html * * A Trie is associated with an AlphaMap, a map between actual alphabet * characters and the raw character used to walk through trie. * You can define the alphabet set by adding ranges of character codes * to it before associating it to a trie. And the keys to be added to the trie * must be only in such ranges. * * A new Trie can be created in memory using trie_new() * It can even be embeded in another file using trie_fwrite() and read back * using trie_fread(). * After use, Trie objects must be freed using trie_free(). * * Operations on trie include: * * - Add/delete entries with trie_store() and trie_delete() * - Retrieve entries with trie_retrieve() * - Walk through trie stepwise with TrieState and its functions * (trie_root(), trie_state_walk(), trie_state_rewind(), * trie_state_clone(), trie_state_copy(), * trie_state_is_walkable(), trie_state_walkable_chars(), * trie_state_is_single(), trie_state_get_data(). * And do not forget to free TrieState objects with trie_state_free() * after use.) * - Enumerate all keys using trie_enumerate() * - Iterate entries using TrieIterator and its functions * (trie_iterator_new(), trie_iterator_next(), trie_iterator_get_key(), * trie_iterator_get_data(). * And do not forget to free TrieIterator objects with trie_iterator_free() * after use.) */ /** * @brief Trie data type */ typedef struct _Trie Trie; /** * @brief Trie enumeration function * * @param key : the key of the entry * @param data : the data of the entry * @param user_data : the user-supplied data on enumerate call * * @return true to continue enumeration, false to stop */ typedef bool (*TrieEnumFunc) (const AlphaChar *key, TrieData key_data, void *user_data); /** * @brief Trie walking state */ typedef struct _TrieState TrieState; /** * @brief Trie iteration state */ typedef struct _TrieIterator TrieIterator; /*-----------------------* * GENERAL FUNCTIONS * *-----------------------*/ Trie * trie_new (const AlphaMap *alpha_map); void trie_free (Trie *trie); bool trie_is_dirty (const Trie *trie); /*------------------------------* * GENERAL QUERY OPERATIONS * *------------------------------*/ bool trie_retrieve (const Trie *trie, const AlphaChar *key, TrieData *o_data); bool trie_store (Trie *trie, const AlphaChar *key, TrieData data); bool trie_store_if_absent (Trie *trie, const AlphaChar *key, TrieData data); bool trie_delete (Trie *trie, const AlphaChar *key); bool trie_enumerate (const Trie *trie, TrieEnumFunc enum_func, void *user_data); /*-------------------------------* * STEPWISE QUERY OPERATIONS * *-------------------------------*/ TrieState * trie_root (const Trie *trie); /*----------------* * TRIE STATE * *----------------*/ TrieState * trie_state_clone (const TrieState *s); void trie_state_copy (TrieState *dst, const TrieState *src); void trie_state_free (TrieState *s); void trie_state_rewind (TrieState *s); bool trie_state_walk (TrieState *s, AlphaChar c); bool trie_state_is_walkable (const TrieState *s, AlphaChar c); int trie_state_walkable_chars (const TrieState *s, AlphaChar chars[], int chars_nelm); /** * @brief Check for terminal state * * @param s : the state to check * * @return boolean value indicating whether it is a terminal state * * Check if the given state is a terminal state. A terminal state is a trie * state that terminates a key, and stores a value associated with it. */ #define trie_state_is_terminal(s) trie_state_is_walkable((s),TRIE_CHAR_TERM) bool trie_state_is_single (const TrieState *s); /** * @brief Check for leaf state * * @param s : the state to check * * @return boolean value indicating whether it is a leaf state * * Check if the given state is a leaf state. A leaf state is a terminal state * that has no other branch. */ #define trie_state_is_leaf(s) \ (trie_state_is_single(s) && trie_state_is_terminal(s)) TrieData trie_state_get_data (const TrieState *s); /*----------------------* * ENTRY ITERATION * *----------------------*/ TrieIterator * trie_iterator_new (TrieState *s); void trie_iterator_free (TrieIterator *iter); bool trie_iterator_next (TrieIterator *iter); AlphaChar * trie_iterator_get_key (const TrieIterator *iter); TrieData trie_iterator_get_data (const TrieIterator *iter); #ifdef __cplusplus } #endif #endif /* __TRIE_H */ /* vi:ts=4:ai:expandtab */ axe-0.3.1/src/datrie/triedefs.h000066400000000000000000000042121263567001600163120ustar00rootroot00000000000000/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * libdatrie - Double-Array Trie Library * Copyright (C) 2006 Theppitak Karoonboonyanan * * 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 */ /* * triedefs.h - General typedefs for trie * Created: 2006-08-11 * Author: Theppitak Karoonboonyanan */ #ifndef __TRIEDEFS_H #define __TRIEDEFS_H #include #include /** * @file triedefs.h * @brief General typedefs for trie */ /** * @brief Alphabet character type for use as input/output strings of trie keys */ typedef char AlphaChar; /** * @brief Error value for alphabet character */ #define ALPHA_CHAR_ERROR (~(AlphaChar)0) /** * @brief Raw character type mapped into packed set from AlphaChar, * for use in actual trie transition calculations */ typedef uint8_t TrieChar; /** * @brief Trie terminator character */ #define TRIE_CHAR_TERM ((TrieChar) 0) #define TRIE_CHAR_MAX UINT8_MAX /** * @brief Type of index into Trie double-array and tail structures */ typedef int32_t TrieIndex; /** * @brief Trie error index */ #define TRIE_INDEX_ERROR ((TrieIndex) 0) /** * @brief Maximum trie index value */ #define TRIE_INDEX_MAX INT32_MAX /** * @brief Type of value associated to trie entries */ typedef intptr_t TrieData; /** * @brief Trie error data */ #define TRIE_DATA_ERROR ((TrieData) -1) #endif /* __TRIEDEFS_H */ /* vi:ts=4:ai:expandtab */ axe-0.3.1/src/datrie/typedefs.h000066400000000000000000000024151263567001600163330ustar00rootroot00000000000000/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * libdatrie - Double-Array Trie Library * Copyright (C) 2006 Theppitak Karoonboonyanan * * 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 */ /* * typedefs.h - general types * Created : 11 Aug 2006 * Author : Theppitak Karoonboonyanan */ #ifndef __TYPEDEFS_H #define __TYPEDEFS_H #include #include #include typedef uint8_t byte; typedef uint16_t word; typedef uint32_t dword; #endif /* __TYPEDEFS_H */ /* vi:ts=4:ai:expandtab */ axe-0.3.1/src/gsl/000077500000000000000000000000001263567001600136525ustar00rootroot00000000000000axe-0.3.1/src/gsl/combination.c000066400000000000000000000070031263567001600163200ustar00rootroot00000000000000/* combination/combination.c * based on permutation/permutation.c by Brian Gough * * Copyright (C) 2001 Szymon Jaroszewicz * * This program is free software; you can 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, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include "gsl_errno.h" #include "gsl_combination.h" size_t gsl_combination_n (const gsl_combination * c) { return c->n ; } size_t gsl_combination_k (const gsl_combination * c) { return c->k ; } size_t * gsl_combination_data (const gsl_combination * c) { return c->data ; } int gsl_combination_valid (gsl_combination * c) { const size_t n = c->n ; const size_t k = c->k ; size_t i, j ; if( k > n ) { GSL_ERROR("combination has k greater than n", GSL_FAILURE) ; } for (i = 0; i < k; i++) { const size_t ci = c->data[i]; if (ci >= n) { GSL_ERROR("combination index outside range", GSL_FAILURE) ; } for (j = 0; j < i; j++) { if (c->data[j] == ci) { GSL_ERROR("duplicate combination index", GSL_FAILURE) ; } if (c->data[j] > ci) { GSL_ERROR("combination indices not in increasing order", GSL_FAILURE) ; } } } return GSL_SUCCESS; } int gsl_combination_next (gsl_combination * c) { /* Replaces c with the next combination (in the standard lexicographical * ordering). Returns GSL_FAILURE if there is no next combination. */ const size_t n = c->n; const size_t k = c->k; size_t *data = c->data; size_t i; if(k == 0) { return GSL_FAILURE; } i = k - 1; while(i > 0 && data[i] == n - k + i) { i--; } if(i == 0 && data[i] == n - k) { return GSL_FAILURE; } data[i]++; for(; i < k - 1; i++) { data[i + 1] = data[i] + 1; } return GSL_SUCCESS; } int gsl_combination_prev (gsl_combination * c) { /* Replaces c with the previous combination (in the standard * lexicographical ordering). Returns GSL_FAILURE if there is no * previous combination. */ const size_t n = c->n; const size_t k = c->k; size_t *data = c->data; size_t i; if(k == 0) { return GSL_FAILURE; } i = k - 1; while(i > 0 && data[i] == data[i-1] + 1) { i--; } if(i == 0 && data[i] == 0) { return GSL_FAILURE; } data[i++]--; for(; i < k; i++) { data[i] = n - k + i; } return GSL_SUCCESS; } int gsl_combination_memcpy (gsl_combination * dest, const gsl_combination * src) { const size_t src_n = src->n; const size_t src_k = src->k; const size_t dest_n = dest->n; const size_t dest_k = dest->k; if (src_n != dest_n || src_k != dest_k) { GSL_ERROR ("combination lengths are not equal", GSL_EBADLEN); } { size_t j; for (j = 0; j < src_k; j++) { dest->data[j] = src->data[j]; } } return GSL_SUCCESS; } axe-0.3.1/src/gsl/error.c000066400000000000000000000037611263567001600151560ustar00rootroot00000000000000/* err/error.c * * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough * * This program is free software; you can 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, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include #include #include #include "gsl_errno.h" #include "gsl_message.h" gsl_error_handler_t * gsl_error_handler = NULL; static void no_error_handler (const char *reason, const char *file, int line, int gsl_errno); void gsl_error (const char * reason, const char * file, int line, int gsl_errno) { if (gsl_error_handler) { (*gsl_error_handler) (reason, file, line, gsl_errno); return ; } gsl_stream_printf ("ERROR", file, line, reason); fflush (stdout); fprintf (stderr, "Default GSL error handler invoked.\n"); fflush (stderr); abort (); } gsl_error_handler_t * gsl_set_error_handler (gsl_error_handler_t * new_handler) { gsl_error_handler_t * previous_handler = gsl_error_handler; gsl_error_handler = new_handler; return previous_handler; } gsl_error_handler_t * gsl_set_error_handler_off (void) { gsl_error_handler_t * previous_handler = gsl_error_handler; gsl_error_handler = no_error_handler; return previous_handler; } static void no_error_handler (const char *reason, const char *file, int line, int gsl_errno) { /* do nothing */ (void) reason; (void) file; (void) line; (void) gsl_errno; return; } axe-0.3.1/src/gsl/gsl_combination.h000066400000000000000000000046421263567001600172000ustar00rootroot00000000000000/* combination/gsl_combination.h * based on permutation/gsl_permutation.h by Brian Gough * * Copyright (C) 2001 Szymon Jaroszewicz * * This program is free software; you can 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, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #ifndef __GSL_COMBINATION_H__ #define __GSL_COMBINATION_H__ #include #include "gsl_errno.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 struct gsl_combination_struct { size_t n; size_t k; size_t *data; }; typedef struct gsl_combination_struct gsl_combination; gsl_combination *gsl_combination_alloc (const size_t n, const size_t k); gsl_combination *gsl_combination_calloc (const size_t n, const size_t k); void gsl_combination_init_first (gsl_combination * c); void gsl_combination_init_last (gsl_combination * c); void gsl_combination_free (gsl_combination * c); int gsl_combination_memcpy (gsl_combination * dest, const gsl_combination * src); int gsl_combination_fread (FILE * stream, gsl_combination * c); int gsl_combination_fwrite (FILE * stream, const gsl_combination * c); int gsl_combination_fscanf (FILE * stream, gsl_combination * c); int gsl_combination_fprintf (FILE * stream, const gsl_combination * c, const char *format); size_t gsl_combination_n (const gsl_combination * c); size_t gsl_combination_k (const gsl_combination * c); size_t * gsl_combination_data (const gsl_combination * c); int gsl_combination_valid (gsl_combination * c); int gsl_combination_next (gsl_combination * c); int gsl_combination_prev (gsl_combination * c); static inline size_t gsl_combination_get (const gsl_combination * c, const size_t i) { return c->data[i]; } __END_DECLS #endif /* __GSL_COMBINATION_H__ */ axe-0.3.1/src/gsl/gsl_errno.h000066400000000000000000000134521263567001600160220ustar00rootroot00000000000000/* err/gsl_errno.h * * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough * * This program is free software; you can 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, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #ifndef __GSL_ERRNO_H__ #define __GSL_ERRNO_H__ #include #include #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 { GSL_SUCCESS = 0, GSL_FAILURE = -1, GSL_CONTINUE = -2, /* iteration has not converged */ GSL_EDOM = 1, /* input domain error, e.g sqrt(-1) */ GSL_ERANGE = 2, /* output range error, e.g. exp(1e100) */ GSL_EFAULT = 3, /* invalid pointer */ GSL_EINVAL = 4, /* invalid argument supplied by user */ GSL_EFAILED = 5, /* generic failure */ GSL_EFACTOR = 6, /* factorization failed */ GSL_ESANITY = 7, /* sanity check failed - shouldn't happen */ GSL_ENOMEM = 8, /* malloc failed */ GSL_EBADFUNC = 9, /* problem with user-supplied function */ GSL_ERUNAWAY = 10, /* iterative process is out of control */ GSL_EMAXITER = 11, /* exceeded max number of iterations */ GSL_EZERODIV = 12, /* tried to divide by zero */ GSL_EBADTOL = 13, /* user specified an invalid tolerance */ GSL_ETOL = 14, /* failed to reach the specified tolerance */ GSL_EUNDRFLW = 15, /* underflow */ GSL_EOVRFLW = 16, /* overflow */ GSL_ELOSS = 17, /* loss of accuracy */ GSL_EROUND = 18, /* failed because of roundoff error */ GSL_EBADLEN = 19, /* matrix, vector lengths are not conformant */ GSL_ENOTSQR = 20, /* matrix not square */ GSL_ESING = 21, /* apparent singularity detected */ GSL_EDIVERGE = 22, /* integral or series is divergent */ GSL_EUNSUP = 23, /* requested feature is not supported by the hardware */ GSL_EUNIMPL = 24, /* requested feature not (yet) implemented */ GSL_ECACHE = 25, /* cache limit exceeded */ GSL_ETABLE = 26, /* table limit exceeded */ GSL_ENOPROG = 27, /* iteration is not making progress towards solution */ GSL_ENOPROGJ = 28, /* jacobian evaluations are not improving the solution */ GSL_ETOLF = 29, /* cannot reach the specified tolerance in F */ GSL_ETOLX = 30, /* cannot reach the specified tolerance in X */ GSL_ETOLG = 31, /* cannot reach the specified tolerance in gradient */ GSL_EOF = 32 /* end of file */ } ; void gsl_error (const char * reason, const char * file, int line, int gsl_errno); void gsl_stream_printf (const char *label, const char *file, int line, const char *reason); const char * gsl_strerror (const int gsl_errno); typedef void gsl_error_handler_t (const char * reason, const char * file, int line, int gsl_errno); typedef void gsl_stream_handler_t (const char * label, const char * file, int line, const char * reason); gsl_error_handler_t * gsl_set_error_handler (gsl_error_handler_t * new_handler); gsl_error_handler_t * gsl_set_error_handler_off (void); gsl_stream_handler_t * gsl_set_stream_handler (gsl_stream_handler_t * new_handler); FILE * gsl_set_stream (FILE * new_stream); /* GSL_ERROR: call the error handler, and return the error code */ #define GSL_ERROR(reason, gsl_errno) \ do { \ gsl_error (reason, __FILE__, __LINE__, gsl_errno) ; \ return gsl_errno ; \ } while (0) /* GSL_ERROR_VAL: call the error handler, and return the given value */ #define GSL_ERROR_VAL(reason, gsl_errno, value) \ do { \ gsl_error (reason, __FILE__, __LINE__, gsl_errno) ; \ return value ; \ } while (0) /* GSL_ERROR_VOID: call the error handler, and then return (for void functions which still need to generate an error) */ #define GSL_ERROR_VOID(reason, gsl_errno) \ do { \ gsl_error (reason, __FILE__, __LINE__, gsl_errno) ; \ return ; \ } while (0) /* GSL_ERROR_NULL suitable for out-of-memory conditions */ #define GSL_ERROR_NULL(reason, gsl_errno) GSL_ERROR_VAL(reason, gsl_errno, 0) /* Sometimes you have several status results returned from * function calls and you want to combine them in some sensible * way. You cannot produce a "total" status condition, but you can * pick one from a set of conditions based on an implied hierarchy. * * In other words: * you have: status_a, status_b, ... * you want: status = (status_a if it is bad, or status_b if it is bad,...) * * In this example you consider status_a to be more important and * it is checked first, followed by the others in the order specified. * * Here are some dumb macros to do this. */ #define GSL_ERROR_SELECT_2(a,b) ((a) != GSL_SUCCESS ? (a) : ((b) != GSL_SUCCESS ? (b) : GSL_SUCCESS)) #define GSL_ERROR_SELECT_3(a,b,c) ((a) != GSL_SUCCESS ? (a) : GSL_ERROR_SELECT_2(b,c)) #define GSL_ERROR_SELECT_4(a,b,c,d) ((a) != GSL_SUCCESS ? (a) : GSL_ERROR_SELECT_3(b,c,d)) #define GSL_ERROR_SELECT_5(a,b,c,d,e) ((a) != GSL_SUCCESS ? (a) : GSL_ERROR_SELECT_4(b,c,d,e)) #define GSL_STATUS_UPDATE(sp, s) do { if ((s) != GSL_SUCCESS) *(sp) = (s);} while(0) __END_DECLS #endif /* __GSL_ERRNO_H__ */ axe-0.3.1/src/gsl/gsl_message.h000066400000000000000000000045141263567001600163200ustar00rootroot00000000000000/* err/gsl_message.h * * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough * * This program is free software; you can 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, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #ifndef __GSL_MESSAGE_H__ #define __GSL_MESSAGE_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 /* Provide a general messaging service for client use. Messages can * be selectively turned off at compile time by defining an * appropriate message mask. Client code which uses the GSL_MESSAGE() * macro must provide a mask which is or'ed with the GSL_MESSAGE_MASK. * * The messaging service can be completely turned off * by defining GSL_MESSAGING_OFF. */ void gsl_message(const char * message, const char * file, int line, unsigned int mask); #ifndef GSL_MESSAGE_MASK #define GSL_MESSAGE_MASK 0xffffffffu /* default all messages allowed */ #endif unsigned int gsl_message_mask ; /* Provide some symolic masks for client ease of use. */ enum { GSL_MESSAGE_MASK_A = 1, GSL_MESSAGE_MASK_B = 2, GSL_MESSAGE_MASK_C = 4, GSL_MESSAGE_MASK_D = 8, GSL_MESSAGE_MASK_E = 16, GSL_MESSAGE_MASK_F = 32, GSL_MESSAGE_MASK_G = 64, GSL_MESSAGE_MASK_H = 128 } ; #ifdef GSL_MESSAGING_OFF /* throw away messages */ #define GSL_MESSAGE(message, mask) do { } while(0) #else /* output all messages */ #define GSL_MESSAGE(message, mask) \ do { \ if (mask & GSL_MESSAGE_MASK) \ gsl_message (message, __FILE__, __LINE__, mask) ; \ } while (0) #endif __END_DECLS #endif /* __GSL_MESSAGE_H__ */ axe-0.3.1/src/gsl/init.c000066400000000000000000000053361263567001600147700ustar00rootroot00000000000000/* combination/init.c * based on permutation/init.c by Brian Gough * * Copyright (C) 2001 Szymon Jaroszewicz * Copyright (C) 2009 Brian Gough * * This program is free software; you can 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, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include #include "gsl_errno.h" #include "gsl_combination.h" gsl_combination * gsl_combination_alloc (const size_t n, const size_t k) { gsl_combination * c; if (n == 0) { GSL_ERROR_VAL ("combination parameter n must be positive integer", GSL_EDOM, 0); } if (k > n) { GSL_ERROR_VAL ("combination length k must be an integer less than or equal to n", GSL_EDOM, 0); } c = (gsl_combination *) malloc (sizeof (gsl_combination)); if (c == 0) { GSL_ERROR_VAL ("failed to allocate space for combination struct", GSL_ENOMEM, 0); } if (k > 0) { c->data = (size_t *) malloc (k * sizeof (size_t)); if (c->data == 0) { free (c); /* exception in constructor, avoid memory leak */ GSL_ERROR_VAL ("failed to allocate space for combination data", GSL_ENOMEM, 0); } } else { c->data = 0; } c->n = n; c->k = k; return c; } gsl_combination * gsl_combination_calloc (const size_t n, const size_t k) { size_t i; gsl_combination * c = gsl_combination_alloc (n, k); if (c == 0) return 0; /* initialize combination to identity */ for (i = 0; i < k; i++) { c->data[i] = i; } return c; } void gsl_combination_init_first (gsl_combination * c) { const size_t k = c->k ; size_t i; /* initialize combination to identity */ for (i = 0; i < k; i++) { c->data[i] = i; } } void gsl_combination_init_last (gsl_combination * c) { const size_t k = c->k ; size_t i; size_t n = c->n; /* initialize combination to identity */ for (i = 0; i < k; i++) { c->data[i] = n - k + i; } } void gsl_combination_free (gsl_combination * c) { if (c == NULL) return; if (c->k > 0) free (c->data); free (c); } axe-0.3.1/src/gsl/message.c000066400000000000000000000022461263567001600154460ustar00rootroot00000000000000/* err/message.c * * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough * * This program is free software; you can 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, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include #include #include #include "gsl_errno.h" #include "gsl_message.h" unsigned int gsl_message_mask = GSL_MESSAGE_MASK; void gsl_message (const char * reason, const char * file, int line, unsigned int mask) { if (mask & gsl_message_mask) { gsl_stream_printf ("MESSAGE", file, line, reason); } } axe-0.3.1/src/gsl/stream.c000066400000000000000000000034161263567001600153150ustar00rootroot00000000000000/* err/stream.c * * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough * * This program is free software; you can 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, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include #include #include #include "gsl_errno.h" #include "gsl_message.h" FILE * gsl_stream = NULL ; gsl_stream_handler_t * gsl_stream_handler = NULL; void gsl_stream_printf (const char *label, const char *file, int line, const char *reason) { if (gsl_stream == NULL) { gsl_stream = stderr; } if (gsl_stream_handler) { (*gsl_stream_handler) (label, file, line, reason); return; } fprintf (gsl_stream, "gsl: %s:%d: %s: %s\n", file, line, label, reason); } gsl_stream_handler_t * gsl_set_stream_handler (gsl_stream_handler_t * new_handler) { gsl_stream_handler_t * previous_handler = gsl_stream_handler; gsl_stream_handler = new_handler; return previous_handler; } FILE * gsl_set_stream (FILE * new_stream) { FILE * previous_stream; if (gsl_stream == NULL) { gsl_stream = stderr; } previous_stream = gsl_stream; gsl_stream = new_stream; return previous_stream; } axe-0.3.1/src/gsl/strerror.c000066400000000000000000000064561263567001600157130ustar00rootroot00000000000000/* err/strerror.c * * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough * * This program is free software; you can 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, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include "gsl_errno.h" const char * gsl_strerror (const int gsl_errno) { switch (gsl_errno) { case GSL_SUCCESS: return "success" ; case GSL_FAILURE: return "failure" ; case GSL_CONTINUE: return "the iteration has not converged yet"; case GSL_EDOM: return "input domain error" ; case GSL_ERANGE: return "output range error" ; case GSL_EFAULT: return "invalid pointer" ; case GSL_EINVAL: return "invalid argument supplied by user" ; case GSL_EFAILED: return "generic failure" ; case GSL_EFACTOR: return "factorization failed" ; case GSL_ESANITY: return "sanity check failed - shouldn't happen" ; case GSL_ENOMEM: return "malloc failed" ; case GSL_EBADFUNC: return "problem with user-supplied function"; case GSL_ERUNAWAY: return "iterative process is out of control"; case GSL_EMAXITER: return "exceeded max number of iterations" ; case GSL_EZERODIV: return "tried to divide by zero" ; case GSL_EBADTOL: return "specified tolerance is invalid or theoretically unattainable" ; case GSL_ETOL: return "failed to reach the specified tolerance" ; case GSL_EUNDRFLW: return "underflow" ; case GSL_EOVRFLW: return "overflow" ; case GSL_ELOSS: return "loss of accuracy" ; case GSL_EROUND: return "roundoff error" ; case GSL_EBADLEN: return "matrix/vector sizes are not conformant" ; case GSL_ENOTSQR: return "matrix not square" ; case GSL_ESING: return "singularity or extremely bad function behavior detected" ; case GSL_EDIVERGE: return "integral or series is divergent" ; case GSL_EUNSUP: return "the required feature is not supported by this hardware platform"; case GSL_EUNIMPL: return "the requested feature is not (yet) implemented"; case GSL_ECACHE: return "cache limit exceeded"; case GSL_ETABLE: return "table limit exceeded"; case GSL_ENOPROG: return "iteration is not making progress towards solution"; case GSL_ENOPROGJ: return "jacobian evaluations are not improving the solution"; case GSL_ETOLF: return "cannot reach the specified tolerance in F"; case GSL_ETOLX: return "cannot reach the specified tolerance in X"; case GSL_ETOLG: return "cannot reach the specified tolerance in gradient"; case GSL_EOF: return "end of file"; default: return "unknown error code" ; } } axe-0.3.1/src/libqes/000077500000000000000000000000001263567001600143445ustar00rootroot00000000000000axe-0.3.1/src/main.c000066400000000000000000000352441263567001600141650ustar00rootroot00000000000000/* * ============================================================================ * * Filename: axe_main.c * Description: Main loop for axe * Copyright: 2014-2015 Kevin Murray * License: GNU GPL v3+ * * This program is free software: you can 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 . * * ============================================================================ */ #include "axe.h" #include static void print_version(void) { fprintf(stderr, "AXE Version %s\n", AXE_VERSION); } static void print_help(void) { fprintf(stderr, "All mandatory short options are mandatory in their\n"); fprintf(stderr, "long option form. Likewise, all short options that take\n"); fprintf(stderr, "an argument must be given an argument in their long form\n"); fprintf(stderr, "\n"); fprintf(stderr, "If a forward read input is given, a forward read output\n"); fprintf(stderr, "must be. Likewise for a reverse/interleaved input. If either\n"); fprintf(stderr, "forward and/or reverse reads are given, interleaved input\n"); fprintf(stderr, "cannot be. However, one can input interleaved paired reads\n"); fprintf(stderr, "and output separate forwards and reverse reads, and vice versa.\n"); fprintf(stderr, "\n"); fprintf(stderr, "The barcode file is a tab-separated tabular file with an\n"); fprintf(stderr, "optional header, and has two alternative formats. The standard\n"); fprintf(stderr, "form (see below) is expected unless --combinatorial is given.\n"); fprintf(stderr, "\n"); fprintf(stderr, "The standard format is:\n"); fprintf(stderr, "Barcode\tID\n"); fprintf(stderr, "ACTA\tA1\n"); fprintf(stderr, "CCTC\tA2\n"); fprintf(stderr, "...\n"); fprintf(stderr, "\n"); fprintf(stderr, "The combinatorial format is:\n"); fprintf(stderr, "Barcode1\tBarcode2\tID\n"); fprintf(stderr, "ACTA\tACGC\tA1\n"); fprintf(stderr, "CCTC\tTCTA\tA2\n"); fprintf(stderr, "...\n"); fprintf(stderr, "\n"); } static void print_usage(void) { print_version(); fprintf(stderr, "\nUSAGE:\n"); fprintf(stderr, "axe-demux [-mzc2pt] -b (-f [-r] | -i) (-F [-R] | -I)\n"); fprintf(stderr, "axe-demux -h\n"); fprintf(stderr, "axe-demux -v\n\n"); fprintf(stderr, "OPTIONS:\n"); fprintf(stderr, " -m, --mismatch\tMaximum hamming distance mismatch. [int, default 1]\n"); fprintf(stderr, " -z, --ziplevel\tGzip compression level, or 0 for plain text [int, default 0]\n"); fprintf(stderr, " -c, --combinatorial\tUse combinatorial barcode matching. [flag, default OFF]\n"); fprintf(stderr, " -p, --permissive\tDon't error on barcode mismatch confict, matching only\n"); fprintf(stderr, " \texactly for conficting barcodes. [flag, default OFF]\n"); fprintf(stderr, " -2, --trim-r2\tTrim barcode from R2 read as well as R1. [flag, default OFF]\n"); fprintf(stderr, " -b, --barcodes\tBarcode file. See --help for example. [file]\n"); fprintf(stderr, " -f, --fwd-in\tInput forward read. [file]\n"); fprintf(stderr, " -F, --fwd-out\tOutput forward read prefix. [file]\n"); fprintf(stderr, " -r, --rev-in\tInput reverse read. [file]\n"); fprintf(stderr, " -R, --rev-out\tOutput reverse read prefix. [file]\n"); fprintf(stderr, " -i, --ilfq-in\tInput interleaved paired reads. [file]\n"); fprintf(stderr, " -I, --ilfq-out\tOutput interleaved paired reads prefix. [file]\n"); fprintf(stderr, " -t, --table-file\tOutput a summary table of demultiplexing statistics to file. [file]\n"); fprintf(stderr, " -h, --help\t\tPrint this usage plus additional help.\n"); fprintf(stderr, " -V, --version\tPrint version string.\n"); fprintf(stderr, " -v, --verbose\tBe more verbose. Additive, -vv is more vebose than -v.\n"); fprintf(stderr, " -q, --quiet\t\tBe very quiet.\n"); fprintf(stderr, "\n"); } static const char *axe_opts = "m:z:c2pb:f:F:r:R:i:I:t:hVvqd"; static const struct option axe_longopts[] = { { "mismatch", optional_argument, NULL, 'm' }, { "ziplevel", required_argument, NULL, 'z' }, { "combinatorial", no_argument, NULL, 'c' }, { "trim-r2", no_argument, NULL, '2' }, { "permissive", no_argument, NULL, 'p' }, { "barcodes", required_argument, NULL, 'b' }, { "fwd-in", required_argument, NULL, 'f' }, { "fwd-out", required_argument, NULL, 'F' }, { "rev-in", required_argument, NULL, 'r' }, { "rev-out", required_argument, NULL, 'R' }, { "ilfq-in", required_argument, NULL, 'i' }, { "ilfq-out", required_argument, NULL, 'I' }, { "table-file", required_argument, NULL, 't' }, { "help", no_argument, NULL, 'h' }, { "version", no_argument, NULL, 'V' }, { "verbose", no_argument, NULL, 'v' }, { "debug", no_argument, NULL, 'd' }, { NULL, 0, NULL, 0 } }; static int parse_args(struct axe_config *config, int argc, char * const *argv) { int c = 0; int optind = 0; if (argc < 2 ) { return 1; } if (!axe_config_ok(config) || argc < 1 || argv == NULL) { goto error; } /* Set some sane defaults */ /* Most things will default to 0 as we `calloc` the config struct, so we * don't need to explicity set them. */ config->mismatches = 1; config->verbosity = 0; config->out_compress_level = 0; /* Parse argv using getopt */ while ((c = getopt_long(argc, argv, axe_opts, axe_longopts, &optind)) > 0){ switch (c) { case 'm': config->mismatches = atol(optarg); break; case 'z': config->out_compress_level = atoi(optarg); break; case 'c': config->match_combo |= 1; break; case 'p': config->permissive |= 1; break; case '2': config->trim_rev |= 1; break; case 'b': config->barcode_file = strdup(optarg); break; case 'f': if (config->in_mode == READS_INTERLEAVED) { goto error; break; } config->infiles[0] = strdup(optarg); if (config->in_mode == READS_UNKNOWN) { config->in_mode = READS_SINGLE; } break; case 'F': config->out_prefixes[0] = strdup(optarg); config->out_mode = READS_SINGLE; break; case 'r': if (config->in_mode == READS_INTERLEAVED) { goto error; break; } config->infiles[1] = strdup(optarg); config->in_mode = READS_PAIRED; break; case 'R': config->out_prefixes[1] = strdup(optarg); config->out_mode = READS_PAIRED; break; case 'i': config->infiles[0] = strdup(optarg); config->in_mode = READS_INTERLEAVED; break; case 'I': config->out_prefixes[0] = strdup(optarg); config->out_mode = READS_INTERLEAVED; break; case 't': config->table_file = strdup(optarg); break; case 'h': goto help; case 'V': goto version; case 'v': config->verbosity += 1; break; case 'q': config->verbosity -= 1; break; case 'd': config->debug = 1; break; case '?': default: /* Getopt long prints its own error msg */ goto error; } } /* Check options are sane */ if (config->barcode_file == NULL) { fprintf(stderr, "ERROR: Barcode file must be provided\n"); goto error; } if (config->mismatches > 4) { fprintf(stderr, "ERROR: Silly mismatch level %zu\n", config->mismatches); goto error; } if (config->in_mode == READS_UNKNOWN) { fprintf(stderr, "ERROR: Input file(s) must be provided\n"); goto error; } if (config->infiles[0] == NULL) { switch (config->in_mode) { case READS_SINGLE: fprintf(stderr, "ERROR: Setting forward read input file failed.\n"); break; case READS_PAIRED: fprintf(stderr, "ERROR: Forward read file must be provided.\n"); break; case READS_INTERLEAVED: fprintf(stderr, "ERROR: Setting interleaved input file failed.\n"); break; case READS_UNKNOWN: default: break; } goto error; } if (config->infiles[1] == NULL) { switch (config->in_mode) { case READS_SINGLE: case READS_INTERLEAVED: /* Not an error */ break; case READS_PAIRED: fprintf(stderr, "ERROR: Setting revese read input file failed.\n"); goto error; break; case READS_UNKNOWN: default: goto error; break; } } if (config->infiles[1] != NULL) { switch (config->in_mode) { case READS_PAIRED: /* Not an error */ break; case READS_INTERLEAVED: fprintf(stderr, "ERROR: Revese read input file set in interleaved mode.\n"); goto error; break; case READS_SINGLE: fprintf(stderr, "ERROR: Revese read input file set in single-end mode.\n"); goto error; break; case READS_UNKNOWN: default: /* Misc weirdness */ goto error; break; } } if (config->out_prefixes[0] == NULL) { switch (config->out_mode) { case READS_SINGLE: fprintf(stderr, "ERROR: Setting forward read output prefix failed.\n"); break; case READS_PAIRED: fprintf(stderr, "ERROR: Forward read prefix must be provided.\n"); break; case READS_INTERLEAVED: fprintf(stderr, "ERROR: Setting interleaved output prefix failed.\n"); break; case READS_UNKNOWN: default: break; } goto error; } if (config->out_prefixes[1] == NULL) { switch (config->out_mode) { case READS_SINGLE: case READS_INTERLEAVED: /* Not an error */ break; case READS_PAIRED: fprintf(stderr, "ERROR: Setting revese read output prefix failed.\n"); goto error; break; case READS_UNKNOWN: default: goto error; break; } } if (config->out_prefixes[1] != NULL) { switch (config->out_mode) { case READS_PAIRED: /* Not an error */ break; case READS_INTERLEAVED: fprintf(stderr, "ERROR: Revese read output prefix set in interleaved mode.\n"); goto error; break; case READS_SINGLE: case READS_UNKNOWN: default: /* Misc weirdness */ goto error; break; } } config->have_cli_opts = 1; format_call_number = 0; qes_logger_init(config->logger, "[axe] ", QES_LOG_DEBUG); qes_logger_add_destination_formatted(config->logger, stderr, QES_LOG_DEBUG, &axe_formatter); return 0; error: fprintf(stderr, "Axe failed due to bad CLI flags. Consult the usage below please!\n\n"); config->have_cli_opts = 0; return 1; help: config->have_cli_opts = 0; return 2; version: print_version(); axe_config_destroy(config); exit(0); } int main (int argc, char * const *argv) { int ret = 0; struct axe_config *config = axe_config_create(); if (config == NULL) { ret = EXIT_FAILURE; goto end; } ret = parse_args(config, argc, argv); if (ret != 0) { print_usage(); if (ret == 2) { print_help(); } goto end; } ret = axe_read_barcodes(config); if (ret != 0) { fprintf(stderr, "[main] ERROR: axe_read_barcodes returned %i\n", ret); fprintf(stderr, "\tThis indicates that the barcode file is invalid.\n"); fprintf(stderr, "\tPlease check that it conforms to the layout described in the help message\n"); goto end; } ret = axe_setup_barcode_lookup(config); if (ret != 0) { fprintf(stderr, "[main] ERROR: axe_setup_barcode_lookup returned %i\n", ret); goto end; } ret = axe_make_tries(config); if (ret != 0) { fprintf(stderr, "[main] ERROR: axe_make_tries returned %i\n", ret); goto end; } ret = axe_load_tries(config); if (ret != 0) { fprintf(stderr, "[main] ERROR: axe_load_tries returned %i\n", ret); goto end; } ret = axe_make_outputs(config); if (ret != 0) { fprintf(stderr, "[main] ERROR: axe_make_outputs returned %i\n", ret); goto end; } ret = axe_process_file(config); if (ret != 0) { fprintf(stderr, "[main] ERROR: axe_process_file returned %i\n", ret); goto end; } ret = axe_print_summary(config); if (ret != 0) { fprintf(stderr, "[main] ERROR: axe_print_summary returned %i\n", ret); goto end; } ret = axe_write_table(config); if (ret != 0) { fprintf(stderr, "[main] ERROR: axe_write_table returned %i\n", ret); goto end; } end: axe_config_destroy(config); return ret; } axe-0.3.1/tests/000077500000000000000000000000001263567001600134405ustar00rootroot00000000000000axe-0.3.1/tests/CMakeLists.txt000066400000000000000000000071601263567001600162040ustar00rootroot00000000000000INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/tinytest) ADD_EXECUTABLE(test_axe test.c ${CMAKE_CURRENT_SOURCE_DIR}/tinytest/tinytest.c test_libaxe.c) TARGET_LINK_LIBRARIES(test_axe ${AXE_DEPENDS_LIBRARIES} axelib) # Copy test files over to bin dir & make output ADD_CUSTOM_TARGET(setup_tests ALL COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/data ${CMAKE_BINARY_DIR}/data COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/axe_cli_tests.py ${CMAKE_BINARY_DIR}/bin COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/out) ADD_DEPENDENCIES(test_axe setup_tests) ADD_TEST(NAME "UnitTests" COMMAND test_axe) SET(COVERAGE_CMD test_axe) SET(COVERAGE_OUT "${CMAKE_BINARY_DIR}/coverage_html") ADD_TEST(NAME "IntegrationTests" COMMAND python ${CMAKE_BINARY_DIR}/bin/axe_cli_tests.py ${CMAKE_BINARY_DIR}) IF (CMAKE_BUILD_TYPE STREQUAL "Coverage") FIND_PROGRAM( GCOV_PATH gcov ) FIND_PROGRAM( LCOV_PATH lcov ) FIND_PROGRAM( GENHTML_PATH genhtml ) FIND_PROGRAM( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/tests) SET(CMAKE_C_FLAGS_COVERAGE "${CMAKE_C_FLAGS_DEBUG} -g -O0 --coverage -fprofile-arcs -ftest-coverage" 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_C_FLAGS_COVERAGE CMAKE_EXE_LINKER_FLAGS_COVERAGE CMAKE_SHARED_LINKER_FLAGS_COVERAGE ) IF(NOT GCOV_PATH) MESSAGE(FATAL_ERROR "gcov not found! Aborting...") ENDIF() # NOT GCOV_PATH 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 IF(NOT CMAKE_COMPILER_IS_GNUCC AND NOT CMAKE_COMPILER_IS_GNUCXX) # Clang version 3.0.0 and greater now supports gcov as well. MESSAGE(WARNING "Compiler is not GNU gcc! Clang Version 3.0.0 and greater supports gcov as well, but older versions don't.") IF(NOT "${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" AND NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") MESSAGE(FATAL_ERROR "Compiler is not GNU gcc! Aborting...") ENDIF() ENDIF() # NOT CMAKE_COMPILER_IS_GNUCXX # Setup target ADD_CUSTOM_TARGET(coverage # Cleanup lcov COMMAND ${LCOV_PATH} --rc lcov_branch_coverage=1 --directory ${CMAKE_BINARY_DIR}/src --zerocounters # Run tests COMMAND ${COVERAGE_CMD} # Capturing lcov counters and generating report COMMAND ${LCOV_PATH} --rc lcov_branch_coverage=1 --directory ${CMAKE_BINARY_DIR}/src --capture --output-file ${COVERAGE_OUT}.info COMMAND ${LCOV_PATH} --rc lcov_branch_coverage=1 --output-file ${COVERAGE_OUT}.info --remove ${COVERAGE_OUT}.info src/kmlib/* COMMAND ${LCOV_PATH} --rc lcov_branch_coverage=1 --output-file ${COVERAGE_OUT}.info --remove ${COVERAGE_OUT}.info src/datrie/* COMMAND ${GENHTML_PATH} --branch-coverage -o ${COVERAGE_OUT} ${COVERAGE_OUT}.info COMMAND ${CMAKE_COMMAND} -E remove ${COVERAGE_OUT}.info WORKING_DIRECTORY ${CMAKE_BINARY_DIR} COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report." ) # Show info where to find the report ADD_CUSTOM_COMMAND(TARGET coverage POST_BUILD COMMAND ; COMMENT "Open ${COVERAGE_OUT}/index.html in your browser to view the coverage report." ) ENDIF() # build type coverage axe-0.3.1/tests/axe_cli_tests.py000077500000000000000000000165231263567001600166520ustar00rootroot00000000000000#!/usr/bin/env python from __future__ import print_function import hashlib import logging import os from os import path import re import shutil import subprocess as sp import sys import unittest if len(sys.argv) < 2: print("USAGE: axe_cli_tests.py $CMAKE_BINARY_DIR") exit(-1) CMAKE_BINARY_DIR = sys.argv.pop(1) def md5sum(filename): h = hashlib.md5() with open(filename, 'rb') as fh: while True: hunk = fh.read(1024 ** 2) if not hunk: break h.update(hunk) return h.hexdigest() class AxeTest(unittest.TestCase): maxDiff= None def __init__(self, methodName='runTest'): super(AxeTest, self).__init__(methodName) self.data = path.join(CMAKE_BINARY_DIR, "data") self.out = path.join(CMAKE_BINARY_DIR, "out", "cli_tests") self.axe = path.join(CMAKE_BINARY_DIR, "bin", "axe-demux") self.log = logging.getLogger("AxeTest") if not path.exists(self.data) or not path.exists(self.axe): print("Please run axe_cli_tests.py after compiling axe") exit(-1) def setUp(self): if not path.exists(self.out): os.makedirs(self.out) def run_and_check_stdout(self, command): self.log.debug(" ".join(command)) try: output = sp.check_output(command, stderr=sp.STDOUT) except sp.CalledProcessError as err: self.log.info(err.output) return False return True def get_md5_dict(self): dct = {} for root, dirs, files in os.walk(self.out): for fle in files: md5 = md5sum(path.join(root, fle)) dct[path.basename(fle)] = md5 return dct def tearDown(self): if path.exists(self.out): shutil.rmtree(self.out) class TestBadUsage(AxeTest): def __init__(self, methodName='runTest'): super(TestBadUsage, self).__init__(methodName) def test_bad_command(self): command = [self.axe, "-f"] self.assertFalse(self.run_and_check_stdout(command)) self.assertDictEqual({}, self.get_md5_dict()) class TestPareSE(AxeTest): def __init__(self, methodName='runTest'): super(TestPareSE, self).__init__(methodName) self.infq = path.join(self.data, "pare.fq.gz") self.barcodes = path.join(self.data, "pare.barcodes") self.outfq = path.join(self.out, "pare_se") self.nobcdfq = path.join(self.out, "pare_se_unknown_R1.fastq") def test_pare_se(self): command = [self.axe, "-f", self.infq, "-F", self.outfq, '-b', self.barcodes, ] self.assertTrue(self.run_and_check_stdout(command)) files = { 'pare_se_1_R1.fastq': 'd41d8cd98f00b204e9800998ecf8427e', 'pare_se_2_R1.fastq': 'd41d8cd98f00b204e9800998ecf8427e', 'pare_se_3_R1.fastq': 'd41d8cd98f00b204e9800998ecf8427e', 'pare_se_4_R1.fastq': '8e5eef3323e597b209f79dc9fcd74c9a', 'pare_se_5_R1.fastq': 'd41d8cd98f00b204e9800998ecf8427e', 'pare_se_6_R1.fastq': '7228a165f353920328360dedc3a41205', 'pare_se_7_R1.fastq': 'd41d8cd98f00b204e9800998ecf8427e', 'pare_se_8_R1.fastq': 'b349d3276ba7c7515d0093b1a49b3959', 'pare_se_9_R1.fastq': '74b4763271aefcc135425b06730874ba', 'pare_se_unknown_R1.fastq': 'd450569dd8fd4bdddffbfaeec4980273', } self.assertDictEqual(files, self.get_md5_dict()) def test_pare_se_zip(self): command = [self.axe, "-f", self.infq, "-F", self.outfq, '-b', self.barcodes, '-z', '9', ] files = { 'pare_se_1_R1.fastq.gz': '4a4dd3598707603b3f76a2378a4504aa', 'pare_se_2_R1.fastq.gz': '4a4dd3598707603b3f76a2378a4504aa', 'pare_se_3_R1.fastq.gz': '4a4dd3598707603b3f76a2378a4504aa', 'pare_se_4_R1.fastq.gz': '96d21b860a0fc70641ea43d350433d11', 'pare_se_5_R1.fastq.gz': '4a4dd3598707603b3f76a2378a4504aa', 'pare_se_6_R1.fastq.gz': 'd6044c04f79c358e4a1d443f8828df18', 'pare_se_7_R1.fastq.gz': '4a4dd3598707603b3f76a2378a4504aa', 'pare_se_8_R1.fastq.gz': 'da77b8e95827d362a1702ce4fe75c7a9', 'pare_se_9_R1.fastq.gz': '9c160b0daa0c73e5ef0994206774a5a0', 'pare_se_unknown_R1.fastq.gz': 'afd5737935814d756e89c365d2d61c7b', } self.assertTrue(self.run_and_check_stdout(command)) self.assertDictEqual(files, self.get_md5_dict()) class TestFakeSE(AxeTest): files = { 'fake_se_1_R1.fastq': '836eaf06938d4a41122f284ed487a9c7', 'fake_se_2_R1.fastq': '836eaf06938d4a41122f284ed487a9c7', 'fake_se_unknown_R1.fastq': '836eaf06938d4a41122f284ed487a9c7', } zfiles = { 'fake_se_1_R1.fastq.gz': '3e07353d24a3ecd315067250a6be6047', 'fake_se_2_R1.fastq.gz': '3e07353d24a3ecd315067250a6be6047', 'fake_se_unknown_R1.fastq.gz': '3e07353d24a3ecd315067250a6be6047', } def __init__(self, methodName='runTest'): super(TestFakeSE, self).__init__(methodName) self.barcodes = path.join(self.data, "fake.barcodes") self.outfq = path.join(self.out, "fake_se") self.nobcdfq = path.join(self.out, "fake_se_unknown_R1.fastq") def _do_test(self, mm_level): infq = path.join(self.data, "fake_{}mm_R1.fq.gz".format(mm_level)) command = [self.axe, "-f", infq, "-F", self.outfq, '-b', self.barcodes, ] self.assertTrue(self.run_and_check_stdout(command)) def _do_test_zip(self, mm_level): infq = path.join(self.data, "fake_{}mm_R1.fq.gz".format(mm_level)) command = [self.axe, "-f", infq, "-F", self.outfq, '-b', self.barcodes, '-z', '9', ] self.assertTrue(self.run_and_check_stdout(command)) def test_fake_se_0mm(self): self._do_test(0) self.assertDictEqual(self.files, self.get_md5_dict()) def test_fake_se_0mm_zip(self): self._do_test_zip(0) self.assertDictEqual(self.zfiles, self.get_md5_dict()) def test_fake_se_1mm(self): self._do_test(1) self.assertDictEqual(self.files, self.get_md5_dict()) def test_fake_se_1mm_zip(self): self._do_test_zip(1) self.assertDictEqual(self.zfiles, self.get_md5_dict()) def test_fake_se_2mm(self): self._do_test(2) files = { 'fake_se_1_R1.fastq': 'd41d8cd98f00b204e9800998ecf8427e', 'fake_se_2_R1.fastq': 'd41d8cd98f00b204e9800998ecf8427e', 'fake_se_unknown_R1.fastq': 'a6de105b6c5abbc2d0d16440333adc64', } self.assertDictEqual(files, self.get_md5_dict()) def test_fake_se_2mm_zip(self): self._do_test_zip(2) zfiles = { 'fake_se_1_R1.fastq.gz': '4a4dd3598707603b3f76a2378a4504aa', 'fake_se_2_R1.fastq.gz': '4a4dd3598707603b3f76a2378a4504aa', 'fake_se_unknown_R1.fastq.gz': 'ee6979b139dbd898f058fd7649f87da2', } self.assertDictEqual(zfiles, self.get_md5_dict()) if __name__ == '__main__': log = logging.getLogger("AxeTest") fmt = logging.Formatter('%(message)s') cons = logging.StreamHandler() cons.setLevel(logging.DEBUG) cons.setFormatter(fmt) log.addHandler(cons) log.setLevel(logging.DEBUG) unittest.main() axe-0.3.1/tests/data/000077500000000000000000000000001263567001600143515ustar00rootroot00000000000000axe-0.3.1/tests/data/fake.barcodes000066400000000000000000000000351263567001600167610ustar00rootroot00000000000000Barcode ID ATCACG 1 CGATGT 2 axe-0.3.1/tests/data/fake_0mm_R1.fq.gz000066400000000000000000000003601263567001600173400ustar00rootroot00000000000000Sfake_0mm_R1.fqPn0 8 X@lKZʒq~QNǻ# ^m?o aL A #0pai-Y UL7;鲪S);$}n/v[ܝ_r)B"Y6 BX[e8 Z$>~][%jT"ÒYOX(^+ 3QN彫د( Ձaxe-0.3.1/tests/data/fake_1mm_R1.fq.gz000066400000000000000000000003611263567001600173420ustar00rootroot00000000000000Sfake_1mm_R1.fqPn0 8 X@lKZʒN~QMǻ#)^m?o aL A #0pai- UL7=6˪^KNcN/7I)7ͽb-"$"%+jӛP.U^1IJ׵UVOeZ*2,).ԏ0T޻(os?9Kaxe-0.3.1/tests/data/fake_2mm_R1.fq.gz000066400000000000000000000003611263567001600173430ustar00rootroot00000000000000Sfake_2mm_R1.fqPn0 8 X@lKZʒN~QM;)^m?o aL A #0pai- UL7=6˪^KNqy b-"$"%+jӛP.U^1IJ*Q2- }BDŀ\Yr*]k'OFqTǜ }axe-0.3.1/tests/data/gbs.barcodes000066400000000000000000000051551263567001600166360ustar00rootroot00000000000000Barcode1 Barcode2 ID CTCGTGCAG CGAGTGCAG A1 TGCATGCAG TGCATGCAG A2 ACTATGCAG TAGTTGCAG A3 CAGATGCAG TCTGTGCAG A4 AACTTGCAG AGTTTGCAG A5 GCGTTGCAG ACGCTGCAG A6 CGATTGCAG ATCGTGCAG A7 GTAATGCAG TTACTGCAG A8 AGGGTGCAG CCCTTGCAG A9 GATGTGCAG CATCTGCAG A10 TCAGTGCAG CTGATGCAG A11 TGCGATGCAG TCGCATGCAG A12 CGCTTTGCAG AAGCGTGCAG B1 TCACGTGCAG CGTGATGCAG B2 CTAGGTGCAG CCTAGTGCAG B3 ACAAATGCAG TTTGTTGCAG B4 TTCTGTGCAG CAGAATGCAG B5 AGCCGTGCAG CGGCTTGCAG B6 GTATTTGCAG AATACTGCAG B7 CTGTATGCAG TACAGTGCAG B8 ACCGTTGCAG ACGGTTGCAG B9 GCTTATGCAG TAAGCTGCAG B10 GGTGTTGCAG ACACCTGCAG B11 AGGATTGCAG ATCCTTGCAG B12 ATTGATGCAG TCAATTGCAG C1 CATCTTGCAG AGATGTGCAG C2 CCTAGTGCAG CTAGGTGCAG C3 GAGGATGCAG TCCTCTGCAG C4 GGAAGTGCAG CTTCCTGCAG C5 GTCAATGCAG TTGACTGCAG C6 TAATATGCAG TATTATGCAG C7 TACATTGCAG ATGTATGCAG C8 TCGTTTGCAG AACGATGCAG C9 GGTTGTTGCAG ACAACCTGCAG C10 CCAGCTTGCAG AGCTGGTGCAG C11 TTCAGATGCAG TCTGAATGCAG C12 TAGGAATGCAG TTCCTATGCAG D1 GCTCTATGCAG TAGAGCTGCAG D2 CCACAATGCAG TTGTGGTGCAG D3 CTTCCATGCAG TGGAAGTGCAG D4 GAGATATGCAG TATCTCTGCAG D5 ATGCCTTGCAG AGGCATTGCAG D6 AGTGGATGCAG TCCACTTGCAG D7 ACCTAATGCAG TTAGGTTGCAG D8 ATATGTTGCAG ACATATTGCAG D9 ATCGTATGCAG TACGATTGCAG D10 CATCGTTGCAG ACGATGTGCAG D11 CGCGGTTGCAG ACCGCGTGCAG D12 CTATTATGCAG TAATAGTGCAG E1 GCCAGTTGCAG ACTGGCTGCAG E2 GGAAGATGCAG TCTTCCTGCAG E3 GTACTTTGCAG AAGTACTGCAG E4 GTTGAATGCAG TTCAACTGCAG E5 TAACGATGCAG TCGTTATGCAG E6 TGGCTATGCAG TAGCCATGCAG E7 TATTTTTTGCAG AAAAATATGCAG E8 CTTGCTTTGCAG AAGCAAGTGCAG E9 ATGAAAGTGCAG CTTTCATTGCAG E10 AAAAGTTTGCAG AACTTTTTGCAG E11 GAATTCATGCAG TGAATTCTGCAG E12 GAACTTGTGCAG CAAGTTCTGCAG F1 GGACCTATGCAG TAGGTCCTGCAG F2 GTCGATTTGCAG AATCGACTGCAG F3 AACGCCTTGCAG AGGCGTTTGCAG F4 AATATGGTGCAG CCATATTTGCAG F5 ACGTGTTTGCAG AACACGTTGCAG F6 ATTAATTTGCAG AATTAATTGCAG F7 ATTGGATTGCAG ATCCAATTGCAG F8 CATAAGTTGCAG ACTTATGTGCAG F9 CGCTGATTGCAG ATCAGCGTGCAG F10 CGGTAGATGCAG TCTACCGTGCAG F11 CTACGGATGCAG TCCGTAGTGCAG F12 GCGGAATTGCAG ATTCCGCTGCAG G1 TAGCGGATGCAG TCCGCTATGCAG G2 TCGAAGATGCAG TCTTCGATGCAG G3 TCTGTGATGCAG TCACAGATGCAG G4 TGCTGGATGCAG TCCAGCATGCAG G5 ACGACTAGTGCAG CTAGTCGTTGCAG G6 TAGCATGGTGCAG CCATGCTATGCAG G7 TAGGCCATTGCAG ATGGCCTATGCAG G8 TGCAAGGATGCAG TCCTTGCATGCAG G9 TGGTACGTTGCAG ACGTACCATGCAG G10 TCTCAGTGTGCAG CACTGAGATGCAG G11 CCGGATATTGCAG ATATCCGGTGCAG G12 CGCCTTATTGCAG ATAAGGCGTGCAG H1 AACCGAGATGCAG TCTCGGTTTGCAG H2 ACAGGGAATGCAG TTCCCTGTTGCAG H3 ACGTGGTATGCAG TACCACGTTGCAG H4 CCATGGGTTGCAG ACCCATGGTGCAG H5 CGCGGAGATGCAG TCTCCGCGTGCAG H6 CGTGTGGTTGCAG ACCACACGTGCAG H7 GCTGTGGATGCAG TCCACAGCTGCAG H8 GGATTGGTTGCAG ACCAATCCTGCAG H9 GTGAGGGTTGCAG ACCCTCACTGCAG H10 TATCGGGATGCAG TCCCGATATGCAG H11 TTCCTGGATGCAG TCCAGGAATGCAG H12 axe-0.3.1/tests/data/gbs_R1.fastq.gz000066400000000000000000002554601263567001600171610ustar00rootroot00000000000000Sgbs_R1.fastqْF%|O1fEJTnbn0dxT lEV1k/|>KQex]?.|Exuw}\!bpDЇ)EtD|O.W_SQ~o/ *WkahC;M.q|k&4s]Vq}3ƺP7Ut>U={_P`me__e~uҟח^L C I^pY'D~$}a0M*/_Ve])a#/G+$ Df<4}}տ)ēS`{>qk[ec Yyv6L˯GY5 (5D^ Eȷ?!$|ҫ'8{z0cia6}cК>ZCۺx#e&9 1ȿWd_^;QY7%a#DTF˷O(_c= ·a B3fW~9v`O:jh!~>|e+d{NN?A\$fSo#G+vk+0N_vƜ\ӛN=zܽ0s[C]Лp*LX~1PKG^/<~9 Q~]i2nٴ6#W^~sb2Q3!;+AeГ7HB;O?/7_?ҋ=}>ݛ9\yuvH`阐=yJ>V}(˿n q!xhG@#159@6 %/^kF1I'׎&Dp|D*q/bWY_~6M?p|+/;q Z5ѨN: ÔH)SNVn2LbXžo9RX@3Clq5b|:k kzK˿W?iDtF\m td9IMDvDr1$f3\7tQǡq&n8N#Yr?L [ F+}x>)K4n _4}_7w?w1Xlz9X< 8PD+4!5Mv6aq"s_G)A{[@Of_c?V?;ZqMa{A+oSW=?=h+an>6In`e;OHaS!+,'6KKiCB 3;ϧ_-8.#pn, ~));CvI-zq `%' ܾra6Ǽ|NQfJJ1Pnc_w 0[2] ;@HlhtХ,/_s} O4#+pa+˷d g Z8r⠟Y?l(&/`oyo8&/g?> l角"#~1K\` x :C|:8.QHSLOxn!s7%K8Uc9@Ob2 vgx(x{6oOӴ^~XOuۨr9pCϐP`OA%k6^ %](p'Ƒ"qE t+6t&~D|D?y>kprC#=kr*o~:!"x_)o1\/-gϪtm(o {*֏bqL5h+ALwX%|햯I $K*W~5|88 '[frM } gל}]p9񽱕[o>W {Eؓm<=_8 _"qO[!( |TD}P(?nX3s΄n൮s7=U]^ u.n`))V+KGj1 G@OJNxyfJJ]}7L1wQ*4?ˣ{1P?ub{;P,l;{ ==,z~R!^dLBɂ㤨Ȁ$&|S2%# Ư,K8L| d|瘿_N䭒+_@x1/݃^нk= -zY;uISs{bBjBb %O $HТ_EH+{/)Ӻe}$5g0} OsT[x?k3΃dN2z7v|Ŗ ^\KCr&z&8]C_ݯ_SD=ިwtɾjH9_QBMzVr-A-A~ZYd?ήqsdoT p1]mAFk7V:x\#=I\/%呍8JKqm2NbEo众YOҸi |!ގV0Ϲ-:hPd[z҃|5M~4(S%jL=\Տ9W}~^ |-]wq^{< W3Kɜo)Z 'kXkH~2a̟I^$IJ}%I$ꋈ} )C0\sjx~XX+\i;`9pUAE-,*m?'GОV ?+g|ðkYJ8GƭkZ秥ܾh}^O?VUaVo[xgq>(ylĶ]}?i~'!Ғְ!?$7 <zG`,?mG|\(΂ֻA9n;I ԫB.MPޓ\Rp )h,PӨG{rn`W,%*Ed*<5tzrqoqpju]jF[2_n=E$~5D?h$Hg`2q=gtˍMb5r$>3 P+l)e ;{a>Fkj|XN9X}BJRJJN{\&O{)f9ٟ- Yv"/FqGǫ2GL` Uj~*[5YN{v<ˎ.ٺ)S.)+X* P +зRKMo=:lau.=ϻM <&yroƚ[Oy_;[v8KسUy\"u}x` y?>p.>XK`ܺ>Nn+`t1GA/2yHw!Xfx -*`;ߵ34f|}VY5۟O[I\  silٝxïo^6):6ԙƇE\0w F pU(kBgؖK-]%4;hh))@߾(ɔ^18G>ngxl.rЃrUP~&pN$0Iw=m]`;F3,6A:'`Q3Pñ nfGT5 ‹@$/0O>h-cwlIC 2a㣊=.Ի!̒/mLbYlxN7Y 8胪̍v'N,9h =?=ܭj{k8߱ĶG9Ql 6.3<efQ׊@K~_^2(W 9DKRa =Z>-%ۃJؚ!ǽ3\xϗ~_vT]CPD[kԄG괳𮜦rlm!ϼf0GZHitEedny-}}k>ܪ)OGkܙYoF{B.m\3gYZ(m&'ZsD/>7$=`(_=MQ;C̣hl- E|Oȋ]>E{ 3`lF!6luI=wX_ul%.2x崜ւtDz?A@Έnh#?G}d|! +sޙ8LN|GR()B=opfR7w$mϹhv pN1`O|p/ :?8{ d{N9O1Yإo]Vٵ2Lq)#Q AD4_T%fm=]2;+clž0Rĸ4nog^\GI9:Yhs)yט_X熵OppQaq2JSn 0av N:Z\G9 t`{7#wYX0aWW,/%+>)]Mˏ87+~L\-\6 (R"Q02Aa1@ȓВ0hsR<F5Py!0X }@sy;ns@s D_=7uOv2Y+ek˯yo O͚#s\Ubie'wܡ>ӳp׏A8/3q t Ssnt[ݑ'}ji꾼ezJ\_.v|VKL>NPδvoKJk]^t[m$(.XoNO8Mz!J`05ǘ]gQ`_pҚ3P#R:iO6U7B5q>frԠDg/I32n/?d+i%}+5P5$=M}qFw.Hn>FH|Y}+XߕwWG]M/1:"}o?0ܿA Ћ^|-:rBLyt?Ug‘SG V5<7fT\֖Lx}~ =Ξ 4N`[~YҀ/@8lvA7`m@Ư.y`I ;Ș_1r ~2vfY$eͷ"! -*w|gm,B]+*o)-|S%Q|_ڹ$fD4&9C{NתX5*-˖}ىWKBfLaʟBQr58CYPv "l5E)@3u[hڻsonB뇷rx3[wFv~;vݭϧ;OR۶V=7ibT/_t)eC:(@$;hZ%LN77wv~xFkL`E[k=7O,~{;߁?nZ]a4k[h F ,:3t zxǷ ˭'/۳Qew:fqjg0mlxsnAoݎ2h+:ӳi(#}<ߞ3omZK*S}՗͵5@fV箕 ݇[&)Iڙ7@Jzqݍ" oGN+d ƍs߮eu8}e1mǶzI64nx5%dKLW}|!OO 컒f-”!P{ GG.m'Y?꼟[ZAa:ÏCZ @LIik3y{¨zu/.ޘ3Fɏ&pz|\ dFL4/<~(J Q{? h/CCa mB#^:\d(#7,Sg&BE᲌3XK$k8Q?? TXcLeW)!hT 7.+"拏#,r1 6q-k͖o Pd|PݘչIm_y)Z2bP:z=+L,E[_jvT&.WޯE  oDU(I& ]`4J_;JŦoҜ dcapYz[YB#A//U'7&|qսOĖh=y|Zjq+ +F¸e#˰bOouVmr/wt#[qܲiw# XLp On=;L֘{Ԧ*[C>le>eپuz,L|acD!0XGwHYZ pn}.5imsAc?"L@!' ?~^vq1Ï ua,R~NYWg.O%-ӹKX~ m \v,*4 s_YZ ڞˮYI"F5{(9oT5E@cһ ~t6.sW p=ZEm.K^mdDk zdT m~Qk_N"o{; $]wt%G@\;#)kE>ۺ͉ۢRRw#`f1qn7:6wd|?dPO8^mA7/8M|E A ^Wox3uݱVyF4(*M)mda}JDǿ_:;wJͬnB$HC̨(mNvLH#zJk hBQ$堷0lq2KO~hлVIBk\w~< vպSXܽ]i~a}JaKԩ|m#@TJt =lW fJN]6ӡYGaN) :·h$OS\%W2C3IkR}ehЅ&ծid72w+M7LIc(˖:㥙)\{vSK *I԰kj⹯e+K:~oQ;CyΪgfzX|`-#h7^rOI%I՝l*c%!Orp/Y>-_Bw!]EO0~gt 8p1iܮ|/HzWk򏃌+䕁 ](xݼs%}fe_[2yuo> \ϖSŽgq5F!^Ӹ9,;zׇ?pGFp*#QPP*_V_6kCgV$w7KPQP;GL09p`Bi9ͳVoa~qV˵}_V"W.q|n1<6uCVhi SIcq yž2!?!#8":T*+ܛ(鑪}۠Bsst@B;ᚔsT&ѹ+Jl~ըjLnՄ!j7{ne4|7}صa>m3mprW}~\~X )=-HgYO2sq3e SP7(dj`w坕;FD\0ܹO)/a.}j!{:ӰFHcu%K,NUk3]PZ\1,Y:6TV rɣ\mixS8f{2vn h7tި O27oeg_NGn;rRZ;k3?H%xпouZʍ^1T[{V('gg␮6VpkܱY~{Ov| +GVѣF.e '~ȀrOmH3]Y KDkWsV:Fa?,`~~UD:cJXrc}:yhd39@흃4u{qW2-! d/1AgWB56w&qz,& ULfSkxP[UVݥ,~QzۙN?ӏ~i #;wԚrKסfhvV!u ^VڹmY0x^rKh.p6L8|&[? t!7p+wE5*s=(~enC@k /r _Y ȼQ7fyT`B-e`9ҪK8L~AĖ(^D}gUlu m@OOj4Q/Q"ߤK"ϖfM˄L֋Tb){6o:WrhvN.ɶ?́ӑr|c\ģHQ@ +[auij`Cf2~v:#K/_dQm٣$h׫}d$鑄o-$1ea&e9LCQϦ4\77U1%؜'bB"d oz,Uc*^w_4}g:ۀn3YSZ&\ԶV5" U7AՄ?33# 2ɋ]$iy&G ܹXk'V?;|sBD*s^xq|$iA[ֱsK7C;^66ّ]^ozYTduCjl ڏ;զjRB`²t-pX_o.JcNC{C{'xz{+UkyEdǷqT-vQ-q@PG*Lצ< ?:niQ)MM!D?OlC`.tϮ۷/E)\ ew6gN}S]ve*5+oeQU= \Q5^ߝ7}s1 ƐP8?Xgk"]Ʒƾqͷa;؏q 8Ӧe:f :qlĉAzө6*O4<`{"oֱf0W2=k~8=lx|@˨[ km=f0lAĄJ>:QXhYdJ>U?ޘ.ڔ'2yd S@hmq*ьݞm&a.M{6 GKCέfO-H81ds+:FC6~qXy?"VpMN8US<oKK 0mQ AI+B Z%wޜ눎}C`wp5Tg+:Htkj"Vt0}w;JwP O~3 ȸyujT֊+wg4*Ӂfu-M?h.@[kbHp' `rϔҏ3G a%.ۗ]E>t2wY<θ\7I6r-7yQh"s+rIFSyM)[tx咆S20ZޣJȻ`8dI7{L𥤆б~BOyCCC{Ɨ})q>/^T,F)~Yڡ✪U ˮG@q>{fl8jJ ,pN0rOhsݮ"\sy}a tO15em h挹ЏR\i0R6?v1Zsү,h)g <_X<ĉŸP?sg •Q_Q|ٚXTYc@ul i*_%u6eunMW`-6!{wKVO5 k]7@Lk^qp~E(]ANM5P̏TMAI`%''m;3{ݶXr>N~Z(Gg>ߺF+jv*=QIu(`UQ1n{IΘ;RD1n/N:d٭<.yL4tj©X`Xo}p޺{O r~)&l`[Q7 2LMGpӉㇶ`YrnNfem*`2DⲟȖc^=,BPn kw68IB L8QŊPFq@(,hHkv[yjNA~?Lu IV6T9Jw>&V(EfО>& [&(:PĠv\;M @BƇ4Wn 7'c~?;v/iȑ䗥'Q>͍#H~, Z`F,Nn~3+٘oЍsI/Wyd:CUbپ(\pf0 [K ُ:I?T1/pr8WF.YIWns|gl ` =e IP+HK-fՂ:Li ߗ&y6%~qqI4P#zC+}Vvv7PqÓF/͹k n;J%w`y߶-']#Jk*6dk'V촕#kBb Otb\ɏȃfNqd6SMA?xe[377jwFDATD3rPGO_҈/9SYL@/yaNyn@P9>]3tږT*x]Z) AQrnfxv~􏟭z,2gd~H1\R blw=2oDI/gt)B˝9Jvk9ArD3Ft8(m(/fpbD?o"] t3;(tDzeXXJ҃2 y1Q{7g.k]#7 a偀?vk3p%i >/ȍ&m/!>:9aK8~Ͼ1߫[Yd?:V/et((_esyV>U@89_z#@Q:3.{[7,j_Y;wYPb . aCDwUVs.#(Hs!G4<n)eXq$5Z0}<λ);ŶMl.^.SZA\yZjRtlg{ker7op#j)TRpL7>p,`}ͱ PC9S }EPT%"HH18l_dWKr_]` :̀qk9sc鍩\C;672KnJ^H݋*림Lw/`Zs BSE'rrJϑGprT2d# :D;Yd 9Dknӑu Qq89 KNPHXswK&e`Wy{ŸiNiNkl7[|:>ftq Gn!h 򫒵\BFN-pv X,wo s; )F{֢e02e=8Hڰ֧D? 9U˭rW{;[O=A"|sBf|]n>ߵ5j9:֏8av̪8-k՘A_|`"< eTZ#8zEkK~aiكfGa,_lt'4,\kwDHXW5x~.5rK[ʔFC}w{5vUoOt E"Ht嚼b {嘧~*?7~Z(Ꮯ,&C䬱/]B6Ws9Ί,T47r|P[[S \p|a8>U#@>@~bDRA~+2֩LI;Y+L˄@gږ "PJ;7Q8ec1hu./MJj q.E$jB-;*X<Ą{ڍc~i@FqG"պN^AF-b|bw|^>?A~ϔQ}O!\yMM/„s~qm}M_(G}u8l.yԀsVq]4{QئxVl ]\^AI]B? 큨o ^b rRR+PeXk_62'`!6S|ҙANy4Q=6(嶽!+3u##xr{$]usЯJp}h8QWyоQ.kЭx.|H%0xR7-`*+p8y4C.GhR:)R69Z╇B.ŕ(KҎsO[ޙ&B:)q iiU)G[WtYI"`CV";j@[LlHd~]칈(0yfCfΘH3V:f6Z{#kqycwHB|MƔ;AZ&rMQ%&bDCB˪]{wt+ :tYsNN?FsGV5 @j_4f^9)fSRuRș(7F[z7au% qgnI!oK:[ёkQ鎰oХĤj/ E@_o>ޡW42άHYkm謜Wlv_L,W ,@1,h n+:\YR˟Xh1ñSZ5ݱ:㖸^*CIo䆠QcPf(\$u.Dp QzYX EKvA}ٻ o ixyN2Euhn)T 8RT*zQM+3׾7x!G1p_Fq8mƣ C E,Z&ϗ%N1=egh3ivƐZ va;*z|aY{?ܴ5\ q<]r 4v*N+*cwqhΙviA\u:L"'[vW?t1탔8eG !N/5>wO<{.k-ho >)!bJ1-dPA'oH^= 1C \ӣzE硖ALrZH {v`T/lrFpCr$5jLί!S}އ.`?n\Z*!}Dk5mmPGXGhO>tn0JJ~{i R Ss;u-$c؏<#L.'XPTw%t)}꯺^MHyb+7(.2]B=9 Xm˄8EWJi18:;kt>Hk- `<1ҁ&($ DRN^VOs`)lNߟl@e@;p6 2Y.֘pRv}U5Φ-Hi\]o g2&RrrF#Ety^(s).fcPp.xrխo&SnlUߩ55Ww擲*rgzH!YO+|Hv~C>SMHZzَX.<3]JĠ/2}UQ$()+RV^Fn[u्tu䶇IncRGaNaeQ(ٵ.ٵ0_s ?t()-A6vsA3њ{ͭS5Q4<8~“0){ko)1GR>Zz<>,_Chk#r¯1C"O6_3qjiiof͍GVi~7s~;}7T]C=5? k6}sjL_6\SeO?Vէ2Gq7rZ,i+z5w 8&~}K]'(+ VQCPCa鹸A>B)sy(yOQYܡDzK!/ywKlяܻ>+¾ xr zHToHHVDkU,XɎaӽ_yq zl3y+;-f'2`vKOd:>#֖ӵby`vv?mj*'ࠣ71iEJ-rc)~gyX;('x ߬25@ι܊u+=hJ6e(ĽMҶq7uڱ0aS8&~(k=o h ~]z)=qP:{ K2Pg;94uB>78J~[ǭ>8ys)ڇ`h0=W;:0C릷kVt糣}Nmm%'(חPgr&ak/!uRJ)%W|pټ ~3cY\HiRL2^ytqBv>>o۳Lo}PMP9$K5hBN{ W?*a:l8#t_xTEVDa.[Q;MtЗ*q괿!ת Zz/6ĩz7,ZE(hg ۢ(vd*lzh8Nz֦l?`=/>T+Ř`~:% Lܾ:?mg,?cƒSs4,н\(''?ϕ8L.-ՔWnd*U$wm)9~%-(j ܑ4X}p"(V2g+#kSGڰg9qVR܃\Ǿ`":I>Vzv$|v]P7nLΘR$DzhK6 Eo?Dz$8Q;;]A#`t{jsIPpM]i! l=`l%TŪ0B+Ji7'hi7)лvԚ@y~; }t卡qݝ.fofR΅Q` ?2Y:=)7h Tc@)bU:Q eiV iAb&ZpJRN|=ㆿoӲћ,*m5Ltt7wUwqʮO~C9#Hٸ|#dnN17żͧU,ҳ]j)KmѲKYkԧN_EJ;Λ|%3֖de+%ZV얐<(7bюz0A9=U{d;Kw97F> v:}f g}UK':Wָ[GZcҚtX'W?q}HY@_Ԓ(g%\z6%MF!7/+nf 7}@3 rp1; Y~q\Lo` 55Tw-e,)\?7 ^-9wp;ekci_1W k2w'[z\*z΋Ty,!,PrC'w..!A/OK[[?)V@8q_2=6J[3HGCŬRr{D؄sj хfۿvQN[œA1t:*X}غAb&?oKk_J'VTEb?!G!=;NQD=g5Ź-:qZ3Lm5ہ/1bǘ/vpf ;TJ\!yKxEG)͔q2)}n-c_͏E SSPh9tNTt)#^? Ǣi.}*́qέr@ UiDBL Q!j$ ,S< z{ny̤9U<5<?]?_RuL)|0<gG;=w[Np"_NOQ?LSyx~Cװ\e:Ii;HxT@~34-$-h̑P F x;5"%8:CG U'WoL?P'] e'ui,Oj裖N{iNeaϧWL_ȩKV(a#l޸vm3d9R/:tRcf3uZ ]2 YV02D}b;ӷI܎,]!Yy4@!C@i5Tk#nV{^5o}b.^kƲmGY**vUNZ=!\ ҃-Y#?*M89ZD{RLiƞ|0ϖ褳Efp.fI5,y:wq2YP5qޙžvmRX*CQyVEz" vDoxDOȗ 4,߸daB;UfwdY 9a\^4ohv (n_^]Ӭ 2r[(1;h Hpks-qpĈ |+p\ۍ6ߎAΆP߇4-oEY ד\)qU8WW]4hjhN5[y_Þ|\B &ukcoCIP Vl{ݞCJ~DZk~̹ C0`WfXcV>T9MP=zү*ܿ *@BFwSҺRc7f\T+Th@o~Cq'pD:ö>TfIy[>I:^!s2eM>]ھ4{^NȯohTe&*50ԉg:y)MdD}$vtIXQn$hIs9PQ T4 U޴R@sC!}G8/_s?3b6lwa(9#j`&fK/>Hl&Q.?%„A_ $ \kdLgOWCp6?~\eB-̏ܧ.Lmw۽a?3>K`2P3V;*H@{tj_bYKޯAonr(w`AeQ)4Mo .ޚ.a~(jN{pM+[V[bg4+wl$3[.@r5xlUՙ`PË*Ȏnq ~S<9IiއuΦv涚7ZW&S<]{'}srܝ*{uC_bYb ̗(#=5SIc$v)'Vܤ%Imz>Ahm}.ٶ?~rkӞ^-o*a>p1,E%Mux 1`fZ)6:)c25ٓɭBrP \P:;!p2DxRq"W5.=8cv9e 9L0<^SIir 3(="یY᥍ V"U|Vۊߊ0lpE)CHbELJrMZk !Lwɴj:#VVT^\C*U6ds vD\k q)Fg;:DvBrW ;99>|jD f;Seң76vɤSД!HOhС9AFWԮ;fҗ 'Ε>rzXvCCf%@vM G0]Qger5 J'_WSeXB]AubE7Sc+[6 [הa*KS[=NKڴZ.L,2O\N4'D-Ҹx5) ͑ n+{) wuN{_TyA{|tcpO t,j#ٺن-P p&ŕj&Fq<ݍ)V#"e"r';_82E?Μiv0g%?: d+8?qyrWBPZs|TBfI:h?OᎬڋ9qU؈&)S2~^e1 oN-C-б+Q_ .?W8 D݄v(6P"gQc4A3F.ɎAnƉ99'b?3r%{ٛJ]bƵja&\QPkhzfڷ1lыHw4~r V|&xkN؝ٯ1uᘲ_+>d NmٱN=lIM`ƺ/dL;Kͥ \8rI|(wCF%=C]ʓ]_ݯeih8S1Eshz>Nշ299EK] [jAF]r[bKmîX*|BX>ndPȝkhB13:l{ږ"_Wī30H*w_|+{Kqr&Ŋ` Z!chX?WZH-`GSz$f/Ǧ+N/B8 {/ME|3h\2K0n䛀$ȺAw_"@]lx0 mzh뽽֧k]|/b[XHr~IeDeHWbw &''T1K3܉,ю,/8jB&AԋpSKuZbK% wlvR^xxhDk~/x=8V9S@98hkFECnD4Ta$2pAlNMYtHgG&+֤jG%Ƶap߳w6ԑ9wi[VCatKtA'\,E- հZ֋I[]-{|ۚKU;k_cST]+i3ipsikmI$T34I31"n#F_ /-o7`W]O7 gk 5P7@CLS/qިﺲB;7qGH07[L*sAU5;}?=ߡLj&/ 8L1vy2-щ==X@/ON|ن: DjT9{i|\V=U!E4uA &BsL+{6^SX|]ƟJdohO?~є{u_{0ٜ)7j<4145 =]2wU0czc׍Mɺ)Sz͇ /?ڛ=y2r7v&m2q^o M&rϴ86+^) .GMia V"#xVkfLTFޮB}s~B*L%^ :~nHRpz9{(ӯKCBRNX{oO Eڢt0%f#x/DtKeD7:3q# 9!]^u) =5PɄҰW;S>U`溠-i #iHYeCڿ(ho}poؿWKLT /`ez aLDѐNw}vXmtg5c3nl_Xo&7>9 g9?`}ln@nPh%%d7?{fv']w!vD)p(5 RN{FRؘ}aFjdԈ&Gꇺhu_l\)*=QX?&ѠuZs|4 4yYF_<2V?)ǼIu x8]~E{g R RfNZiGC;g- P*A.wg{m]ӽ] "Xח C)4ƷBߺvͯ6[W=lŸˢ5]ulY_&qi3r@;! ,j|b?6jh'`\5h;TTuw~p~w?dBϜM|! ׿8*&2QŇL(]4[žrK$ CNFUve|t3K_4_,Ȑ$Mu {az@V#fKXdReC/td?ظpvȼӣnP?c4L^==mϙU5m l\;Ս:խxtƋ{4C*.6}6e/A'8 M[[mkk_(Sι{\?wx߼xsV\'\F&dKDzpyrE#>"v|MG2Xw $&U(Gyuv#x0A_T % fHd,jc 9D2ZaЭ,U;x?Ӄӣ_uWPփX]\\̧qV܄b+[#ؾ>gjE+&|$iu`aF:<?h[%GxH~}hy}z ?h"!eN=Ni; 1%?2z:?ȵk!Z\m꟱oRc%ReA'=1)tW{`NxN,0. HR|}qL#ku8p0ʝ{uı^ކSzۢi~n%S;khY1)%#Ņһ_NF8<\mP }>w2)EӪݗQ7 HFpp0-[pXORn3  N/,Q -8t26DH!o֠׭Jo8ȭiR-¿φ+ qII' 㙭D[y!subVg&]-C 1dskkǥ#ҧIف SËiwuR?ϥ({fXw92)&ԃo^|{7`*#~ӿHvr=e{ @2TrNXfO!aG ?"f`TNᄡH&/&E(V޷6U#(zX=򿯷Q$WsrӜŁzذ d .l-O5e맋||L`$$$KZsR_].⿧Y3OXL(Уi"#u9:c'?.-QZ~ík뾞دR 9"}v<ߕ^σ\ 6Eo tˍO@M+4pCt"G5x~0{r'9S;(OELA%i`2]w5:`zCV0xOkUs㚺Ե`K-CS=(7ED>ib1ip੆?Ր>?+pz (epdfE@|D{v9BRéw/4 S~Tw}Owu?"uȀ`9 Ln&<$Qp@ዿnvu:L)lRZ ~MY_Oj[Zlqv)}6-G" T}/E x7Q+?^5t,]q!/Gç 7d w5m@%2W<2(yp[jzpo9fɅH ku> z(djY3l,@$xDHc_o?_7wi}jeoqGOs/W dRvUŪ$8> AV4 &,ל v)qkoc |sPo9(xu+#P&Z ^]'m=5ʏ\ |` Z([\q[?|}ok#Ź|? 傜D2ݗZRtʅ',ԛntxͲ:9|.%j76 dcxo"y~_bbe@5?z1И ~Bm\LBX,d|]a;d(!<bJ]_^]uER̷9WGYB\G`}--tcUG_Rl?ե7e.ۧo5E]M!= PDf,Yʯh!35:Z  u(Rac:Z9t\0]8[U%خO ._ 3qCo36CMMFPF5v#d.|h1h9N?8L8uZe'qG@BߩOOf5NP"+d,f8"b-Í ( tK($_uJ(^^.'ewcx*ѼIйrm _#̯vm{67Ýq=84m{ah7W0Yp=V})g׸ŻV;Ʈn[UE'Ȝ #`@9M[ĈǠotsR㕍q~KSSts};?D~;g8 ;!6n@33Y= R0s7?pN|gGn2K5Ob~8tMs(t:~ʘqJ!˥v>2=|8\cn8sKce&dr>. "pLp,Q!G&a)ϳ/?m{*~фfYj}e)r#Ml ޏ=®xy(H#󜏜g6X?-^Lrm46x)Wο5~_ʭŗK5no's0gS3,=GΎ>Q 3/t2Q0P9L ITI,F(aa{}< 6[̭rdƀORŠ}?ч]孠HhM97]  }%t!{.L/<P J QQ^.;t(}0䧰g9?ܸ|&⢃_*?\?g'ԇH :NQDOS Y?n_Tצ}(Y9]ٻDйT߳!ꛖj (Xmt ;X}SU5R{AOY9Ϲ@CPoH8ObĘ*=Qλ } 2C (=ꟷG~Gq Y:|A l+D,T-t/P{4qD '8}0Vb*A-de˨ǐ'cWy 'Sf@q'/8}>K_hBIJ@szxMa(;G"cZ* ?z_ _8_N??B׽K.@LCH35Lrh` qDkS^o*_E$#ezC ^nƧ¿N94=Y[qNAݾk3*י,$ 7'C`3Vz1ʎ^kko7ӊQzoG*eeh!sB!х\/7~bw^ͧ/RD 2o=d7i0|v]eȱW]?`j@i3:z@5WH ;myڡ)WNV|_jjm0f Šjؽ"5j9L6 Qdl@ӏVh}.mo9F/rցY8ghO׼e$E&Y*O§ oP@@IH[^:XJ DÞwR׍FO H.}\ zc#p3,^ILn<CY?z%Q9@.G ұ/rx+9zawV=,g=[⿾u'Gk$kl|3ߌ :BO :aeĐZ:B*&0q8YoX_!|23^TNJ`~b6vmz#O!`/L0Hس=qmWC3,|DǠCH>( &=vN= ۾iߜ ntiO7j;y9SRDZ6^@&=OMat_כ &mǫ~S{-;Gl֟ Gu=)XQGr?Kuh*/X>-2O2w.E-GpIP߈"J"l)Z' 9r>W#hFS:J@|(]o4E#OV|DA%GԔg-ՏKh2SOӄEd/r@_lrMHOl ^q> IűB bzt=c'WdKdEW'36 eBǦ' ok^>21acds?}ƿu ?1s6zw]`/ۦrM G3\@2>sh 8hM7ݟ}j3 SF&?,~^[*_^3);'}?;IXۅWu[=='[eWތ0iAyl:'%Mww 6ù4[ULݘTKf4v)%U=:6,6=_^ב٫;k/wL"E訛r|Y9?H+-=~Իd1m8֦~}v]ݥmש[v.~ ^H #:%˒Y GaaQJ/1BU$!#'9`ҫ"å|9] 9ܪid}JƏ~0Wu_@{Ū:֙.@C Z`,N!|@HgM;U Ixz*`;m!]|:mEJ4\RQj/T}Jݟ)x3!1b׈#R7\Ks: K q:bMg c pWØ/p~,.m{aqJf5S߀S+sM>G9*RL~zmNь2AGy)bJHyH`gvGAǛdlɖBoQۮc#l޳yYIjGSU)\V^C_h-U>m]Bo©+@>? "<iO /7,[C;O00xձi%m]RWt8!{-]/xI@dg(͢|"{RP͸ @$Nn;lTN@t1`M9оumǔ֞E/h:/?:eCϏ⿑BO g @@A_0w6D2 t|ҝ~Fr!>Rf8$B. e}Cui腹?-nvYƉ~v (R$Fa=(5ZQ1< la"u?\,ܧȹGs?1d#gԄϙC|?Gv;J#hVxO5L5c'qJi黶w=.ͩhN]w9\qI7wab>#1]$Φ {5G1IexԧKqII Y'}[S<Č,tK̑BΎ@C4Vgҗ:m"vӞOQO߈ȧݺ?i!#. "1yU'?@ʋ7ޙF=c%chBJ]:.񦯾U_Aޅ EXEt%}f` g,~S{av:|+M3~m[;9̌OV~RʰsWu7wI/?@07 ^(p G!~XScNpTWQC(wوwSpoU)d]kl%.a]_%wnWCb\ǎt !$YeZ4Spd*߄?6ql=<8iopjz0śI[22z}s_nk-?1ls(tw~1&اG2ѽ>@Ӄǧ]HB y1EJrPRn? @WTq=Ofp sZ3X;XOKc^#_n򪂾V{)%I`RיT,ؗb~RƿU7-EșMPjeH`g,KD^@ߪ ΆrH %C`8t侸t.Rոv@d#9gCw?0!o dC Gfr8Y+cE?oTgU/k;n1aLS޿gji$Bim)i~4̷ "V_ڶ[{2mkҁwEC~ p=I g|K} [be> ^/(G Pd,};Z#gêC>w F3BooBq&=n_ػOןP !L%)CaCZa%v?뵵?k.Ǧ->O50É'"tA')Igcf$ r)ߔ@PǢا>꿘c7˨ Ce)|)ſzI ~W!pOD-84 w/ p-?]eUaUV.3(8">9\ 3b'?*?OQ`vB^Dm̿V0M/=߳_7Xs!3A=T pD ˚ϼt 3x#w+!AϬ 8\k@鍩ʑ֕eci_ʰ;)Tr6# gf<qT'(dN9 TOCg*6TUr:֩ 1թ,Ͻ8_Nw߭ Hq/KG.*i?n77u`b7/w"$l 9['A&e,g kH}wԿ!.;BIl>Br $HӴ6IWva950@2 (Fjorss9M/ jkmBRh@Yԓ`tZtxqSyVoPut x`+41@% L)aX{ME^ؘ/knu;IϦPI&`BGdrp p`C]ƈw) O Q̎|*h5ޤ'Quuϲ{{:Uw;*!z? R=D;@#a2'Avix{7ݹEަF\)F.^ ab輵f~#`Z44}Vb\1$ߤrD Z(s͞\ D&+AjDߋgb=QW1Fmb4Fe>EL{l7vmg\wއ KOk?Ϲ$5 >+Wlɛ{D1\HyѤ׍CU5e(ӲCJM`ϝ,Ŝ8tp AIL#0OGpC,_KLFM1]6 nz:ma.eC;鳭xY9VC1*^C1UhY&'(P#?HtuS/B@Y45``@dG,ߴ Q2<ޜ@j\Hj#@1D"Bӥ1R5 {_.]6Ͽ m.?+קبr|'3=|>Z~ٓo=:gj)y^q!]6g,3DeUsx^,~1H)Aj Jɫ3t;?WUr'Son4) JE@m&|3*웶.d[}>G댽u$q?9_{ E4"yu?B?N3"攈?* />x;y19J #W[6y'BT EsNG~>'^ԜˮrKծX[mqm9Q50S?M+P<_˴G/f)(PPX|3]z(Gz7.^8R 8ŚQg+L-JN\'Vʣ:qz65$(^^!Tvߢ]r߂f&n^@]făJ =/)p|(tP)|JKlNMq:^tq y'ad}/x~/dLK(`L ?æbt)8Q{rfSңk|+}!2lnNmpm/o&~R`*tZ/c&B d5;SO H~#>aKT3W?UxIΌh̓yw/CvhRhoL S,U_yYM-'4o'3m$Fx C8xO7|@ϟ`8SuidxpHuިڜxo!`a?W[g(3.3ag~\[*KӟUM?  OC*Cfܦ_w5bbS^v?ߑbzJ5:PYi_~~tѧWk}S<)+zM:q}]_t]T|3l>GBų:t*%%"PFčmo eओ!%48{U%1d '; T;=I7y\ap{-p1KjuMQ֭^:WZ'`a''+u `0w^\\*P7k%r\v͟]/9O=,/ol,:G#hjϢlttōCӽ 4x. ;r׶ކ_Z:ۢ+SzѝY_ldoֵ!zgko4Glgb{'g{mxiF(^jP7a^yti_ݦ쪔V]_vn@"`_t+a"^ h؜yrn I0C^rwu,xS8" 1S'sSmjG6AYDPOn8 P (?/:3SơIGzY>= ̽h[dSHT L+ù\z { 3ا,B'9#KG; # l!]gTI@ߕB!-sK(=Ҡ]? Rweg`.& HOP٪0cf<^!p蚱60!T}{\x/ZY1t:y u\ΚN3Q/1iνwޢBJ":ӧ_Nq19`~]7ZZsJ3]_/+0gv+H mCx"Y9LAUOqSB$y"`3*= 맠sc[~oysfb1;HYDbPI}Uӛ=BTS9the~?\,;PR]trt1DQ2(hv~u'w EdaAq٫< ~8GM-F)AF~+ƶdT1mWߤފChS/K5Kc]mqD]d~iǸ~>+C79OWWt>*1WQ|O-ey4uty5F_`]Oh4r$7 Xvqu>_m>13@䄈W 2-=G.GZmufGSu!;HxiIξv%!v6ZNަL&Ny'Fl fP04LL$*vOH^'ޭ4Ii-ԋZGL PISwSݽ\$謑)Adx/.@`s+drӌ6 c`hh#FxzߚJ4a|;5ͱ8Yg_Q\ gx=³#p`cH h Lp٧iv4]qu 흝B\t}-$ܧq]U٦ܣ)]O/d A9C!ni ğOa1[ 3Gv}J5Q>gdv̟&b0"#3y[R#?0=)` JԱ'bL^z\׽l 96)OMW[8w)Zov={N$?A]0#Hh)qrJQ'H9&ۓL~w_ڴ)vnϗs!$6U, d+(5/V(ri3H?AWa(10y5~^xIcՉ Nm 4_cvH0MoQ_&SzqbjEƩ1K1)՘S_xƺ~n[M!,>.pq9)4TQk,Ks;r]q %ԧ[ 63){m|gugu?6 :>uF/r3y4@>8=]eOhPТ{!L:?3h09qfb}= ]#9ϋeszS]aly8Xwo ӛ1ߦ8ҿ,SM4ȍ7 5 C7@4M@bR:FREt[[c90`±s!E-@D~~ҭ`*mC-8l귡nۿ\;%~]$ҿ_o@'@3o"C6!(gN(ckԶ?@pӄ/Ž_D#t1ɩ`S2ޥ(̾oۻĿYxry&JH#ۇ4r=C1gAq5ݭbE<_|_(X}yچ M275M)}N6J+j<(hWiC n,L  H$H0dFl,u ȡ3Rw0[x uGWK`c*ޓ*RU5߫~ (ؿüL}DWNp7gf^S, I$X}}lt{yy9_ފ×C}9,yI]bȮ|%;$H6g )0s=q2d7(T>~|. Cs7$ l['_={eޱ[nGiFKbc>׆.DBO`?|ձf K8 I9MQ朙0H۽!{~H}A֎n]7 C^]޵}鲷+{?k4<>(uJ1R~c'N'WQPiip/em]R[|տ%{iK/9`|䂪%%F"R34!h|'>p }:)y1D;={wf~+@~ 4 >c B>AŒ!WXm\`NZyKCgptP~ %K~WӒi zo6غ6V<{_yB/_p@Xa mVE,q-wP; y ;&cҞ ZnC,=ѻԼށG5l%6 >|Ǜ ac}P^Ʈ2aZ\Xާ0&egJ?ZY+C`9ny5!loshx ic'{ ua.gmhs#jݲ<󞐴0 n@JLakCf}x4 ,]" Cey[МWLoc/M?rjHWF.w8|;UQ"EGԛfy2塆tύQwwGZX'xCLcΟ%|Tp:QhB5B?'Rsd+TLqz߷$p;Sҝg1EeJg;ly@xD _#(dJga/O{zGPl)<@[ߡҥgco'~*1A=с%1LӺ{"}i7me|4M;%f(tvޮ/< G ;1,^5)23 ӥ'0p% ic! @}tqWC,@RX]/Mc+8ZwGio6X1ܻ-W GuJ*A+gM/-@z`֧KjIҷ?R^U='_Y)L,@E!$*0:5~H÷B:V#{5ʢwǘ˿O_J˺"t_?E'UGr/pAfU>T`+ @maAp4!nn,v#D:}iwou:u:NnJ_;|EC^'^ץKRlS֗͗c^H/?HڇMRƮnA('RqQHd 9Э W VqsN AX`J˔]/6Yz[#׋*rUIۃVi[cT+!=f e:<[>,|T.+==?y/Uǘ@/(ArC' MrPyoJ}2DJOf% <(֩܃TΛs*k[YN4h}8>67j1?RH$1봉u6 d=v\|ŷ ܨ!ac(%~6Oipإ+7/Ҵ:!yEoYC?O ~| #Ƥ\lY5PDv?l`B:X\Dg@?DSKuq&|\ 4ە4/6]-fAk bĤnIi;b|d4KS}-Siu]7*V-CԜ7,8=%@#@PGGom}7'@S2u:?݅}:Mmu]-%u͊Tա4]ՑKr(쪢{Jܮ~FS,NsPn#G@~M϶)@GO*;Ӑ7{Loum[oC;WەϳOt 9*$Lga6"/CKXA?z y<Z C"{< npg[B] 0Y?>݁m֜G*P>BDP-WnƱO[1 {j|JF2ֶm{kwau M꺶{_1/yVA PhYֿ&jaŖ?4xӺ.-kڼtS0JᨇtBYP"eS3oIvx<t4:}k|NRTݬu(З=&oܮ?Tv7:$E} _t/Е8Eu&C/ӽ&wWwDSSfq6eVdvn}m2i^_x A.4ڒuY3>?)ϵ!_T`D G9ah3w1 L?^ tGG5G:UZ0!yٻ9 גUyU:!skSw?OwRhC[ZAM'*~y\PA9)<IW5j>przXB|R '){zhR菮K;J6KG :"sZ(Ѐf?WOF/MY0Wl}MG23 r4קTUWuؕu?/'`&#~sO3?>B7#aNp_zX/6p@=4,h4m޹IQRoQECq2${ mC2?SH xd4쳾9K (8 ~}@t=ߏucl׊2HۺT֕u:\^D7_ηs:&H7,:[a| _hiy~È!0tE##csp Őt$~O»Q/B4eaR:p&C CB.|Qs*_ʤ' TSruMEK]WݛoUCUԥ)]>ϗ۳ɼTbkcY/ XN<)*"BzsW-n]Pf/t)  {.=5?5'sl*Dp@Ei| } SL RqRn t2(Mץ xsjfO_yYA5DA2Z򝟜_?ifwWC7_.>w>y_Ȏ qÈC}*'8PFXD,HeQA> ?U)@'8@*?U1#MD IÔLw;`/_?n_-U 1< pDYe0clz"1=P_ 3H5ژTu ć#\,?u7  i48@$n@ PĀЏ'qaK,Oe ixmʒ*KCvEk{u9N=ַ)C鍸/1(gqoFξCJnnLvnL#r'*]뼫(:k^{e 0y}ògAEXc_Jװ7䀛;m1cD:O#g]/!4<׼hFNPqs̢CC$tBy~̐\G;eʂ?8~6uݶ!t97K~m!AT 7 M& # `,6cq$/\#xEYl{|Oܽ1eS]%gW|?͋ضnc 7\qH iOnsoC¦ȍӭv߹6|*Qn hf-:E!47+3W?H֏O}íC{҄=:=jtUyd_ۗӗpxNjbg{ 'җ(lP&1J@lb^f)fUy#/Y <==qЉx> ۭn&?nb6A#.A~`$`@j?PǠjTW)4u'}|7+=p?c:;Oi 7;sςGq+"q"A 7|%El64r/ƒw/z+¿=_8Aa"},7U?lAῥп{Rϯ5cJzMqh<ئ_-u'䥨T jp g~8at͝O(/߽5 ޖ?O9a1#WE8߳};xaM 6p@cr$N4iX:@;vQ}VݞƭU7o{;ߛ'( JVĄyaGR}#mL_,zmb+H :PJ{:x9LiYVPǼiRJe͋ $ HA#9s}?a2]@w,P?O uVa"W @XP?Sܓ༴| J#K"PCv <|}ֆWc/c3o&0zhbԧP;զRџ[>]Up>ٳ2\rpduׅAG#x|Th;!6Vuz~%.~N9Y^Sߧo]|"Y_u i]]d T&BCe8G*p'3ho^a鄠J0;~7mz{2YZȞeM>Kt oSl=]o`8?[yτ>DO}Ĝ&wnC[ul]m?OWX,V:OC|h+7)н]KʼUMvy{;_ϕ15J|oˢ-‡hsm1]:n/@@KW)n$C[|9eUѮxH`@ `> yIN_t۩ ;d{JRNw/y_WPtuT( P\"ѲdSBl?۞~x .`RwΟV7 ,32#e(?U4zj`;yJ`|~FKO:&v槇5/0p6?dN Ht52rMֿamI#,mݳD~8-&pN ~8`m-@9ʍ!h(X>(0 G~054/.0` ̅-3nf{1~;Ro-xLM}c˾7nŅ42}F'.]Lq~!L-k,]2(F *[44*r\)W3wb# KOx!F?8EI$1ѶmJSe:?F+7? d3&O@hlN( Loi`e=P׏v?bp{RRH(as϶F;n}t][pz4̥ډh 0_6]/(\>ÿR;cDq1f0?9A$_!#ſ0 ܥ1ܻ6_;ƃiFM?``S%@ /R,?3\ fOJyLƁZu釛)n4}zb]yKE#cP 9m "3X,x8`B<7UVT_S&,%}6SJO44 ]?ʶ?TD?c= t=PE"8$AY vJ YF$̛p}) ]oE,3^ވC|As~ = A!8f/˿Gb] =U{m6:e׹H%O9]^NVxoR438YuarH H-6ev>ϺLP' FwH WkW\?ʶ( )_+dM6AVgAsS"# 4f'Y&$#"M|(7x # P[Gd3hH9L M.|qwQ\x?E>hAZDyt#FT2ԗ1vl:{3윜` }uD00!,xPN\ )oE#H%#VG5aB/r~Կ"߂ cmĒ. EC\|o/؏NPF% >r6;)֑sJw`=_~@v] NH:& 2zKTя!p$*c8l3MIcj_Z[Y_&?|M)wB?^jQCc_3aDj3qotԿ \Ѧr?#.&4iʄMJ3Ɛ`VYImVխ#߻~OuHą *QfG!M)ɡo\um/deFmjcT'{|Z>ģTJ2q(DMEk#0e%F;۾G@}/2;[[v\rwO9_yo\%a׬TelT,jh}i(A1*| ۱vL0727/u@w?g (cA@NtNZnz?%4q@9&elzzGӛT\ަ;4ݥn7zk:WY֥ZM{¿zݣpW< "s_ @ѣepDo\':/>|8~X|>Z% ΞϞ꿥R,a7K+S$ (F=':|P8!6i_ dm:vYۦ'34">tZS:]~J݃gOTHPRT NBRI#n:Yɘ 1jIVΌg1pT]ܳuŚ:+8FF N E/UNg1ݶ|ݻ1oیE/PPAp?.7X_Zwa:"vg m0YkrEO |:g9#O~dYnx3ٗiJ*4. W"%:ć>##AQf:鲧 Hc9+ߞ,&3;0z9!`3MVmA{_nd d P5@x$Olr;$il:Y!OG]y0^ejW/[7)=K@ݒ2@iAiR(x;l5|zPsG& ׿=D;` Udm=mF3H.Ya`=#Paʗp8ɧQlzD5j3@)OC2qo+}YU_Op[Hʑ^]xEN _zx#Q*X0/)`K@l)crq~!/}:\9Q k ?i8ҤPaHlFECx44C)]*ujGlgw􏗍"VIUwswdpKz`J=?4Jq;j Ef,؛:i21uwz? .#MŎH<Av$9!; U2 Dp E??gky9`QJӓgɾփ]+Ί]\mDJqL 00ܐ0xklOƴ+ޤeЗΎ7coY"[6Ѝ]S&]~6%nhE(/󴸊 O\ S ' FI`;x` ) v?S,2DzQ,?,;'z?V5 >{n{Χ%֏.ή_Haq蹴3D   0kAܦ{:AJܦ Rj(ZjZ?m{j7Sa'A}I]0}E"r_,3m"[?`ϧ!տCH?Mp!s_ GIoORTLr-q㏩J;`a\LE]y#0\.c(('ӡpᦄ ʈ=isSXc@˵ܟT|u$I73J+\(J_x)UKM7 X쇗N7;QRvCo\ ּ]oioo-.ƚ?YyzZzV]zYx~r pEe:fX}A~j|2})+x2pc?2p/߳y JmpόY.L@yFHcBzz*-ALyD!E{ GMy3MŘb/D?i~5E{pie0!JA/FJzayEOw=y} y~^ƃL J_ҽIa"P-DD)X/ĦvhamN@XI;ہ?c?5]4 v::>/`Pf|LRkt/s>d82?_ '—T]UV+fT¡[1i܃}s )yI ^Oa7?cB nIfG [al5"߯Q_l>S8)/eo]g3ſ~?U L/D}0B f1$9[|} ~|y63q?W}4G\f?Xַ)䅉<)0=RbuxiSS/YY\VHޕPV+[G `|d@Au (^; oLUIZTL|o"a fdjKUpܧ/]|@m߱9tYWyQZo3?ȞS \h#Ho&\9@W?zD?<<)@1'E,1 ~_X9ӟuXEQJ!34NI A<‡dB2Oh/~1d=_wP_`SuЋ䯬IaxC#UW"FL."qPƉ'?OhY)'Nl.;y]8u*$ŧϢb`?ʇx!QTU3ڠ)DdR,=YkG Ċo7?( c1_18g+ b7O~[IXt9y B#cm``@?,*[H 3dM1B?ZT,F} ]CqG;_u*‹ۃp9=K&ЌτE NY_3ED`JA " ).kVZN~fIa˼p@P›E.`eE>n;QL`俑k?U9@8 E}1alLY.:%-)lDV}(YAz7 Mo5qGg1 H$١. p~0pYڐOO [ r-(srt¡Z)H]n2P oS;F6^g߶mI4L.e=';;vB*>3T*_a^YRY|3%_K/gHs{֜wj+-ͨЇҭ+UMYS?F д'WmaT ~tgᄅYQ1p9ɗGQ! GDI52G:6wWSfpHЋCp 1,aB {O^эӱ:jhn"?~/R`_d@zp) $A}C/&w=9Vʒϛ1-9}{{z59t6m!Ooe~+?˅x_R˸WCEKKin) >95>F37'ZgʽG'}RѦ =;U219h"lZ,sxѺ?f  O~!}m?-2 DIL#3D{o'?YЃJ(t  @v16u)ǻ|SlECD3`E}0!qڮllG\wO\uО?W7[A\}jBݻ'ʼ5GpiY)'WOX6mѥ5޺_d܆{YppA.+mP{0]vb38ۈܖ@$g\ge%Ik'<qt3|9?w_6/`-IѠ G8DKgJWC>2P5YL a[H~㐮J+Wۻ3{kχ̒<(*#؞^pjaD7<9R4"ƞ~/5xMѹ%CCdbGL} MTu#>.0 "J36YNmp:Mq_M]ovhYӷ=fjￊ+\0Kb.jrb')X PD{?GD.Gy(!ҏV Ks-;aN)tvW?Nps(w!lNZ^0B]H4Аc]Kb`I 3Mp {Ɖ0!ԬxgZfΤhO|O)EP6,_iC^:,"P7-3ESC`m}Y/y5_NgύGQxJ!Ay_ D?FlКRʶ'\{O/ w1{~ $f % g{%nX0=EN >K/$ b,qUwƷ0^ MvczJSMͫ)Tp ַnnVjvs_?l6Y n8grAyE]sS|i7ps' 4<]u>@RбgշPąo_rv^@U<;%2 neE-"2m]U_]L~4digz6I`>_/{_a*y֡ހAS[?YE/t{zp;/Ϟ"s䗁/fu b~^C&<- iAR:ȋ6|)ܱ8=^ 1y\ Nkg/~`e!@(\1f{qEX ʓT vet}ʋ-?;pnf,?.hPY3h3Q`rB\a8Ⱦ40=fWɧD/n4,z7tW笵p,$bv\w'd[GYt-R 4)鑲q:(?=< kd/~ ?~vƟ폳|o}^;}:g{[Q<݅NI-^}l}OD66L_le*{GczGfm*m+G^U]Q6ίHޛnOQ*Xޠ! P_ b 8*]y@(V;z .𦧂B fi3 ̎Y.4)&Gz},a9i~o;RƿtM1r:}!CgUv_R~VBā x f'%,@ ~` Q0{TCPwnI·>^=&AMKZYkB_9տ'w}4l=PmsHz@itѽȻoi 8D()Qj׵% 9;5vʔZ(~73(WQDpyFu֘)Me L!)uPKV]s͟ @OA<Lag}އM5KYkshʋ#O0KSgk/N=Ӝ:/9ֿ]6j4JGm7S7d濤cR4 o1XNqvCߙ {Dq鸏D()q}u@~ݩ;.EIӗKeR{y`BaGg4:Q=EC޿螩_el\p=Q4ߞ|BPЖ y1 5/xL_u}e-,>&$4 s 囅n8(91Itܝ/?%ǸH!D^(P(|t8 9Ng޹ hR)wC \aS={Kw&x?g=߀夹+F{D3 hTK Bxuo& /CaIGx0&0%ws/0yn!9|34Jq^:n }o{eަ0w10mO~EIn{cE`jXʚ(g܉3>N>~ Y?S'6{:́SA{RSOu]Xt҄2;TxPwj|tD_Q' 'Y_8!>}gҿ,~hDC/ԉѤT!lMrBeHֿ<}NxCcLb+ecLEc)IPl?) &ľ, ')U'V3|oX}9iD?ѿr: ZuU54d$7ٜM՛f_KbH=)C=[ۍ~?ޏ:qW6誃N@nAgQu7kfNY M{N}Gwc)-$K=pwdzgEfu燼NM~y(xط~qIfBVXB) >{xF$'n2T=@oQ _nU~6w=.g=@t-GXwwMoFCʽfLKPlTSYoVwl)}|PY)5?~VFXo5& v'8P[yCO$}K'f~oщWP~AȞ!pkc2`5{gڷWkhfz%qn\Vm?PZv:]"!a-rn`v*N^`3 ZQhbTP !:] 88[y2x*r5{`==?:aq7;>ˢ/l X^z)j+!KCIx Y96˛~!KAN-hߑ& ̕`rA#+F?8j]6)"ښFB¿_}8ÔG8`{B;FQl@f)U(ROOC`%7臥O~i Cd> t|3+-ĭ l5<{$^8KiQ?h۟D=˟_\aGk׻ZoP4wC@~]}"}$YLf{?YpY_ BNـh,T7xc]|1Md)|*~^B:'f''S8rqGӇ?'dgXOu?L;I&)#%+aSw6+^. _[9Nᓧ "/%/yS<٬m;8Ip?{1ccզz2͑i 0]td} %7CPQMg.ȤJИyG8>U%!pw@> W`ɑ ?G"><3HsTNkj?&b)~G Qrű]O]Y_`m;͊5DH~A㯂Ƽ3qe>’ǚ D&fe8st]?߳(:G] %YABX8D ̵eg=YoΌh/_҄.~>zNHa" w@ztAz8Q> M-_1l'{O %ML0`81 [G,{pCmK^~碰+MR). #p;`b7"O)zҿĨ`C]c'<䜟.G^ɇ7C[^/(pŜ30+$:$&Kxg&<}QJCn{kM}uYYs k+~#:pإ+.*Cd@3n;l`a N:xh+f!B'kc˺h,/iqSR?nIfz2)%J*sˆݐYl^oH܇0mS0xpcLQ=;WK, .8`ʿ*7T!Nv?Gƀi^#L "h/.TY*!N/ P %B)`/<5-zJ׀n^Lu%˨wC[?NM ®utv*, z+ M ע6=v#A~tMOObݍdQArɬ[u`;ܰr߳;߲_&ؼ\9uG,O? j Io^~|)0.h P s{*נ݌ݳ9g ?W۵.m}VsEQ}o$o| @R=|q.3 QGq cCP+COÁ&^?86( |L?wio?MA\[c@Ubߤ5u߱svŭ'0R!bwtb a\T5iy|ưŔJŁOpJ SyxaqY:N)˙_ׯLr/Hu ǠOEB@5[pA#zzC'#P; IO;N5?)w( t^n 4Ѕ.J񿩾gvk+'|WRhISOnBa= + @irI3NKdJGTњۛoLʈ[ij6C؍3y%9@JW_T>()ёxd}As:[@ OO[gK#x֪߿&{@# Ib@X4ČwGw]m u7\۾nGE)Nq%'Rd>P>>'v^P  \?P# a>+Gw]hj;!+b?('L"$aBVPt5{Uʾ·˯6Z۟'q{ ]{9TH, gVS aOMu}u)t4)i_-a:$j9oh}ϋ2댹^/Ɣ]w- o#诽(` N)@x$GFY>滵uidǎ&fyTRAQ=T;^V\aJ05zڲ=I+yH*_%Gg)0$QQI~u/L/]yw\M(C8 @/U xPK "k?=Ep˾\hpk3?4%&Q(}1K:~? U+1:Q^ CNȺ_@;\Λ]Kc0axv@%t0 rS4"=#]oY@k\mھ>~q,'/;3: M@:ƾ:{YWS8i?:? 93hܤz?^WKy ]ʡS,t_  -ډ@D*aJU:-e hJwpkYxp䢰g+ڞ\?zuF4s>8-IO`փ|p!`p+@ ?M!Վ> n0ƛiK l#krdC5}[⼓FU;u?+ w a. nd5·S;toJqY_~fd#C;@e>$^WS,G_w䅮mT{((hg3&l~W2Am01ڿyzn(1g?@PՁ0 -l_4 HFx 2us  S!lh3ycq1NzB#;; )(@rCiSA)ytQCA S6.dAL;tq * #jzil?b\@=ۚe0`ȣH1(]1Ic;jKiPzGO%/[3:#9hÞBKڟ+E}|?oE5 ie 4h^ag^.qwGN}FNs9 G E ^[dWL?#~Cח.& !-Lzrv?3RĵgWBG .ri\߸+UƔ LvKٱ9X_]sMɞ})HeC*"˭&d!xuL O`?hxY j\P#M yX?b <A<`R7߁7I?xm Z>IhQki.vNNl_ߥnlh0NDs!p `Ac@ѲC*&2EkƉ3 f2TY =2dnboԻ$(OnbՉbu,&6WGnX%AHDr"h#QĈ5!/)oy7єZw*$-ފo0"ʉ'am &NPJ_ G9Gve.#yy֮;7RCoXLrH[Ń{ε EPU"4x5 BΫürC<2x$ 2Tېddg}u?ſ|7vտuƀ_pqES{Z?#?oTŴL3)qByE1qi;{zj۔M zrw K_0 m6H]O1h+%0~7? v|5o&% 7ޯ{R+E$a JT 9>QlBLf;K.oƩoZ2C:qsWzN?v}aeFyW.6/a!H㮗rA o Hqt}L!qz 2ܝh]CG&?[eu~NIh?l77 RF_ɍ$tEx*r i}IN ɺ(uNIan8PB/`a w"́^'tS)m̝\f 04oͷ ËyI;fKkn>>rV!Ct⏤&YrEkbQ*@h%?T(t0M @)m2 J'fyGIv WD?o.9`7 NLZ0 9t*ZൕV?̞sIɽqfJ #1ػ| Ƨ 9saҢ~{pPѶGY,z`Nطt8pLM1ӟ5M`-# ,g]:Vl>,PͯP%];:N n"pZ @:$NTt J/|OeozQ ,bR,ħI%3T,MioKr*ݡ??XE[deж.Y D)8F%Uzab'ߖ譟RJGss(Lu>gh}ޑ6:?C BzX~\ lFKܱ#lx'0E*-EC&~''C׿?`t1(C\BWySppcZ ){ Yi_:W_y~{Nn;A[@vBj*A )E avtwW$4jHcgnn`gHΡb2C/ee@ +B-XD{Àt|Q'W5Վ ]-`7VQ^~_^?[soӷ_} |?%c]hG# _FN8`¢9w=A!/z> Zu;j"mϊC_POTiK9N2h {66C{,=:?D~!{XT;'~y%{KPqTdAސC TAЧo޽'Ś7fz* I;Հ.0I,ttC߮8 R?s؋Бݔ\{{_]Y5:2.~r^&!pk@¾4 6w'Q;Z:c_!P R*Q@3E?1뿈4q @%4V;ߨw5 N:RG^nZbo|o@!p5zs\*A={[{{:_uݥ$hp_\lE[D!_~O▫/]}Q}g9Qy NPd. J#hRUY pyy7`ELAbWB96ŭb>?448"z`kp;b7)ܚѹ&]w#+mr[r}Q uCm"y¢#OOK&-1o(L^@3i0J:HB9$ ϼl4s|S*g-A$}@JdJD@σDmtԻo䫼gGq?KNDs̈ޥP\DU vG08 ʀp 8[Gëo8)H8S.=bb0#BbnƩ.~;W ŌhG3@ rCr# -DElag^ӱ-Yf$,ڼ6UQEzM]4sWc[ߦއTY /?_uk[J?Kw% y.DzLI3B}J7Cf7/H'#uJ֥-.עh>(sÿͽ5?%=|P p_ (-C8cX^J!<".0Վ*!i{Z\'~RGOa GaC( eDtEAK_G1T`s\\AR1J* #'X LX hHvan2&cV:OZ_wO跲IK//r%f?9x;T?-äb7`ҫF8)qe" [> =V<8t ^'oŃE%T54{`{S>6 ڀw-&Hpܐik#f(!W~;?/Nu6#q?8N2 {RDQ|a>ֿj򩝞gx~0OZ@Pi"xin"VR;mZI>[?:\@%ָ;Wn]V46wg+A2ྱb忓 O@Psf8]n@\' .ٶYv0vqgE)Hz!#7t/иtХ}3MyڷuJyPʩM>ٞ?9^Pq%}oO:}َU o, 35U愲Ɏ\ko OW1B(B4q1Jҳ>,D5ȣv^t: ݛ #tɆ_M"W,V R߻cl Bo[ i?v99.t t8pΑ&pSmIhL#V3uqBcc_9OR?9 )TkR;[]ʡ;R76M,}N,oRl/+v6ɍ)xLÿNjkƿu UybsG~j oϛLgSlUUaIݢY(A@D'"(ftAv:x׾?Wv@Ҹ_(R*xϻCNF:@1*/] e/vޱ@*O1%DvJuCgC*ZM];<>2>>)nC b|PX],zz4 L@>c-E%@S ?=ֿj P+z$ڑ6WLE,YMOωώj{D`R0XMy' IW![⿿= Md W$G%Z # 6?_N)@[_i#ܬo&'$5כ0% k)QW\ֿÿ;`E)¥E‘2 g"Io$%6~(5%h8]F!W1TfuB a=1 =XpC?t A/8HA F(`κXU!7#adm iX0tC i#Cᶕy `L-rR'$(DS~v#CˏFU)D/'%B&+%??Q+D%PrۥV)La0ФN&1zZxk}p.A HG@)m%~QkE= rtA W(Y/OK`|#Ͽ/@uRͣ_(]=r"R,Eӓ9g@!uf~?ߗX. (7i15*gBP%߇h>Is]J&s@H`ƤX8onhƑ چ]kRؿ˽n!C"`p7d4&kFȎ?_ՇE mj%t[(7 $#Oiev=~I$ {2׸Z'Ƨ߄;#лg j% aDy4> kPIfie -u'If<#p^3y40LW ~{,& eQ{ Fܠ‚CK!.2!}CFzyiK޽!f:w?o&/ԝK¿;^ŕXT ' #Q?ølΈ"}_h80H@G*@ieԿO;Ât<@ | jka1UW1'+KyP> ~Tt]X7o+!bf?'_\;09\h$kRS*O:>s%|N=,@F:̫饰A`ϗ˥xX֋H@c" $NK G V;1|eyBc9)n0<5,}S"~q \n  h6wy@__[U3o_e 0W9@aYuƒnL?r>b4(Π/EuВsT׺B-EH:4QOA\!+(۠ 'NQC|H)\9QJlJŐGSUU,NheCL,tC]:޷]]$Ry߁g?Z\,(rT(Cݝ*)᡿N>ރƔj##yY`|b'(9dU IͮiXwweW򹜴4ݗ['LP`E H@WW ,ǽVOǑ,G۷A]Vҿ HGvWo3ġR?VB uQ2FķO!c(ʷ0oF Q,$ 'E<8P(q8}|^aG t @Fy܉lw:ϑ?NA[$8!< &C ꆃ)mzޭ7K(yƹ3.Vm6Bo}dqz{r-_V2tʝ8AmXqaEHoݟ#g's7atchCӵWC!mKncjK_mIH#;*^v!wG&K*,@AteKYY}PEvSΒ]WhfzĻ9?#@2) k'mt,?hn8o߸˹E|7ͭQI u"4׽1†C5/ֿ ^OAEJa>ju6Tؘ "l;"BD^15~N ^*v\֚ӌWu:m^gfG~nEM$xʆUþw[\lr0FGk?@Zn_kĎ?C+!4ӿ/&Q`(-?A"g  N=W%w|9Y G@V+#;?Æ Io@ pnC/A$,fਛZMl}lLJco%rjມmkG{˿:oka0at}GM ¿ы7*YpQ?a2m8Cz]v[PG` GQ@P~ ")t^?ڙ׋krt) jR@fTΎ/w{O?JW)ɿjYr{H b'h0E'P"yӈ ue/@zZ(zd0Ƴ!Ʒg-s6TS[ gK!?0HGjN"(4{D!=A;7F_4Ѧd @¼~Gdg)FRT &j ϓ!} |@U\xA 0+2|_ 8&NDhL3\ vl&sc,|ZҗG?A m{,}qQGCQo81Ch`7Ŋ3{B~gCf >R,XRh 8יwU#L|VsSr_Q>~:|Ha`q_?IӏY Fm=O]lUv8Yi~ b%4ECqNYsQ@'0C@N OOY|LW|A_ƘA2])#:");'O;w4j7Mf}G|fA1Kn'Sg e~4oEtCAvUn Hɉ姓nAE gNYS0 1U9iփ38Q~%YROr!>e@4WW(Nk&,"P1\V#wwM=iy|/}HYsFDۥ!."֏)ӏ!R!dm˲ X?8Լ_l Q/DƥS)z?rW곒CoAMWQ=yIO(ʹ&.&0ϕ+R +T.\Pa{ !$H0HT\.G=߸2kBz)~oMul{St:cy~yHzKE8p~%d,A/Cfm,?qf Ρw{X]_EA|u>)U\4A{vC+"9^ȣ?&47$)!LeYOEN3⟬6 b-5>ȁ#]7(w? r9I1?ΥT A%E`0~?'(( &" rbЊǃEV)㻘"Q OCB!~7r0"&rOPܗo1U*ۡz<kB@ F4=kGawߏ:oNի+xGiyߜb}pZ@"?˻`yGb!5v.݇dEhX<ság_QQg偢E&]4dj@=^-~fMEIahT| |yySdڬ^s !ſsPok(>q#r;}fSꈇu[O>6~J"vʑ`,[)G:)?Ns\|kn1|Uv{H\J:MN?_5^Z}vu*C9w'Fӂ[#HO?CX w8Fb̳L.p2tڝ6p5{rB=$P&(oYv}пm_$!0+vÙG2$<]}ߌr{Կ)G.ʋegU}}3L<G,z6s,ǚ# "Sr S 0PXEPWPHxNX 3*A|Ok*Սd澥oUƓ^hͼU#|wˇPl i 0B@~E?OTDGC!aGôēhoԷGknǔݪS$K Aߓ[< 6{gm07r+j`Oe}H|+ԥzEapi?o4_TБw"k ^idaWw#Zhi,H& O@Bb'8:N/M WP^^_7!Of[Ec@~3cAN/?ېbǵN%wk1vg]G jC*аLL&1P2Dq ]`}Fɵ<坝abnYV$z3U:.˥?*R6?K77hw4}zVZ_N51%;d)c?WO_,[Tn j=!!͒9 oL {Z@Pߡb'o3jW'#~Hpu,K00 P'4.~ JecY+npPDo|8R<;qv>AN͠OS]~Om}OZz6K`-'h)$N8nhjB7ҟ-*ۢCMpG2ߊ]PX Br_1OLx@1)OiYX_k3@hЫpߎ鿡'U ^JBq8B  (x2X(h/ .އun0L4!D!v!v]9qQ@4*, pB%DfO"-a~,/zf̳D!$T Lq?v= 6`Kp.@D\=F퐐?v?X/66 1 oC##@"nQq~y'qciEi&:)Ο+_v-/O/r $֌MS?#Q/81o]:擷)ϊ_hjN%i^BOT1r[`7t?iRؑz6#)$wVs'qBqAfEH`2QOc6m]ƩWMwSY/* c覫޾B=گ,$Qjj$=)IZ̨E4|0z<>Bdy]a S\`I֍<,tryp ]m6Dʋw:{~`z"^au7\`o TNMnYqmH`HIDFBIFp_~tbƎ+g"h ug/%!'X GPyCWIϰ[S@r @R c z[}y1o^|x:|nͿK?*e$>ޭ~Dk[$t{24"?QlH-mIo迄 `bX|YG{c9=lh&m3 !o P?BnG5ȝ@5bAflD*&W:PG[gL8|';ÿ>wG&8y0'[hm(Sy=9ޏbt$?$;>}g8J|Sry|/?2??_S`}"vI7] [EˋKd ?tNѠJgPXӔΥ׺U6:wi4?@, CV#_nU><–(t5aXNM.N;_^{kڌ6ۭOq6Yd2yJTı QJ B?a'v@ R6l6(r.tj41G߭dQa9! Kou!J03 D¿6s!n `VO9t?r@os wPU)oIy ϔٌqg{3^mm.Ԯ; Kј_AĿ_y䬀W:wH-$˱7L{n tAt=g?ؔ)}SzZxᲺ휱M2z(y FGNwQI_,`B Cvt3{&􄌟%H|cm*uSCG*5A7?n޴axe-0.3.1/tests/data/gbs_R2.fastq.gz000066400000000000000000002520571263567001600171610ustar00rootroot00000000000000Sgbs_R2.fastqے~"H q+<ňK\UY HJh,g],;?梁^cY7g)plesT_͡ߒK!,s~"aI>-RJe ߱?|wq-GoK}φ0i7Z@:n.Sg&mS`mHggiFiթmlqc_eirW/_xfiz%ZR<)4VNSM)_h#fp=X/y/ϥ-ϼIΛO:yF.ȖkE -N /5тۍG|!苉's4#ovgv@˯/yrx5ygk~.3 ~DL+S*?'3|]c'^i/O;Я An|E7<{YgC9s0qJyctg'#۝E,k\*8y.r5 9"N~FJ1./~<>O]8OkԑQ;a)L|X4d9v.ukJkPe[ x炗t_~·<R1>[t+y: ?Dg'~v07G=hOvjcf Av6V/r|N-[$X -I=#tA+%q9z7KOd[Izs&KQ~(0D^4ܱ㕖,'9|  >za%<=Z~z4 Ŕf}ilɶf0ݾ>WO?kŻ|e, llzptY,%b6 _ ~m'FOm66?71/^/Ʈ۱%9yd^?\>A f[/-'7ΫLw?wǢo±ghy1vqϻ/=ɢz#RkLl&~^^!ޓj"}DZ to,Ugg,/71?Uv8n 8싄l co|=s>_4C!dq#m8EOw:􂧄^Q" ?4%5᧝wdgAL򇦫CwgL~rۊ5Ɠ)63n^j??ޚ `b|}Mdi3'Hdɻ;q]@$ 1(r<(f3MԔw&Z@hKSk#gfǷo-$(hmӒ7'婞`sW],$< {,jׄw*\~x=v%̞~y>ƷЃj8x7rr"Xս~\}C$0bVdx}Ă99 H` AމWno_| $zwwEA"5 lFj!{6<^o];Mg{ ]n9Yz +@' { ꫏ /8>1Rftbi4TȾQn@> I_Oэ~ۅ1>2{0+y O%WOni;: ;w$?6pnxqX<]=b^8 9PhAʽ`}/+N:z͘$ Pv210q$N8;?8>JXt4/'.^ZI2 pl&ҡq R6[_)#I_а;.c BNBl:wGFzbS@ZYD>A`8,y-0Pq )~s X4c h /0|\snw*()wP?&;M8s0#Zk|V&:7;"(== ܟ_/ z]ر%mHժ M(`aUHqSPZ4<'.?WZ6n#[7̞7;=1Lv:|w#A]B;l .&=7ԐGS?HY%G,ïŘۦJ;fG+ݯ'ߗ9@ 8%ϑ=ŧsq+K! {?z;%G#е AGseî?4?|c8+Fwn{,9n%[4aa?IÑ/oB2cOK߅5>懱ѿӯǯ'J 'yUok9 d?/Y`;AQd(;>v\|^J0T~cDOI"9p-3n0[Kգ!D zӉ-e v 4ջֳ;_|> #~.%9![S+r.<==Wc w-&r0(6@axFv·gεȪ E?s ބVDGy^`0Ny ԇ+z/@{{rWP,!Hd '@|gQ.ci-A:mf Zgkas)']k}!$y:-_s&GqTSjGؓxhO2eEdI=ӇPʃwZ 1쉒C'.=ƙב' E߽S #g˗oClr)UmQȽC ?. oҐ/p;r^o>q!ߢo,1,;@>cߗ9(娯P?‘yÐȝy0Q35bfCLgalFǸ}rp\KMkb|$sK6Duz?T}ˁlkkP7 vf8SS1}|s҇{;;TplʜRZl~ӊeq! Kj~7Jc$u|JC!c`Cam1{qH|BKhB'rvРT 4BHo`>z ll X_sx)](\f̉%{?{v, bk }!G/GF7JAlu&P04QK$-M,IW`z;8+^M+KsT$ BF_ޥ_x$I;g0n 5)/N#}G&Ix@S`! AY|rղ%à{e"Sjh[b| P$ N+x.pdžN8Ǝ>#wC˥#]s߹\Ķ5)V@KyMsӊg-+ P}ly+f'NrCn=3O Q,!۽QnKamZ㯀󑡂=w_ž 0!F;_nYIx_N'].w/x\e΅\`?Mƾ3%6΁r |5C'a_nLS8˭8uj#'H.灰'+ '?M_Y,_.q+yQ#zAsҊB QRۂ]3Pg\x- l#_HaO?]uZ%u,ו6)ŭ6/x:s3 \ 񟲏&ŧbҼ wunX_^VJoRf7|⑔R{ȅo{J@Z .#J.x{lHtf8SqOKZ/[nVRPcQߟFDm|!|Fdy ˿eROAٮHM}'7 s1皟q-{K@C9Y3+z~a88 J@-9`N 'waj7`} Nȭ|żwW O1oQ{j ?cb)ZZB滨c/R 7=YiLW<>1Ňv>-vX<} m\ࢸpWԔ70MN$buTyC$/K.i^|r3rk+}wi$iP"NPۤ{G<08kNJBlfV2eT0Ku< _Yk7ivN /:#>SzL=(du,_;{-ѡ;.E$cC'x$ǐ!i{3jſ?{/i̟&.=v V?vGw*e[dU \2@]H! ~9Y#bcRB !^T~220m2Q?.3#?1(6uɠ5I EdVRQ)s~⟎,b@cr3E4% =ql4N?pd|JcwZ ;tk?g(bbk:\$iK=~zy*ry5j\Z}={S빶íAyy wJXx :\',2pZ4.f? "Bײ)d.u vVEܗk~}` ?06YxY>)RxeЙU_%ZpwᚶMs=;ڤhcOG:MK~*T{c{Kw_d|+'NЁ/~a^SiwnCl)?ڧ.r.֒T zQ賓p=nx,T{&y ? eh+<̆r)m?Y zܤ7nnfSGV4)s+ZKF(?8X|NiG4s4.~<k|lMt(Kb.lccBg}'۵\ux?tƻQ&>ًo Ϛ (/AF!ޤ6JA:2qgH>ocA$Io#Ӵ )5{ߢߛ73K2}q0CK&w}Q/0؎IX0Yj>ϻ`c ǖE]g;L괧)[=xWg_m"ąr`GA{F<^x~pb`T帞П q=v-*w_h]0~*_7\ tg%\w g֝]srֻɐ'tWfGa|Cfgma N|^˥м+)3Fz|x#0--jAẇpѲ4 Θ~BK﵇6lNLyCڐ!.ojRx4m:_,;4&S<\_;F{ fM@{N\ p90Z%ro ֨ pRc391&B5a\߶mm=peⷶm:fU{Z{7-ZuJ K.}cYOQ/)?>ǁcT+yAij~!Y9Ml hS:Yx65   + n-#[Rf mopw /(qǻ}鏞~8cgbY8k<2ʲ*~)㮎] [ʲswWfu6+E-gA +g8%-8|B] ąrUsAEGj=md:8/N yӑƥ `= ΃ErAku7= ̲! 6)2s{Y2FmϢ=\֔0Ab :񿟎$|m`bk{6msWs5mvr`ro R_W]sR!;( EXe/@@t?+Nm9q3}k\8s?kUv]ݸ6ܢ LJ Lm E8 B!jqUrK*ɤgY5$f ˠK ԡnߊVʍZR>X78vr Ƭ^w4,S\_MY)=KH/:H,ۯ?9PPwy)rہИ/"V=fC4|KiĺԈX>벆=YZς,k<%󓗛d%zѼG7{c7SHo/Μb0,e0ou{~MIA%x4]`Z֢ NjOB&H^M=YIq[t+D6}~FAruٰg {-E/T.EY?P\mjLe ksh$_< ein8֟n4}SKo,-60a#o[ NE0{U%sa#S|SW՚,xjSVhSOk8SJj%Zf:~tZGݤ5G?5&L$wqiwM㺓aW펐 >ʫu.GM[ s@Mm(": Tt?B{{~vGʝnݔڜ`ޙ%.;rOXJ-t}_ӵ[3 6 דy{;7p;}SރrwiK:<і`Ͷb \ +^c_ DWqt3u Nո/m[E2RSpT>Hs*}OҞEw_[#]%yHvLlCވYK?8hSS =:~WuKX`}ՆfJZNk% D?e-Y)}/?tp>&׮h/xpf 9ܴ;39Kr_41L#?B %3Of}|g-Ψ""UtJ9k5 yCnҗVe֕15ڼ=º(|7KkG>_F RfslvVςO/˿;bGF@>i@#g z?x G{?@B%q.n7a,'GX'>ׄwy߹ 48FgsmkG,]dIyf`9p/fpPՎNLf4qOV k+i! wr|ɨjMjHtY;ydokes "_Y~^*O+YI\Acn֙gXM=X vlyx5-s<8^d*b٥cTA#|9lOȾ"5ַlQz!3&RgTޠ75eUR(j teW<1q=V%ܡ,9O2JȎG7lž)ލQ:W]4Y~i՗Z?ݝ m7`vlk|U/JxQj߾d/'c-s,C8f+JsM|1oΆ3SJOj?߻ꌱ?ccۃz6uO*hw0νv5SC_XBExt|84\: c+{Q e]͂,Gu˝эï=,Xd?aΙ`+Dh4mA֫L*Mt;De(qhJ9gU.МwBl* Ͼ*e}`QD6R{ȍJ&yks{.t4sb+m'C?؍* <"j[Sް,%}mXm޴Ė`}A˔v5S *5P_,^AD7R5}tm!חCsnv2#~WR8Z vokrʄ25IlCDf3.+u;iU5ptܷMv|Q׵?s7߫u#EB㕑,З&w/؁{7er071tXd˸+CwM 5zk\g;Vۓp,j,SYa86~P Kfu]ĔUyDN.9ջ^\@#ۿܳ֎lNItaOÎ2yJ&u4ÁWFvj!4wwI|]\`rZƎAqb4a*N\sBA'23= u%_%]QvBe]TA$A_)eTDnb} қzdٸOq)}5D1|JIot-+xmKlM[0s(+Mp;<+;OXM+))f & 9o-SkcеS,RVém[{|}Hl v:cŠVr0ٴʏ@?N%8?R߯bمtGCK0RwOql|(]MVq)ScF0nǤVܱ5츽UgS'Zw-lS;B+paf2p 6 =]?F.<JusuՖ5Ӟx?t|Lj}Pnqz]jJKX9KAs`&"VPpwض"^cMgܾxh#!(Gɲz/I53+wpsunlZJJ}-JQ& IqrL[~-Y eYʟ\/mL@%e)G}lM֘4tv3폲Y=}|\7U5~1Y7O^P0 m&-+q6GVfǖuz(3 Sgq]q2~>ϡ 3X _l{7APmF)|ް*b@ -A81a| }/-\멻z"=qRV62{F];7uYh` w78￾&~阞Ƨbv,c2Je.E$v#PbzuSĶjqRKkwrS ~ a"µko^ƺ%!Sg(ɡu3My&?at R/֨MY.x$HҔ@ Ig oX~n,pc-Eў47 '~Qc?_`lx[R@uP~Nuш@=A/r>Þ_%5-нmzC7 U(|AE'g ɠ}|Po3dO)q^)pXіpE q1Ê{.B !7gRpAcHe.%ni!0;Lc93+V }{ުFI:W5 Z˖Nr돖vR& Wy<5<уeߔp ,U;Gts"\%9v)kq&e ]QY)ZzYjOcz3f"$ZM 4Z)aO MKKO_h#8dq%kB>"苕|bti1[O3P3Jz\13_ )rSk6 ofg([JupY~,c/K.wxʃc3⳸u1IazT.x$<Іq HA]yL ~WO=A4zz(V'K.Ӂ;,hfĶ/1gOzG,;9#Ǚ/eLiilQ4"d [pQlkJe|Kxtyjf5z|䞾|Q{qx^g o?_g~et )}M !*Zg-ON֧/J{\7͖G~rv<:F1"6ƓbHcמ,SjP t;{g.W:7̸cf fMH FojOd+[bۺ /ZI[2q㫪ق?;M~&,{SǒMt#]' ^G )7$*ǞW"\av|Ԛ} S|z2ԗΰp(mfݳDu}?k1ܥ!O6>TPNDȜ/Pv>0U~H@o3iK S äyKxSdۡo.pmF0u4`qS6ĶMrQyA ɓVۆ"D2s[eJHPpOyDňB| G*3_bΤiHaPIq )j'g=/JĔ> NڙWv`g%egf?1S%µ;`bwts\xAz[ -KVFZZS>&*e@nIb_1 ټA:˾o1|j. 7 i"S휡:?.WuZ^8L.4sYr{ <%ʭ R?hyBd(?67{;8q+P$/Cd}U1,E5rQKXqRv6TΓ=BTtwz4>!{iK%=7g 8}Y.)8 _r9H1?_r}߸HI_l5uyo~1n(ѦW-,r --jAi&BG;nR)0H;?{?q/bM1τٵ13aEfʒ~ :h sS]Wv-fW] ]:qǖ.|C&,2>6OM} ƆPa/Ӂ3k9m-l\iezƢO c pFgS9պ @-s" {,rZG>BGOã$`GWfuח6g@E=ׁ罋)hS7o9XZg7ӇA e/9|49H†-ܿ_U/nyvD=jSҲPB;#镔rx܏q΀rԴ-ښTyvu菀׋ <1B5R.?[Kkz? 9ڛ0}WNx/"ڞMLAD x#3PEE7ˏ,Rx9<͎EY"r^'0J< YvC]gyNmGt@ {НTixV<}5HM2_:%.쎑21wwHOO |42 mʓ<JFZqmbtgnM:"e!힌ݑo6ES61+m *x.I} +P&7[vx cf{p9"0]J1'_7AFhԻ(q >e,&/@P(e轟>O9a>ۢpgy:sc>1_<5?].=vtS}!ѽ,ڀEI)nK`s碔u%w'<*.)'?H0o;m1b8֡I8B79٥0U=Ri/;Vݵ}6 oҮܠ2UTwj ?K֘UBS*Z/!C,R̠p!*07C%,qp 3cH23.Kݨճ_GN+?="NJvB C=TXr~Qn>e f3 AP[4YLYF݆{/KK ,ܝQP&? c͍M5eO(2i/7=h@x}hjB<=aſQZ3߯&.j#e,H"%ncjX#Zms˶ D0gfx7:cİ]5~J$od$W~SX2KV̵m4]mf' !Kf/K3aroJG_m)9LC+4VoGa~9]T}qKeu `_jfP3jP]C)).MwQ ,H(-|,mn5'D/6-_bnO+S;=#/)5 D1NK3Ғm.OB}|E̖2GBb>iUK$+se$+#?oE47o$BaOƇ執_=9(p@^9뽀 N=X?)7ж݊I_d-`Na!J솁r Dzr|.ɂuSRN{Ec!(=J_gXhZ}6Ul5xzr0ɤZ˺]s}ӈLi];Pk-t w:4SjX/?Zs hhEZ:AU|E.Mlo<7!7$9y(meV@O?kU[x6םo)x<ظ(O5{vo[VN{ԡ+M.I k?6{3J+<:ЂQK ^2Uxu…@)!mZ~x:י,[N)(:"^h}[I-֦mALߤvJ5cHZ)Y1ʹF35쳊̟1<|zIZGRyAwUr- )9ii<2*43R#t5Wz#g52 uӴ|6@;?Hkw-uuOߥoZkv4qV7+WdhzT .pU4/F3)Y 5[rP4gMBi rW6ik# :i @X_C. ۠:%&f81 anfVn40db%^굖Lh[JUtCV!-9 k;]Strqӄ_~5$k][49'Ӷv 0{-Bk.?iIKɊ'a[@ *Őuͼ1s'G>P^&>/0'5N8*%:vS㻲R8m<.uNѹuX$j4Kʙd+?O(A󡋓JsYg_~" yq뛚\< _t-z-5@D=nv|FT%IoQ6"^4FMh!u*xEo֖{3[w?NZ߄Ԩ6-5ϒKϾda\)MmQׯ%Ppve2OLw_ .ˀ{ү(^ 9O۠?0ry9IH,]٢,܄ʢBNܢ:SK1 qA @o.,&ɭ@% P"n?xW0`/maNJCb}uU.v>o8U#|9 Ga`Rw,Xߟ'9%2A 1`vS%2J88Ls-d0\N!yo:i_\n)/^/.8#e6g&X9ևjOdn]3'Ŭb.zd&7Got Q\ 9Eq2U,z 9CȐ[${Z4'WNo-=}{󖅼VqƜi SDDŽQ;? E%OFь.D#!c,P?\PZ3{~"FIcC),b? e;(\_u[! M8Hu%nWd_v^:}a쐠d뵧,'B [/5-b.qFӋhբ¼˝尬*z&v:O"Hԛ{E<H 4F0@'O!6׷1ʣH˗|_!~%(+Kae-,h(&~D_py0SVJcOqf+'{Ƕ.zNdⶥPڢ,Vu{U[H5Q|VZ٨g1GB Mit-EZ&Ւrf{_6,iW[l8ɍΨO^`UHYB'%mUSgL*!Tcu0|r{YoroY+XE hՎ_;o+pi з4"{*pBrSB?zm2I,ClG:FV!`)~oۡm9R{Lf|2t]U_v$ *`oL˭r ^-M ,S+ot)շe3=7qSq׌n;K[4\&nLZ:..E-|Ox)d3Qp:-hҺ)51ũG=ӗl$ΐyʄz1t[J*YZnߊ'l.Ze8k_˒x| "78JPU! f`#Pex܃OՁ9w+_UW8ED 5<6Pۢ$P=@ +YPw&)NV6Umkyo'7}f|j睯߫hq?}<]Sт~xxN{2WG„" _-(*2ܝf;0uSoB4/Y.IS$'c*76J_0d )e0< u/6 a㓄z@{t ` ^ ,:0EOi6~}|{wƒ@kTof#펠;dVPhb]ʨӜ@\ ]Tن4GÏt%68꺰]A2Y]=jA+@L{Yi3+)4{֫ejz/w,&g&9Qq^V߹Q㫏WݞEGSp9* ÷Ec~_8͈at:?y˔0I@@.e>agmF!ul\25Yp=JZ% @RS厠a ŠNC,>Og>)|v#9p!GC(3SmlmRFOb^}k&uܱ6m@ͩKX%!zuL-3Vr~M;Uc;%Wuj>!,kVb֨4Bl˴dSURkUn&`JjUo C7kX! |` 9s6|?h !Ayȸ1(}[s&GW*m}KT:5npE9:B>"ՠZ͊@]zXem`Þ7˗D-3w^@tIj-L ^pͨ &)bP/0c]©w=(ReL@'̿=syj8rz Ns͒|kN^dY]~2gvʂrZMa,955,䅰4Q caGO.p% *|t hUz^~(dN}:a譳u3ʃ3iL".XaOfp 0{k, ڕb\UcY /z^fcQ$)u77y7Ȟ\]_@6vW=@M ;\4WH/WlR&klEU4xdvq0/&8b4!T˕Ɣ졩`qcQa_h6S.m vP"AxpTG+Ak$N'vd|\j4f]d<؞o(:s4dhEoUR,%CK'׽ę](vl<19f {dbX)o}KqGQ%ٙj8)O-`}ˉ ,>*2X47t\)XT |)>}3':ʮ\·qٕwJW59/pXup2{>9=G}IFRy3+KlCzS^?/%N%_js(A.0[+S7Ve74og=.]XE|;دqzuZ};X"qMڭ1&Nk;]JOC{q@oT08mFnPyI]!)Km^V_g!875~mB-c<^j'uWvt~u]E$\.$ C(X W-!6x:|v;[>^ۏCpmAj33h E6Bhg;?HgxWm{۠wqKn r f5eZI!KYVV0\ œlESMHn|I&Ep}OOg6uTi7=)93TŵS!ᛙI!gq;uMIgMj‰ v(dM}*nC~%.*< 4xac?dy݆/hM7+aWnLߒL)kCN Z>(-D,͒Dϧ@'!X O.f)1u59st=ey7u'/hϥ Q2SCB fh#S;-})ůH/=Iy1P969h)NCg&7|nF`㓠w+[\]cpqz? $Dp D~!PcLhXF?.A!2#*c~LE.k֊!Yv_;ٷI>+9y`3 +gbHJcFjx5#ַ/aAMcgG,>1B! B6أخ^s b.\g )<#gaBc)ޚt<{vZ.fg\(~=ݩU׼Qop \J$i aоEP_&lcX{I8Mq̢o#edEȣH(]N&/x4(HQ` HOܞ.$56C"j;n t<8g+R-mq`݂2oOGvdٙ~wv3-i$VE4^eOCd .dsPARE^1 >Јձ|OѼ 6/NEk[?k_=U^#8.УZKp7΍ wwY3f7A\Dz%;^`z#}gB%63' |1P(,> ]96u`ƩMi /2h2VuJ)\7.]ogǦd\Cn) 2m]Y, \)_Ҷ(i.s.&sDK1(~0˔ "KKxJ돯)ikڢuK)xv>{1{Ųs8Bͩp^_<࢚KK>) ł;{_H\}vE/;g6uuL|n Zn'> e}KNQE86^٦MA,vno_*:it/W-%|S M>e x݁P5y14 ̒BŋK!žMgzgj1Gt$]n}zR2~cxrmGN20w`8G[e4? wbΔ޽E+^Qi(V/:Oēè :OiϪcٯĴQogEW%BqQO{bgNL~F`vƏK9Tҙ*r.skJX!ʛ9^$ z//zܒ 9qȂM * wszZP p һiFpWsO$Rt+JvђG=[sw.Y·"OXA'r.8J7/-S\R7UVߊ"c%JeSW- 3ڮ̨xl8({q(|srF')O"PIoSrx?vUjC;I5&ŁI9oʄZ_.?}طvי]永_a) m ,i4aq۽@Ja胎q/c' ڄ0<NSL{$3u_25:g:w2 rxslp0j!9YH숰BFE٬tQMߘ L1G-Bƻth_a:\ =NNYoia~SnQ,Ÿ#Ѩ[:gsWFe礼/W".v0HG^ H0c 􋗲')s CLQt۽plڋ1o͘Ϋek$e[~T燐;UV7.]Ʋ?Hߙas1ǜIB'a03KCvdž,dzUs&-ޅ>ԜCMH88b2]B\]8s]`f%RBAVZ䳊_Q> tmJe3| ɰ SM049LKIG?88::İ@Z6^6 r/u?EyݖuhmSHxYbpBbBmܚ%묉[>"6^ѪIQ2W}ߩwA:'k9kk]FiMKB tťmMd'g3jݡ9C$ziw[{SK6]64R ܎Z9uJYu/ZNMݭgș=9O}/ƿʼNkNh{hMV_wE^k*PX Ԏ^8})A$*[zqTv̝4O|{lQ!e*xH\o{)uj\V2GF=NX$Db8ѕh ekUzx!*1] K5jRIjUXU!8Rѐ۹&݀'k_#?i_2aťߡeo.]ʜH3GMMny O؝dTHh[wm7ݤu4Sx:C+VZmRF&gz83iOtG/]\:~Eu>Oږ0TϠ^~ݦ&Nk'_-zKbލP-&3@}}7[X?P_ D;X<)zp6p=7$UW'/e ٻKm"i/v<LKð;?;(R(C'Ifː^- <#}?L!CB w$wC~B@GՇ3:`"$U"At_MdL4qGc]k+8(3 {l]G› Ύ/:Xy\A304ZߩǸ'cN=7{' _]f2^)g?ÒYAf9q!X^b`x883eJ?OYsg?} qc,X$|mJۥDGƐ~RηۋPq6cWS2盁8F41e]B62pY4_h}l 7aD-}u:L.@VD5VuNS yV&k/#4$yE>-a3 f=>\lAʟx Ϩt  ppEʅO|V4t|Y䀇FHy1"Էbl#6@ 8?Է- c{!eGYuS:(m ^) :˩7?ֿ?s lgU>h@];_)O=Oc uZ$lKs6[꟏}?`;3x4i 1ߛcd+I/g{ܖh o$cNY5) |]g^#3uɜ0e30P `KojmntJRN?h4Wv;s7p>DfI+/I_Z衷1d :'#zwS \=ٯ*ۘjh;ILU5JRkZGӔ{[)/gWNj!L+QZMZ Ln}#Y>U~~e}[9u `XwBY8 3ʧO#bPc(]9TyCpEO)ͯ.]O;;džEfjT@.l&$:D@3sz>{@c)yG2pn4)r+7I'LTGrAT ٌ/|g48'1*af?:#=\źoIY+;rIb e=ځؓ 7GH ḽIdf焔Q,W > k&3CsH4ƎUPeRd>}2(0 u_ֵC?u_[Y>oHscfc)f՘տ 6nxMWeBm?//J?G.7v| YE4d1kZV~Of#`ݺ7DSj72o` 㫱ҵ^Y[Ϳ^? N&$?[q!@Bx_T'D[˙+eDCbKk 4fA}8$2E 1!J'7eG{xz62>sdK/O=Ljw)5PĕtK靈{d$wV8PMx8zqk0#x:P` aԻC' [2\sOLuAXSa=괃x҃m~J~oݮ[{\;pwy]L7@lzhib;Ty|>!Z.rZ/P&XO&dK`$F*A޺%ˏiѕqiH%ü pϘP„MȈUB{Πe6 H#YO鬤5>SqG/iI NZy r7ps¿ֿt˸23V0z~a) r*@/+L\эin8t0vӘ¹9·^a_ط;ccKocU[yyPG39d ?  ]̀7yy3OZkG;c]Erms8YR+n&Ksg6Kce~jR9Cd_)pRJX 304V^Tӣ=7FDoy{qybw\/3œ2fR3uU>j~u_6Ɏvk뮻Q.gJ"|D#s3 W7ַ;4mZ(d&dI|qCjkCY/gv(#B;t`' @"9cfL!q;FH `?lƹ~PGL;a)j@=uRa  ì99 $?k}TĂ1V*S^ӭQ;NE+=tWڳ?^N=;P^.SY?dc5%?e@ ofD, n\?==4_]syp{u6GأAtpy5)]qpR -8}Ҥ/~:  >]huuם;6:Ԣ|@~'c]ܐka,녊aIgr2\hspr{؇~X}:B}NAoAnv ^׊8;w7?-)f#O;v0 lI } ts~U.g%^{z,屴yl6jwz+/Zx@6~G#wbxʞ?o}e@+[=YÑ5|bC^z 5=*>6_OOr?q Ȭ\8I-O"W MωW?81MnMw}=^+l-ֿSC0HNMuWfN/棨Bm{m&Ir&4Eb͕D <@Dd]?8ȱ1B8•z,C/>֮?g4Ѿdg0p@#: pYD(G ɣ}}FI?ۘ:@ e~xޜ C |gNrFJks`Q_׋wlVJހ6:M L9odΉPao֣M_6$A]fʤ#~/@{)FǟgAwE}o8w_H.J-\7Up\xlg9@*9(+Od!D>dwq20=\I]tPXQg[mEu=k[ P2d RDQ~ ʕ{tzc1|fBȈ "1+?H&C)ߒCÎ5 BKb%'Qi]u52D;E:됏OK'nؕ}=j;p|+2a?o1Orj\ܰQ+縀64=cf:hvAG̵gX(vd7Y |ΏzS=(y_ڞ(z̶Ol~\?4F:Aum)xA۩!_[7zBd|vcPs='|LQ_XDŽ[}ä=dyԎJǡ3F: v+{kAaSdK&0 ^ Hp0S rWƻ\0큀ț c jn|ɷt#mMӵ| ԸqhClGPW@10:=$e4cOA {hz<] Q IU_.կ 6lW?p!v?0%v&GƑ6yh~^=<5A-c5!SP0!;EOK9:")!zPc# #l 1G.>$ ]:c}mY?Vm Bn( )z1||{{@0. {ؠfXI ]EuP׺1ֆNT159obAD_OO[υ><úl>?3<DY#ew,="9dm@ͫO72| nwFwh0ƃ'o?_ /~ȏv" בJb:ߙatJ{:" '*do*\珍;4EҟS7월nY߹k p٣M@.؝(T?UNy 7C aL B1^ݍIr@` vjjsHKbUqT'L=Zd;4; VL=ez51/{[C@DBK* /@*ޚc>:8;-tya8QR!Kd6:G3D"2DFJ+[Cl8 _UNX'C@/.6K^GW{M"3{ n2=MmhSZJ/sSz;xڿ,D=GC'l+="XX2&8n ^R":MK ^ 1rIwY{Bz(Mdis73K3{UfS@fJ,pQ6jK֗ 0y ̼t-Wח1χ 8|ZWtH#Fv045?8ʄO2?2ecK7}=i]*1eDLsCw1BDO&MA7mȍ>c.Ŷh3jژK! =ټ ]J7Ÿ޽Y9>FR|Mb=c?3Q rG7ȼk Q2VO6E9߬f?C|`(;"R+meE.Y?t>w)Xv)-d:ܜ6l%+~26SrO8 4䎇}\Iggv1 (hϓIϨ{@ʗfIq>Y/?ipKC었7ENߏ޶9iW< rx?3W,.{£0d^]#.m1H)}3j_/|LW&LqÃh_W E+5"o&qW\!z5efs~irw>S Z7ۏ*v2\{];zX*zr{?h  F?gy 9 1lyA&C<ثeRߘ?<&kit?WU`6ɷߒWo"Dyfe0C#8_&6BEiG8 t(zz[ɗ2EW/] M\5^.F}8HL|#҇O-3L4)s&~p 00h]֦k^/M(>̅~~ʚna4e^bi bXfvvʋ"mDdjYc[hJdf!,އȋqCj#~TďEzx]_AX7VDs}@7/ As3 )\DK%2{o\S>~gJS{_(ŽSܦ*׺\۟e݅ss:׹0ӫK;@cEw37(_:B^ оCcw0&ݾBkQ]nU}2ǜSL00Ȍ(*[?I[ ]1Bګ{NF#lH Q霽4N"٠c7tw.Ϸ\l?I[r pKN4F/o`OAhfԌUM@:iMvx[0٫?a|iM~R55ƨ#DO查ibcЎR5qoN>]㐎ÏVx;__JSYKOo?-]0}fR{ݑx ̋%yRՔ'cvBPhd`8~2J5_j;7W3%uofIGj.%( m?T>hJl,ѽ4'?RAN)CN>Wuy΅̇;WG uc>Ep. d7<4qSO@N #U<]eL2&R-Tъԧ8\.c|xk6[d+,D|l ]n]2?k.YvTIn(!:qzBk\_۟+kREw*VgW3O+_܏$i2@4 gИy9ǾiLp2jjZ|Hg3DM}/ oF ]{ ?jW/T:t9Tjݟ).l?yB[HGa)8DL{sJ*]~Gj܄q-1O0@( :uCHźo,|%Y !'CX= E 6R!6^Yo}pY,űv>0(ǫGd Ξsy3t/.CKH'26?i1eY )ezz72"O[f|yD; '~]_љ0+!ⷦ v]mg'9acq1R3}"/8 1#O3npH??MyoN˱9u_ZfԮUrGs{}xh';Yߚ(}(?QO$4Q DCaU `_ăm?W+䦸# )vyU0M (.>ũx??,|=ڠ?k!#$c@n9WO-IՐ q47"oL{R6, ItuTj~/'x R R ;CMg?x$1$xPb۱Pd!̰xxq*F0 ! ؗ}) 1D{ v~m:vss(a{5?>ɧ !"`w eG8 ^{{٥Dl}Ua ֶ=:tc]۴uCmj7nd4U箨1?b9yD3Qx "A9G̃r!HƏu|SU6m G]W;sڥrIG[W |e)LHf?I{\j @ee8?gHJN1aA rܵ SSMۛݾ?X~dK'ah~!_3_BOW}5[*"Z//rb" 0BaK(a(`3^Ds?ꠔb\6IDScPԔlJi/nZrMRjʮ5/seWS:GV\aGq-{@kh0 0?~ _y1>|25"@.]*c~DG u,gG 1ڐ?nQYlI/;,ca~!VUVRg#?Ǯ w) 笆^08SǏ3«M#>YKL̿?*E4p,z!xX =ti#` y䑑G -,ћi`AaKl0\tQ Tij$]ciFۛX U^8tt/SU/Eݡ\.R8cD8 hH/RWIPznNe'_0)e3S[oG-тXmmX|vSDU׿AZNkQCm 8 ph%AFG P .md:.b u8ֺa~m8//uD?`ޞ]J+zi[_6@8:kn!dKJ!eg<A@RRv} <Ȥ[ʊE;&ۢ5[羿}߾}&n\V_qz`Fw͊h.v&3{$UTzHع2U$c4'wr,aiOѺt+4q7Xi !b)c̗ҝNk+W ,MB 3gXI?.MvuȟBM/ ܏iW&O;8ԶN\J'L ?]?8üt;雷_3;-L?0R04A(v_W?S* %D}vC%pg6ry8?24ڠ;q$Tt1tc=PzS!s9E/SGY߿U*7ִ)ЛXf >N5G3^Ot#?~&xkc6ӡ*y.O?ҷ).A'`23!'iֿ6bՔ> ʾ"ſt _ߛ/QjaS{cgaܱ;V_uWTUֽ逜o߾I:M?Q_0GZ2+oF O`/(IC?quS̄9 7lTZ ;Q FG,̀9HR$(߳[()ʀЎ@tx~ y FU:2*:Gq) q{;EwYK%)u61tWum|tc+7_j!؅7p`\+Y=i TaO`>r&Cw_ 21[i1Eǿڠ~aS,gH'K|؀ &D48.B}2 ָԌSx9ݏ|Ot~*R1"P(X|fiC `:ƹQE[n7t(U}„18rB4t(lЊ h׽E)GaS#.$Co9=(D;bEH]?X됷2DA5UJy8k wXR!%q]ef_0xtl-?/j#tlg܇?ۣݰ2,s_a@&|I҃HP #{_ 9eY5n۔c1Y{?P:r= :~/Ֆ UTwz5r3i3i6G"y"2 cKN;ke?&p{QI4E ܐ Z],o|d=z(z>wC6L+?9` ._x"`:[H*6a~HOP&J C0~4Aa>;6qp(|!/ BRk(@>=ʗq) ΗVEcDC r?Hqlt3Op[xnC#sQo RIP^R0ar8jSxT;CG*bhzg`GtC{tzpn.mhjeT攊;y#RTk0ǐ`˔}3eFon/? 5f=eQـnX+QF["wB: J_'`n)I:$E*  X77onJ{.W?fa+̠`)BI~rԃD iP'ئyʔW`í 7>EPkm:iYKdy?3ejÝ97gؗ`/_rAWzQ2ku<ԃ,%Z-仌b}g[ʦ8Mcnr֏#>ff@ȘadnQ]dt(C>6=Ӕ̛xǺ8y5nmk7KF l%ȭE ^b Afx?// ny{K"(n2`k{Y?2^LLjs+s/Rȭ?X,dCHC!Шx goty:8`t#[ 6hJ wS\Z%: oGDZ-:gjib{$U 7k՗c0cTZ뇦r}%p)O߾w;;龓;eu5QԞБKWl(oЙ@ A-2HKk/qЁ7Ny@d簰B{F?5NxPCKck/(\yUX;qǞ niok98-FAq3rxr`^ȉ~^|cR1.`y+aPa9b"-.poW5XLy1y{"6 vvwDXНqS3LHȨo:uaj 9!5Ŧ>q4 ^cH7H~Q閟~n-%LVIx`DPپne Ǣ)[Ok]?" *dh$g叕.U},K} JxmeYE94W=Y ƔM_!ay\PD|?uPix(~Y`kO'3vnAsl.GYsHEtTA9pM2"Q거A,@ ]}WӘ?X翺 '64@|#w'Lb{ / g"d; !:~1e͛An?_OGσ .zh|eNE 6[Kd0i.P&ǫQf,7 $y#W-aIS'qt)U ﲗ]Opswn8tݩT{]-%z\cFjFi*/cO@\0(ZJo%>TRݺЊQ<|0P1!ۦQVP+*붞?]_i)xp/EU ?Mԟ?*OGS>t^Dgcμmve&[lIVXہOG&$"_VufI}߳>wJ?(;#>}{HGC"d N?C~H;_9t^:_WY^R %'9W&;^ r H5Du~O>݄[m\T/ܡ^ony߯l@̜19; #_1츇t}5dR*XQ󚮅n^o +U:3t΃¹[׷_eORLs+aT5vgjo%Ks+״ڥɌۗҗ?ToǮm\:Lݮu=W'}bF ٞEE{o$5YNPLdEd7(T|}|wA4‰K^1YPÿeCso)r}@z]J1`q{S UnW/O4 rKE炲\R%? w7 .&x^ri忤s<~ڐrML_ sJRd i p:vw<͹񯷼q䀼iR#i *逨aLz|me*>3đ d~)뾕EaG !hR+/p4SmVnЯYLAzEؠߟ?sqY †&0 :O)]{jS7bd dQg.I|)VHb - `=KHl0mQH-Ҟ?%tm|S+#/ GC^A-Uo]T f]^UM6KsA+,tp@-*b$ Ptady~$op)"sz>*M]T 9o]3,TU䉹%Wܳzu an6P"K O/! WhC q̔zmYCHQ?X=M"cdvcNEsiP f\H=]{x=MFDϗ-9a۶,u9e9dݸ2ˋ}C_=`Agw/Q 1 'TE=G/} q nCskW|:6fPC OG(\P3_ lRK-!WEPPjl@ K.|ZU*Wӯ4TG7َ@8/W: 7CGW:nE8 /{QD x*oz[f))7#}J RQ<NQYmuuǨWW,imX1h DdIen _$_v4ٹ*UcP:\4T5%SkO BνKrfe!N&{iE mY9<6 &S3t!}9̻/_4mvoTnG )aU2#ݙt)/ݜP} E ՎԄ3gG ѮWo^WEl*Y? 46UAjB}u=W_^j"ta9NyvO8 &:o]zt MCH'>z NߧӀ8.\?>ҟ%Q5EPOx?MW(gNihR>x6<^?j!<7ȿgF $ x_3 P!p!7F b aà b$'/s/D4sjyt<)YX{Ө:En~ ](҉xekО 'J,|c6ߔ:qcMpxdpm{+^pӟ&ݜa ?]~9Vuٺ1,q{E}?-GIY~A߁WQ[ކqV q濤zH.'Y ]͇v$Ĕ%9g `RĽ*jWmw_ +jP`~Dt=s4N Y'E{Oi1=ܝi3VwL,&SA_N‚' [k@܋(\8< \9wK4Xmt_ާ3 bNOv:T=9pMSڎЧa[#a.O/ ڣrOd<e/O8xAðC8x'(>]J7Y+1: g0vpqAwv|](@1E2Go٧pN'~I 4e x%;u*8_'"zj;`9D_@fɖ@A2,`AG7/ "xpe}z|0M|?i"=UG E_f( b du㠶Τ{SyB#>m|>.4)3o4L]^4؟>M;\0rC 1MK4On7뉰lCCѸF(I<q(iDlfvlZfÏM]-».]WSB~VF/bUTwHͪEZIw"ۃ~aЄ+mb+4|SF7:GFc?P$n~ֿȟӠ@<9n/mB kudv=)MS01z<۔ޤ%_?ˋuÃǸ&Lvglzb#ݣ@u$:0Ӥ ̉N)iŧCJ[_9HI6Wa0w; :Gv#9f@5I&as0~jXr@ e 怃"@ߒΫD܆>ڙQKV1lUr89f)W;!kR tJq)>LwYSJM?.7V tT١o| ڢ>+gLo(/2aO10abqTYň5 mO_vJ!=yQtl&%5l{"۝N;[uGEз_%SSC +۔z%28痡$ȥӐ;OgYjWۆm?1G}F M} P~=]8KSu~h}/Mi{//k'Qy!g30f]pc-RcaF,?F9dc:&P2'3Fa$73L" ~l]?~x7,kEypn ,S2r2Q@:'dEY}S0iu}lLEva'7s:'i\/b[H Jܙt޿]R|ː1X7ٷ['`n?U*]6(BwUY;B*s~A"U{<~淰|jpdQo\0/L# ``_IXE+ p _~(K7D?ycov._gQdbk|]'?}A)n|ߘl/Wo3tos,@qim4u |E]k̡8M^sfy}kq|K?w3]mꬮIs`CM^vMMRxt,}__SQK^| aY7/5ખ_7^y$HZtV& tѯrMbK,Wlkὢ 2-{ HH$ #of-o8 !@.5 +;IFyGTWw) |(p)9K?CC`|xsσBb/ ZօOH':گ5y^t='=\?}Fu }/z0q,@mȝ#Z1pܓYf? "Bzѷ4淋@}Rm`cVTMI|X;'zy@<#d#XT C8#<*`Fr o;`$Ȉ}1{qr u`E&2D$S'Mи؟H#OwMBT0Tz(#苤ux `o`S.'&DatD@,"l$<uET$f˿r9{#IqZGit[[ zBԾ-k_YȶE`SG&!".E.gJR;|T!0IOݻ6Tx1G>ӂ7:4xS/m`#/GʇK~Q?Lw& fb1t)=z74ؕ#K12aZ  ߾߲˜ca_flfuq+WNb#'P) Ep00t~<%a`{I"L=7X4نȦ#8‘rX(MbX~nI, px+,ou h':ON=뿏m]7?Ҋɪ '5NOKLWSYz@tPJ$%'059|^}LϒF /w&<{n%Ooƺ1y6%gT(:qKIWKݑ7Ôo }_ Gi+`b FDQ2u a>AxF>F?PW?}%l&!|(`,KӲI ?@qRM ~K[r?w,^8_la;Pi`W,<:b<2<|g^ )<8BH!1:Ap=h_^@ai׺юfb ̇MR8i8uIɂmRqW~X?NKL%Q@8յNLQFA??1_ǿ׿c\Tnβ>JgTQ΂ w:'^}pG?}oUdV[fD17ަO ޗׯҌ4-\َ{ΒjV?NFT Y j^ݯYFrH$LJ]P;o҉FpqA_b$HtuQKݛFS[zMhptՖ~{5% 4V8 # @qV)*,;ow]ަ.]8&2mR#j.p(n !z{]'"ćY<?߲P]lZ=CO(h{tه]Foʺ*M?oUXS|/BG02M BpE Ou>ч}> 0}1=z:PcUܖO?ļ/b1+)x[ !>:}*?5!\qd0!i0]KGn.FS/% 5Bz5v]xc=dGw"w H#i"[47OaFg>.7qg!pDΨOs{C-I{ʱ<W71ݗ$#ïw4!9 =hKW6?:pz?s+P?I 8D3e%5=O͠MG)ʌht[[ ÑϿ|c/MgA%T"-:`QIT0Jk7Q 3)Qzg?sښPQ[0z5yݖhnߟ^?JN+bn]9 U xbXI'Yb 닞M%$Ct.>ۙƟQSkHumz_E4U?S t-W#z%R ̬ o_߉Tc 2P̰e\_#s<6XJ+7W#:uZ) S|ZǿZ `9,ٽdĊHN@P=?\/һHW]$JBS1з)Rt,_o3\~y^8kF*5H$XD!ȟ99H@|P<#xLcvpFŌ"LWzqo]G-ߔRw^ߡgip0smF'|o-uEc}4[zya2qb} l@C>+3E~J:uGoOe |RP Z:|2#3yծ럁X'z˛ٛbvS;mE K[˥ͶI[ɟPkgbd)S''yD [K Èzw£݂ ?*~ Dfr  A<(d<p~W?2_WADQfLQy(M$q~.QxwV !W CrHx@3-rw0*a(L."6Zb@nRC|JTjҦ'@G_m띀zR4u=̒ٹM?ṂrY~t E(,YHg= &i0r\|+8;CE.} S`WE 07 H)b jtg5𚵜WNz<= 7tE"g.<ٞQWGha͠G# LP{W6ߐ6VVJT(8aEʒ,A1',ibz0-&Gp7I02}G䐞!=頚6SC %qCDY 3܄;+k"' /|ȅ#"2Q(ǧ|>$ t^T)br!kK8o߳ޕhejU:Fc$)`%R&Uu} QT9'?- 4 "=P좥G^tWtw,O,Y}A%%G_mY,ωfUiMO hX ȍE#6#znNbиNhlGH|FL V]]tGN58f QaU'J2 ~10 =3%n, _PjySlLg$zDcc7]-.?V|fKEDO:K޲Gc!~ثLi{*ۮ o}+yvie]2_VeMK- :Az\)̄~m&ט>׍SJÔU mUc1 m[5~\[ݥ]j7r,Ӷe:en)U1'*LA9|PCKciu\,2t[ 9 '@zlR΢f:'Z(O!DfaAq`/tMDtHs`&漑T֑L; әڮ:J!_@ ~.nsO>@In?WQ '>")[qAhC0hk")MlG= JyexTv.TF7ď)tyNE1 壆ymjoF௫O-۳ ?rG% .i\"'9]8OM|*G W%Ant O$l?(=0i+T>hd'@pbE8Q8>znKSҙh %:[u察WwkS}TP6rR2 Tj'2@1'Nk$ < R3/䖾@_Qzj8U" *<(D@!Y?r3nUꀁa(zMȀpzk0.Q՛G[߅ CZP8 BTO^}*~]AfIcCBMP` woDjQ?@zoP:;|eD(/t0~ ] v(nzRP=*Q tY;z:Ȋ}?Dq/lsOĘ>HiF3`/O8|8ٔ.gQD ‚fNTC;uq@}'E0?\l?DM^@`39PƝ"!iU +׏']^ȓ(̀Gu!EtJ7,'xgu ;z!,p 'B SZpWrH .=;_ nEU!-Cg럑;x82_T7of 8 "'nu#eg +®}i>%S&K9N/x\40 CC؄ggϿP|A<ǘ Q`Jc֦;7niW.=FTUi}]|?ܰ wtSHyAf?4r7+\{}HA18`';=tŎSGKMT}٧D ;^[.vi퇪+f3Rh]-7aѪBR'O8{V'D {# yx?j[ ;&]X74px{o|ۿ/?o?~ؐ-yϺ~v߿}?vsKW֙Pи f 7BK =`*D\P{Q4ΧTN[ϒOҹ lr&>ÌX. )M*fGFmOϢBK/eIQ܁{-Í( UϢy,o0~nXۤ|4rJ?COVy簧ҿQ~(--NY +@]XJCp Q qo=NK@<`N ]~j/PMdkR7,y|G) Q 4) OTF[OTf=QRSڦܗo̻!pc#X觬K„q*NmſJMt]ݠVߟxQOhtqxNc{$BQl/gQfkam#IiT^NR~j&|[%U$=]@2+Fx mOr0Q9xb8!k C xbPS5qȍ]^n+쨧7\L/7h/Ot_6_zZAF1(%<'Q\:.!K'@=q}MooL"tK,)_WL8 4@R}M]6?:dW? M  TȰ@nLpտZg,(H)ЕwG.LYwbK4,x_8D$lW\;eGumO/|̉ᒢ=@{R~?ֵ=Y#LzM_4O7sA<~g>XP4@<|!nI>LH3t'噳;c>'8@ށ1M&3,lc&>9s˚w+Ҙ@1 c_:' r+11@9PAhiJbAl "G,7sA8PbhGFD3OG a<'74&93=H#t1 79Mnj2æAW}gϵQ MfAFt YNKggY ̣wv@k dnx;O@@O?5}**,d!Lu{1Dtɋ4NdaO[?ǜ+g!: 7h: I5*ƕ9'^?_:ēL>EH2LǠP!4& 1}Hl=X!AFisϋ Q;bށ#Gz_ 0řpw&=WIzwC~=ȞЛz\*gWyC_SF '-9B3>%$͝ύ'8}|'H,1r?άR:YI\?ӱ cفP҄TD{flC LZ@-: 5K#8^ |@z P$Љƒm|dYeGq<}Ր뻷//?~vnKP.hMe(^Ѐq>8q D~X/L>J0ύ{iGvJG Y]8pG8@Q?_?%; Au g/(;3@V4x}+vScm^yF)dvOBC 7:J?WwaA#Qj[0]\P;+ChWDKD[PMg]y#ZPSn=+7H%J]-"7X8 ,<=c=,>T'eĔ&L?9L6lTf: q- , XA9BXƠ-7.>џR=? P0)sǩ~܄]C-rPw8dMQv1E;*uEBswQ: i Zq]S YSZ)1 HVh),I?vCt}ӏv- . î ƞSAإ?ҍݦN,oj]q dgEE=$B(0ֿ|Db d#[Ó#>+2ʼnUߩ #0t `7Y /rax)|OD?S. UOz 01?E='A}<@ ٢?a5a/ h^R$hΙgg`8G]gd,zG_y {"sb^sem.Ӛ`R=C4-kCхVFP!&*% ҧSGJ%Џ"I\k1rALbpLQCL]E]m??k'* ,RÇ0/ I!)}IŅb 2Ls\8&J6'l?8 uwm-@ e8(_<{Zҟgoj|x| ͽ `!ca:b 5'~( kZVSLӋ1Jpd'2 \'-k{lZSY/R\}<ܯa&]9" z7HpA}. MZt2XƼ2ս{}Ko?ZSw}Vo ^kI3B~\0y+!0  dYڱ͎48sI2o ?w_fܕ>5klOտ<{=F\| 1(2r ^@Q )=??pC0D6!0BRa@s’?VJ>/-?,>dBuK=(?+݉f (,3VGJRpMF*?vɧ\9]Hr>+ ׀2"~ t҈HNBo dR!ƩteQű n*C%?*$- M(R̀J9;3?~; WKٷ\ʤ\?_!h?? vVM6٦>?x'=L^)U\.6;wt.Ou}MzaN5< XP !ޱB$b A?(R {CU |= iӣI2Hݝ@3tB<ἴ:2v,m?XI s19 ",dh {րތO1K[ IЈT:JSTvjz&c/A JІQFaP<\L_#|yЍţL}Z+8قd+- 0iwjCW =;7pb|-nX${,=`/6`-/<?Hŋ͎FRD]&fN}ҤKt(i{*݌tn)06˛nvqzwȻ}╱'eC Vq8f! 0nv= ޟ'o:c<}Kc\~/앗̊סUhοc;%+ۉt60+7`Q- V6Kr*iik&c⇁7u #qxG窺6Yey}ױ`w" хݪqYV!HFSk/MmJ:҃JY )u- `}πL{㊾OJ(4@ߐND:L"7EsgzS;^?fs1>2@,흘<_bKQ~N"oWᨬ.֗~ח[(?E!>l:`#x-@lPg;_|6)YFIG ~a96e%uf5_%p<@i ׿z((Gd |khųluƘnvk MxBCQNP ~((S=v)_5Ø# XBolƿI{X?B撱=Q Nu>!B`nr< C@Io:*Cj&R$ 幎Pky"d BgJ?A]ߏgZ|Z^p` x3Ig`A-q"-㿽w.%Eo}[cJS14rM9gSB׿bUeg&w]7%1x@"hޓcL{: ov#T4_$J [݂1$ 䰧i:)T߄N<(`(^Oddϧu>b5|1ھIN ]8yglWfD0[RcGP0.f1ċJ#]7 C-p0NrO0Oտ vXWYs8'+aVWD9d"CƟt -;Sct>Rj5ўrM(aKw =c/hh{H3[ryDK+!.TT@8Рkcp ":Ӊ@mq* >}Ţ#j㳶޴9dRN?:+l9F7n7{(4!(߳y]x%_@ƀFSP籩RP\>ToE˟?#ThoT L  _.[-O~2hIeDg;hʃK!b\{6\F.>q@p"l a 0!QБU.{m_TƢ/m9gԉ(̵W'ݫjA"bGӸ:4C'ߙc#B?q F@@moQjG(E,΢1]͠PĈn2jJTxYAN7kc9 d"*,埾Ʃ_qmq8#ǃSu}7ߕEюeZ2n o5LYޗsO;xE?&6P ) .>ο 09e02*y.XU!!G%~)H_b@pӼ9u+^*bY6 }~%72@2뾧/Dn@LИrvXc E8~l67a v?n]:\?P)nI=,l.v`c ҮS۳C@A ÷XM:_[7*u Ev%9TS r'N$( Fj NMUjhD07?p;TLi TY֔Mhxyz?W|7̿(6u߿ߋ1ƅ-_$} "jVYT!y"rA le1/t$@?N0BK~ tu=,m2ْx^mƒ4BU1~ܷ֏QP -9q\/$ {? (o+u{ʃm_ËQYN  6 Q`vrwf0~8zhi~=oj{MSVVhzzߚގ)sY%(xKs!hb=yAleQPHPo|R+3P q)߯_?.նw*d?v9@f@mρ 9I$@.B8kX*E)X)ȾWd+NWS롰# ?/jNf"M查MVЇCZA y&"] *?q=NW)Vē@a43+7Τj }?H%)ipnxTnC[N _X{?ȧu ]}W3`dƥnѦx,tN \f -+~?=;y/|H~J4alΚM=<+\l[ߵEԼ7 =p$ԫJPr^Y 㱏$tOF'Є :VAl;eGq7 _hzϚ˩=Qڰ K֧WP) PP$Ytj #EB~o׫c+ݖϵ.yA&lx.@ ,,eOMunb 9dȘ1{{1D"Dգs6]wHs>Oׯ=s E%1 :؍VxQ263-SO뼫}}Ǧ6M+]u2GYo^͚"Mvy[zwQss 21koJ~irxkB =ao# 9@Įgȣn7\-"!JCd"h $^X:Rg-"+2Q,M4#E8s`8 $5ܙ j8Aʪ~ff=%}` _,+,YͮguA [ט겊R-0C.T(76JP茞XA}PgNX"C'gKxO-9@4—$Nݑn\'sV_AJYD9yǼcT~c$܃t@97>=w;Hot0&mcSᆿM+<+]ʜB=>_hɮU,t{sZDd tN8BAo2vD xW;! =dcݦG/Χw"Lcln̊kx#&4lVDx;#<4A_lDTSFhSlˁXmj5`=?6 .&⽥m|f lSxSmK )K~zbC|Ui&j楟)Z8$-?I}u}|aTדA}n MZb&/p~`?8 :h'x7#PBR"oWqmBQ7e;B t,aoK=4q`@P* t B Oݞ?TDyrqprҗ!4& 09NJ:ڛg9 j\3E kIaKI`Bc:#cJMFJWe&h-cPlmRRg}`o!,c%"Dɀd48ߖ?Tݓ[8tŘS`9su(w?l[MSY8eW m)3KOOnV - ȝ5POP}[cG0Sw2-hmVm܌ksP+3G?xL;qryHxػGi .|ysW߁܅Um rD"aX7| NMO5ҵ:=~B dMǡ',`G6^?rů8YjY 9)ۀ\!8F4{7霧:ZQ@NNte* CӒ$0:T[o|:6ج"`pP߀]AwMcM:*J/5_])-.FAO&κ\/Dޜ8CT{ %a]KWLz֍'?ޚ`}ԗbh /ˁ/F?ſA+Hj8ڶ/1t\b3T5 o)${NjQQX0U>q37Q!26Ë.xcoO@O@qn ycd0@[:ZK}N)śrd/f K8U;C=%PO5$. A%?x;`)/7sw/u* t<߿*w_/'!("E=ؽaI!s|h鿶ux)6z^ϟ~~>q@uC ~4G\Njg7XxoiZq!4r_O0uR9iM(-@>߃JpxHޟ}?m^![6Z-KqVpsPoIgbＴC2G!>Ͽ&qc vw)e# .h16)eHEߩ1 vgpH8/Ș'8̃\(~h|SOoUHދ` #aC/x]:2Ж0tw[Z[Qh E+*2|]>JGn >'6W>Pt{gBk2;(68nݸll9G [T zd4 at]A{_bUoMj!u( MYR0 '[?y<5}w Yp9=3Ůy,FH⢺ *S-ơz耧l>mkMs,Wdoև]꾒u_#m:?3g.8{~A|:aaA「„A+vzҿ&ԫ`i&0Pb 4 9u^n,|Y\@ !Hl(??I#!@L@2=S[ʶuݥmoөr|Fjn>Ugv?/Q0=͆%q iE*$vK1?|yBn?˙ΰ@֖:ÿN('ﻇ'baԨҡͤ<?ӔloL˦]iʞ*k;eN%/X~ b$C:Hxo@)5"*#$i?rOοd@t"BS F%˔D7юdp%ST'd]DP{FBlޅQdAN" ¼zݑ'󏯘YP`3Ij宧j:Lioqeo%l5jׇHF:'vm~)^BB4x+6I6.2Ҥx<˸Y/7??cɢE J< ,R^ߥFiAz_baP22x"?%6;S6OP9&!ɞˆpJ^Ȥ TGd0wS) r(J8t)aj/mZ1mj")ZC|i ,3?]>0j,}^cQ1Ļߐ*a8u}`Oyms.؝*=N)_~ֿs{4ws9|MR<_?Al=LC K[ި#%YϿ4`j?ܠ[pIpg{ES[ + W_ xE5 b`8y ,ϟ]c ]OSR.O!!/jr*rǥa.}[i,8QEk6,'?w+ ?8G9#dW`P>&ywCާ*2D Y 16?$b3+EN3w}q93#">0jqC*0 S$ @_jD1y_2Z_v#M/w):(XRÃ)m}zzXAĉ kjHok8,9`:gS7 /ދ{yy)RyƐǣ .  ͻ GnK*Ixpp0^.v޹#ye+.|ԩ߾ԡ}G.ցaSS]֌]  X֘)IH:I5TWZ&xw?#>Epz GB? eZG ,Yt7J9YlySIQF_2RTp 9[piI7?eM\P}\gs)C7{xfsd&=֞|H#*(7P唯u}xу#X[_K;o\I8҄q<ANG< (7[%yM9SN'ztONł"E3]8^I䤃OU]o%X?q!-}J</'EE,9O_/CGQw}O1|ϗKmCetc8*^ס9׵1|.?)u-8嬯vIoO~&COczFz[ٍN_{{?cyh_?z7K(f@ kOOKhiy~Rzv'jH9'O?\-_ZHBIA0?&qM8GT6ʃMFQ;p}>(5CBpCW/D\+0|(cdN{C!׿xpr/>֧Cp;v4nVmySF NOz|kO]r}W?Ss.eU/a#{P1)\BoMBvH`j Ɓh&3֯0ؼ6e(XĢ/-W>o]Qtndb|u?B=ȢϳAC~ól(dJLu _p4y7D53B?F苲yֶE@ԏ(e*F[t1|t\u1W )'ċS5p( bGEXfuFhZh l#@b)- .O{ SSFvHR 0 "tJ@ 1.:3)e+>ם\ 9_%Bl忬?fb6PC8uo;A*K;nb3COu71Sq%oq,]!Oοk7=L4}]~ _f3\:B -f%H14F-wcrHs S"EObỺuѝZ0OƸ;Vm'kz:)ߋAHT?3&Ac!HO@8skv'/)S̵7xmN]3Zx>W7&Лi<DnoR|_9@|+.(\<4~~@ir`{+_iW63ym>O+rP4/ UCؿKX/?BEkdOHqfÀGvlCPG27 e|Q}S\"_/7!oyuS(7ſ?W? >.v80/H)`5O]ϿX| /Mo*B}=;m`j<]s>?O%Wq(EZ界~>.VG4%p vUH]|]9ƗseW_j!6??xJS^|p%h#ƌf1; v{2I)LcW8λ:gkq9 oosǐ+\EUUݡjw?O/o~%g ) x?nCS޺e 1nt)?0z_DW=ڜa (Gq^=l!w6C~m>THKovh *-^_/38Ppޟ ⚍';a5QQii1-S^r ?NPN<`*+۴ezɇ 0qz3|fb(F >ަ_<=^h˜tkIOxu_)7\ nPYu0d4Ae2S_z!5!5j !~Xtj! uoGVGzQZXy0yn@#,F&;jϔ\F2(2|v_/_u?Sݩ:Tyb% =ݸHmoPDMr_ } K@V&n ;(gx(O(7q~q{x6ۙNf 2$//) C7}l?NBE*ڄ#R.hԒ7xy]M.[cWvaB5򧡎z]W㯶r?5@"hC$N[ꟷBGy!·8r <0du\W/\߽uXvMSvoKxv/K 1MׄνwU\A&Z04?Rߢ։~_K7?>z]KB pc Rқ [|JpkOm4=kDmT"uZ߭7g.}6??h-DF+ ,7cMy<ݲ!Ўmk>/5h:68 CoDV2-3Ol 1Oix r U A85|m/~?ɅO@gHƅ`(D(\ϋ꼯k7y5p9s>:?h~86|4`{MpNf{sDO7h?;5@baO'?9xvhWg[%qcxȍoƕkc2%&PC5q9J4Zyǽ} ?r^)fz/Ֆ'UY .P;cGg£M3JƱ~@\_W____zs}}م]?O/;t׵{1~):ui~ FnEB*W.^PZ \BD~FEJ4;Fb}TP#n?~ӏ~^yC|6pY#=摿^d]&}eB`0gP>!pFbi}k?jX$^,%vqP1 5OwF[T6TENvŢhBӟVv9өi|䇏>?yw|7BDoM!JQ!96! bJ^?$Zq|ȿt S#TR(EӖ9z9"n{?݆‹~] mzj{1b5{do^d/Qt;" 8-MpFbsxi*m(Sz*(:B Qn*;oC|CH*F]z%:&#_ xK '/5@?AE4j3tM0:+CpcpHWK[G\U۝$sa' Pl]PڠE˘Y%'P&Q?3k;'uPFADZfe|eD^h#F_m=ʞVL*=fuuSc܄/^1TMx?GP iz?H}$6#$OE4Pr;𿵄n~o41%P[ w\,m?(V@"F:HFT:ų=?~O& H#Ԡ?_h0I/3 v!7WT~A )`"QV0^濢zU֫^u*-t\(H9zL|n\N]oBoۜ Cd./緕;4fxD`vߛOGh0o?6H焁%}A{*m[gw|Dz'[#yhy{ FpOF^U.n anw4N|dl`R$丱H0}nba3ZC4 ՆwUes 8Z3KzLʇ}B⟨@SZx|(w17{7j@t=xC.G.6' Ｎ6m׈ |.WA7χ=&beB`ңeW!jc]Ʈ/8^'/upW9a\*?ބ=-1~{lד `0 Jwl20PO.?h(Fi[s߻%?u1Mqj\ c3;Jb>r%wN\΂ۿzO:754 3!|X*fd @4/{}s˛O7T Ϸb _E^._s./>ֿy=vN%}$VelpP!0mAL-O Oyx+E8^%At^4"w4 G0r]iyT ?8Gb`iقK_™fԸ8&pExEa섘Y\ǎn!Q,I)!@_!{]s3 .aT׃ #?xij}&\9~"ѳ%+GȄ z&Z6]M{+ʃ~8\*`0,X|uYqu{p]h1\i)$ho&XyyF} (:LK/JGͯw8q\󤄟7V~r[dFM G ?|Aji䢌wO+aL-D)2sbDY:eL9Ϳ 붉C)OP`aVE6$~-TIs}hW?{?2k4921qe}%G~ٹt3MDqã,n73^7q=EPsa0=WO!Ls̾ޤs`sJ/. ܦ̿Ycoh(H@"RxN};LQZkEky{#nI0j-#|NS^ja(/| 7<3QlyvgApq_pE}wGAuG> a89N22Mp̍dO_l4sޗ2*zXXKSp%W)/®q8\zmcq<6_Yп yဘWpI Iw7cTf[>ƒW/h䧘xd:~xTj̛)?Z̷AY`>{_}wCӅc+IRfݏo]qu=\\8>6vyG9[/-Wj d-,bY,4oJ qsSx$O򟜾9SM׌e )S/^,v }I F}ֹ'?,mdޏ-`ОϜ)Y~/qw.D`hQ&Q/b+kNx`I.HmJ.If|O/MAr^XcOHKk>v^6 劮97k1.^Ͽ"J@h\< n$$z^0f_?}o Y[:{v;?_|tB qK&6 6HړY@6E$P TS6J? U_(Y{PgNzlB.| -ߣ?ϼ`q̤>`E1'Uzk 5j٧03 ]?6 5*OotsB#wqW $[_Mx*}3C%OZDd˭_l=NIzE>ǿO%4ꈋ%2C :ঋ:GvkaW=goP2y肐`,@aǨG0"7,Vȝa2E=tN,@!*$~6 n5C W݄h?`MO1CBvdP38 ,)o}sP-Gw Bݲ*h@rc?#(q6 CNxewp(pA=$I*.(=Xpp>kc|:拣A| m? C# ?>Km@ɵ?]Q8\nNwyQ珋{߿a5!Ӯ0l_Sqj8 cOxTby)}<ߊ~-[)nT,,(v5Hy\B#T \.! ƪ8&CsYoU.F۟ŏs T9x}^^Ǯj -_mFڀ2h7CbPLN0dl?Sq 3]1O$Nеm[yKkr7 ^>Ykt %g ևCbz+$MoNX:?Mӡ9+oC'&w4 2գq;u(j)a^}WcTA w߸HmANy { l7R[oH(l5}<] 0M>% b/ mM?\lMLHAi]31/hlzЅ-*ʐ)HSǮkFBW!)<}^ e_Ch^͗:O9 gd߼ ao71etuᇜ^#H㯫C.].ťoR|O۝\]I_Oza? p|٨~ѼzđաI.8z=ޓ)|zOr$9 8M.>}]//\]DUwe[<ܦgAkgf{j #yQ,ϋdْeĿEv1=52 iphd$_TX/ 9%\醷-p|ҿXkVG- $fKݐsu(.huvoE\4Ft;)cKyȦWD S4#GX㽁dE,wϸ= @r?;-xRQ`Spo_r`}e&+p"&@dq,|B??7p]_Pܡ7Dg 7t)$voi azh SEG@4B_>}Zal4 f"mɡn%N=1Y,$M*۸q8=o^ 6\<@j!k|/T<4ɚiG!I\t s4zBݝ/z,zwb$0'(L[XHS4Vʮ>?}uOU Fq^Am=Dd!- +vg"LR>.?w7j'|AfЧîsvЋ8EcΌӐciQqC8rpM??$KtyĻ3V?"J6GcK--: MP[ey+)@ &۾b5VNx)6[D3~LJ굩zIs\"ɕq:te/C?Nakڋ _Kw/Y'檡̅П0d W# \pq ;DQ"G#8(G[׿h ;N- q vA;D5sp$eW([mZ Tt9yeڵuY[߻Ӷ{ Ho1 L  !k`#%HJZXZoc#taH0t!ފ`H4iЦ mUSB[t{e"E:>yTzAd:%jPW.?{翂MW349<1CHS Xb!礇7ay<2:_ ~%&\^dKG]w6P_-?u3I}\?Q~EddITt/`z!L֛4""YN^~?RGqfCmG6^z@5$ G[pI U!죌̀3 g-GW<ນ d.nDy {6#nS7 >bHF }{- t[_{?W/zHjPa'6EoI$&ehr?5oMt: 4k~ɔ>tRɥX^bsbl42q [N`f"UTO*<>sa(c^?_}LCQU!w]hkelй-ñxZrwP..iSGvMolVx:ϒuDm V#~i܆t 1_~aC t`#0ExE|. xj"2 m?W3t2=͊ CeGF$ !T}({tY_Z{or]kC{EI_1׀+/C?]NK![ߙM4@xI"u4ҳCO R/eri efydΖ{` =߮@k͏>=/3Yqz\NA$A^ !Bwlg̿^?2 61 0L'(Ep G6%X:v2|kdW3~D"P ')c6+`px|+|dhq|co_cOGx[_GwC[7FSn"xp~oyDwũ[?/:/敳C{_Xl 4 23SDfX}ZlC a ީw:Rt? xjZ)z e`o0=UӡI} /:©b5̡%xWa 6x4~EA@B()R~e9Wc㷏šU''m,+XvW*X,i+f>R&_ͿLJQ{ u/4v;8Q;HK?4eq*OSqxl|]6H (X s['zA :Q'tp$(yS> EO–ã!t'wt<%qF3xizhA@7<6Nt"_4 h &?{#$>Ԙng!@uf@ԉaur k.vW\aGrXF3, X{J] CC5i{7o^<[(hNOquÒ//}p?~ R"#&:(F@i5@tMwZȮ W/2q C翭9~ϧ_όJCzdNiyzA)!M{uO|d.Y8Ŀ῞kFzUIӗmm'gD))b_uo?[w&do2hl6[+Hhh Z̞Ɓd'ջI݇0W 'C׶:E`v@A_s"b v}0IMƟtY2sx_!~8hz$c&(}+/neThr9OY axe-0.3.1/tests/data/gbs_se.barcodes000066400000000000000000000027241263567001600173240ustar00rootroot00000000000000Barcode1 ID CTCGTGCAG A1 TGCATGCAG A2 ACTATGCAG A3 CAGATGCAG A4 AACTTGCAG A5 GCGTTGCAG A6 CGATTGCAG A7 GTAATGCAG A8 AGGGTGCAG A9 GATGTGCAG A10 TCAGTGCAG A11 TGCGATGCAG A12 CGCTTTGCAG B1 TCACGTGCAG B2 CTAGGTGCAG B3 ACAAATGCAG B4 TTCTGTGCAG B5 AGCCGTGCAG B6 GTATTTGCAG B7 CTGTATGCAG B8 ACCGTTGCAG B9 GCTTATGCAG B10 GGTGTTGCAG B11 AGGATTGCAG B12 ATTGATGCAG C1 CATCTTGCAG C2 CCTAGTGCAG C3 GAGGATGCAG C4 GGAAGTGCAG C5 GTCAATGCAG C6 TAATATGCAG C7 TACATTGCAG C8 TCGTTTGCAG C9 GGTTGTTGCAG C10 CCAGCTTGCAG C11 TTCAGATGCAG C12 TAGGAATGCAG D1 GCTCTATGCAG D2 CCACAATGCAG D3 CTTCCATGCAG D4 GAGATATGCAG D5 ATGCCTTGCAG D6 AGTGGATGCAG D7 ACCTAATGCAG D8 ATATGTTGCAG D9 ATCGTATGCAG D10 CATCGTTGCAG D11 CGCGGTTGCAG D12 CTATTATGCAG E1 GCCAGTTGCAG E2 GGAAGATGCAG E3 GTACTTTGCAG E4 GTTGAATGCAG E5 TAACGATGCAG E6 TGGCTATGCAG E7 TATTTTTTGCAG E8 CTTGCTTTGCAG E9 ATGAAAGTGCAG E10 AAAAGTTTGCAG E11 GAATTCATGCAG E12 GAACTTGTGCAG F1 GGACCTATGCAG F2 GTCGATTTGCAG F3 AACGCCTTGCAG F4 AATATGGTGCAG F5 ACGTGTTTGCAG F6 ATTAATTTGCAG F7 ATTGGATTGCAG F8 CATAAGTTGCAG F9 CGCTGATTGCAG F10 CGGTAGATGCAG F11 CTACGGATGCAG F12 GCGGAATTGCAG G1 TAGCGGATGCAG G2 TCGAAGATGCAG G3 TCTGTGATGCAG G4 TGCTGGATGCAG G5 ACGACTAGTGCAG G6 TAGCATGGTGCAG G7 TAGGCCATTGCAG G8 TGCAAGGATGCAG G9 TGGTACGTTGCAG G10 TCTCAGTGTGCAG G11 CCGGATATTGCAG G12 CGCCTTATTGCAG H1 AACCGAGATGCAG H2 ACAGGGAATGCAG H3 ACGTGGTATGCAG H4 CCATGGGTTGCAG H5 CGCGGAGATGCAG H6 CGTGTGGTTGCAG H7 GCTGTGGATGCAG H8 GGATTGGTTGCAG H9 GTGAGGGTTGCAG H10 TATCGGGATGCAG H11 TTCCTGGATGCAG H12 axe-0.3.1/tests/data/pare.barcodes000066400000000000000000000001341263567001600170020ustar00rootroot00000000000000Barcode ID ATCACG 1 CGATGT 2 TTAGGC 3 TGACCA 4 ACAGTG 5 GCCAAT 6 CAGATC 7 ACTTGA 8 GATCAG 9 axe-0.3.1/tests/data/pare.fq.gz000066400000000000000000000005661263567001600162560ustar00rootroot000000000000002Spare.fqn0 DwEOEQ@m BL"4AQ77P=4_#kO)`< Ɇ%PL@9g9z*DDxQ5 εPLbQ)81FF g"ZG gW{@r0[.nY3=j7 20ýUv],JUs%+!II8!1)Oqx8/0LiNA@`8&OO):j#(뛂RKDӜ~17m9;Yx{܅[s|-C5o{ Jw'˨r/)CZ6!#_޶uqy$T}m= axe-0.3.1/tests/data/pare_full.fq.gz000066400000000000000000000003671263567001600172770ustar00rootroot00000000000000Spare_full.fq @ E " X4^"vƠ/q]7#,0p$iR/!ғ P X5UoYj1\jj~fc["m_l1 l͸b+˚m͸b՘m.JՌs jrVc-R-epWlS]=MtX]wEt:` MLaxe-0.3.1/tests/test.c000066400000000000000000000026351263567001600145710ustar00rootroot00000000000000/* * ============================================================================ * * Filename: test.c * * Description: Tests for axe * * Version: 1.0 * Created: 20/06/14 17:14:55 * Revision: none * License: GPLv3+ * Compiler: gcc, clang * * Author: Kevin Murray, spam@kdmurray.id.au * * ============================================================================ */ #include "tests.h" #include struct testgroup_t axe_tests[] = { {"libaxe/", core_tests}, END_OF_GROUPS }; /* * === FUNCTION ============================================================= * Name: main * Description: Run all tests * ============================================================================ */ int main (int argc, const char *argv[]) { int res; int our_argc = argc; const char **our_argv = argv; char *data_prefix; data_prefix = NULL; if (argc>1) { data_prefix = strdup(argv[1]); our_argc -= 1; our_argv += 1; } else { data_prefix = strdup("."); } assert(data_prefix != NULL); if (access(data_prefix, W_OK | X_OK | R_OK) != 0) { fprintf(stderr, "Could not access data prefix dir '%s'\n", data_prefix); free(data_prefix); exit(EXIT_FAILURE); } res = tinytest_main(our_argc, our_argv, axe_tests); free(data_prefix); return res; } axe-0.3.1/tests/test_libaxe.c000066400000000000000000000055101263567001600161100ustar00rootroot00000000000000/* * ============================================================================ * * Filename: test_libaxe.c * * Description: Tests of core functionality * * Version: 1.0 * Created: 22/06/14 13:23:46 * Revision: none * License: GPLv3+ * Compiler: gcc, clang * * Author: Kevin Murray, spam@kdmurray.id.au * * ============================================================================ */ #include "tests.h" static void test_product (void *ptr) { const uint64_t len = 4; const uint64_t elem = 2; uintptr_t choices[] = {0,0}; /* Truth from python's itertools.product */ uintptr_t truth[][2] = { {0, 0}, {0, 1}, {0, 2}, {0, 3}, {1, 0}, {1, 1}, {1, 2}, {1, 3}, {2, 0}, {2, 1}, {2, 2}, {2, 3}, {3, 0}, {3, 1}, {3, 2}, {3, 3}, }; int ret = 0; int count = 0; size_t iii = 0; (void)ptr; while ((ret = product(len, elem, choices, !ret)) == 1) { for (iii = 0; iii < elem; iii++) { tt_int_op(choices[iii], ==, truth[count][iii]); } count++; } tt_int_op(ret, ==, 0); tt_int_op(count, ==, 16); end: ; } static void test_hamming_mutate (void *ptr) { char **mutated = NULL; size_t count = 0; size_t iii = 0; const char *str = "AAAA"; const char *truth[] = { "AAAA", "ACAA", "AGAA", "ATAA", "CAAA", "CCAA", "CGAA", "CTAA", "GAAA", "GCAA", "GGAA", "GTAA", "TAAA", "TCAA", "TGAA", "TTAA", "AAAA", "AACA", "AAGA", "AATA", "CAAA", "CACA", "CAGA", "CATA", "GAAA", "GACA", "GAGA", "GATA", "TAAA", "TACA", "TAGA", "TATA", "AAAA", "AAAC", "AAAG", "AAAT", "CAAA", "CAAC", "CAAG", "CAAT", "GAAA", "GAAC", "GAAG", "GAAT", "TAAA", "TAAC", "TAAG", "TAAT", "AAAA", "AACA", "AAGA", "AATA", "ACAA", "ACCA", "ACGA", "ACTA", "AGAA", "AGCA", "AGGA", "AGTA", "ATAA", "ATCA", "ATGA", "ATTA", "AAAA", "AAAC", "AAAG", "AAAT", "ACAA", "ACAC", "ACAG", "ACAT", "AGAA", "AGAC", "AGAG", "AGAT", "ATAA", "ATAC", "ATAG", "ATAT", "AAAA", "AAAC", "AAAG", "AAAT", "AACA", "AACC", "AACG", "AACT", "AAGA", "AAGC", "AAGG", "AAGT", "AATA", "AATC", "AATG", "AATT", }; (void) ptr; mutated = hamming_mutate_dna(&count, str, strlen(str), 2, 1); tt_ptr_op(mutated, !=, NULL); tt_int_op(count, ==, 96); for (iii = 0; iii < count; iii++) { tt_ptr_op(mutated[iii], !=, NULL); tt_str_op(mutated[iii], ==, truth[iii]); } end: if (mutated != NULL) { for (iii = 0; iii < count; iii++) { if (mutated[iii] != NULL) { free(mutated[iii]); } } free(mutated); } } struct testcase_t core_tests[] = { { "product", test_product, 0, NULL, NULL}, { "hamming_mutate", test_hamming_mutate, 0, NULL, NULL}, END_OF_TESTCASES }; axe-0.3.1/tests/tests.h000066400000000000000000000016671263567001600147650ustar00rootroot00000000000000/* * ============================================================================ * * Filename: tests.h * * Description: All tests for axe, and all common includes. * * Version: 1.0 * Created: 20/06/14 17:16:52 * Revision: none * License: GPLv3+ * Compiler: gcc, clang * * Author: Kevin Murray, spam@kdmurray.id.au * * ============================================================================ */ #ifndef AXE_TESTS_H #define AXE_TESTS_H #include #include #include #include #include #include #include #ifndef _WIN32 #include #endif #include #include /* TinyTest */ #include "tinytest/tinytest.h" #include "tinytest/tinytest_macros.h" #include #include "axe.h" /* Core tests */ extern struct testcase_t core_tests[]; #endif /* ifndef AXE_TESTS_H */ axe-0.3.1/tests/tinytest/000077500000000000000000000000001263567001600153235ustar00rootroot00000000000000axe-0.3.1/tests/tinytest/.gitignore000066400000000000000000000000511263567001600173070ustar00rootroot00000000000000*~ *.o \#*\# .\#* /tt-demo /tt-demo.exe axe-0.3.1/tests/tinytest/Makefile000066400000000000000000000010601263567001600167600ustar00rootroot00000000000000VERSION=1.0.1 all: tt-demo .c.o: gcc -Wall -g -O2 -c $< tinytest.o: tinytest.h tinytest_demo.o: tinytest_macros.h tinytest.h OBJS=tinytest.o tinytest_demo.o tt-demo: $(OBJS) gcc -Wall -g -O2 $(OBJS) -o tt-demo lines: wc -l tinytest.c tinytest_macros.h tinytest.h clean: rm -f *.o *~ tt-demo DISTFILES=tinytest.c tinytest_demo.c tinytest.h tinytest_macros.h Makefile \ README dist: rm -rf tinytest-$(VERSION) mkdir tinytest-$(VERSION) cp $(DISTFILES) tinytest-$(VERSION) tar cf - tinytest-$(VERSION) | gzip -c -9 > tinytest-$(VERSION).tar.gz axe-0.3.1/tests/tinytest/README000066400000000000000000000012411263567001600162010ustar00rootroot00000000000000Tinytest is a tiny little test framework written in C by Nick Mathewson. It is distributed under the 3-clause BSD license. You can use it in your own programs so long as you follow the license's conditions. It's been tested on Windows, Mac, and many of the free Unixes. It knows how to fork before running certain tests, and it makes text-mode output in a format I like. For info on how to use it, check out tinytest_demo.c. You can get the latest version using Git, by pulling from git://github.com/nmathewson/tinytest.git Patches are welcome. Patches that turn this from tinytest to hugetest will not be applied. If you want a huge test framework, use CUnit. axe-0.3.1/tests/tinytest/TODO000066400000000000000000000005651263567001600160210ustar00rootroot00000000000000Things to do to tinytest o Replace the license with something recognizeable o Test forking on win32. o Write minimalist libevent-legacy thing. o port libevent tests; move libevent test main into a new regress_main o allow per-group forks. o See where we're at. - Allow groups to nest, perhaps. - Port Tor to use tinytest - Warn when running multiple tests with --no-fork axe-0.3.1/tests/tinytest/tinytest.c000066400000000000000000000304461263567001600173610ustar00rootroot00000000000000/* tinytest.c -- Copyright 2009-2012 Nick Mathewson * * 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. */ #ifdef TINYTEST_LOCAL #include "tinytest_local.h" #endif #include #include #include #include #ifndef NO_FORKING #ifdef _WIN32 #include #else #include #include #include #endif #if defined(__APPLE__) && defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) #if (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1060 && \ __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 1070) /* Workaround for a stupid bug in OSX 10.6 */ #define FORK_BREAKS_GCOV #include #endif #endif #endif /* !NO_FORKING */ #ifndef __GNUC__ #define __attribute__(x) #endif #include "tinytest.h" #include "tinytest_macros.h" #define LONGEST_TEST_NAME 16384 static int in_tinytest_main = 0; /**< true if we're in tinytest_main().*/ static int n_ok = 0; /**< Number of tests that have passed */ static int n_bad = 0; /**< Number of tests that have failed. */ static int n_skipped = 0; /**< Number of tests that have been skipped. */ static int opt_forked = 0; /**< True iff we're called from inside a win32 fork*/ static int opt_nofork = 0; /**< Suppress calls to fork() for debugging. */ static int opt_verbosity = 1; /**< -==quiet,0==terse,1==normal,2==verbose */ const char *verbosity_flag = ""; const struct testlist_alias_t *cfg_aliases=NULL; enum outcome { SKIP=2, OK=1, FAIL=0 }; static enum outcome cur_test_outcome = FAIL; const char *cur_test_prefix = NULL; /**< prefix of the current test group */ /** Name of the current test, if we haven't logged is yet. Used for --quiet */ const char *cur_test_name = NULL; #ifdef _WIN32 /* Copy of argv[0] for win32. */ static char commandname[MAX_PATH+1]; #endif static void usage(struct testgroup_t *groups, int list_groups) __attribute__((noreturn)); static int process_test_option(struct testgroup_t *groups, const char *test); static enum outcome testcase_run_bare_(const struct testcase_t *testcase) { void *env = NULL; enum outcome outcome; if (testcase->setup) { env = testcase->setup->setup_fn(testcase); if (!env) return FAIL; else if (env == (void*)TT_SKIP) return SKIP; } cur_test_outcome = OK; testcase->fn(env); outcome = cur_test_outcome; if (testcase->setup) { if (testcase->setup->cleanup_fn(testcase, env) == 0) outcome = FAIL; } return outcome; } #define MAGIC_EXITCODE 42 #ifndef NO_FORKING static enum outcome testcase_run_forked_(const struct testgroup_t *group, const struct testcase_t *testcase) { #ifdef _WIN32 /* Fork? On Win32? How primitive! We'll do what the smart kids do: we'll invoke our own exe (whose name we recall from the command line) with a command line that tells it to run just the test we want, and this time without forking. (No, threads aren't an option. The whole point of forking is to share no state between tests.) */ int ok; char buffer[LONGEST_TEST_NAME+256]; STARTUPINFOA si; PROCESS_INFORMATION info; DWORD exitcode; if (!in_tinytest_main) { printf("\nERROR. On Windows, testcase_run_forked_ must be" " called from within tinytest_main.\n"); abort(); } if (opt_verbosity>0) printf("[forking] "); snprintf(buffer, sizeof(buffer), "%s --RUNNING-FORKED %s %s%s", commandname, verbosity_flag, group->prefix, testcase->name); memset(&si, 0, sizeof(si)); memset(&info, 0, sizeof(info)); si.cb = sizeof(si); ok = CreateProcessA(commandname, buffer, NULL, NULL, 0, 0, NULL, NULL, &si, &info); if (!ok) { printf("CreateProcess failed!\n"); return 0; } WaitForSingleObject(info.hProcess, INFINITE); GetExitCodeProcess(info.hProcess, &exitcode); CloseHandle(info.hProcess); CloseHandle(info.hThread); if (exitcode == 0) return OK; else if (exitcode == MAGIC_EXITCODE) return SKIP; else return FAIL; #else int outcome_pipe[2]; pid_t pid; (void)group; if (pipe(outcome_pipe)) perror("opening pipe"); if (opt_verbosity>0) printf("[forking] "); pid = fork(); #ifdef FORK_BREAKS_GCOV vproc_transaction_begin(0); #endif if (!pid) { /* child. */ int test_r, write_r; char b[1]; close(outcome_pipe[0]); test_r = testcase_run_bare_(testcase); assert(0<=(int)test_r && (int)test_r<=2); b[0] = "NYS"[test_r]; write_r = (int)write(outcome_pipe[1], b, 1); if (write_r != 1) { perror("write outcome to pipe"); exit(1); } exit(0); return FAIL; /* unreachable */ } else { /* parent */ int status, r; char b[1]; /* Close this now, so that if the other side closes it, * our read fails. */ close(outcome_pipe[1]); r = (int)read(outcome_pipe[0], b, 1); if (r == 0) { printf("[Lost connection!] "); return FAIL; } else if (r != 1) { perror("read outcome from pipe"); } waitpid(pid, &status, 0); close(outcome_pipe[0]); return b[0]=='Y' ? OK : (b[0]=='S' ? SKIP : FAIL); } #endif } #endif /* !NO_FORKING */ int testcase_run_one(const struct testgroup_t *group, const struct testcase_t *testcase) { enum outcome outcome; if (testcase->flags & (TT_SKIP|TT_OFF_BY_DEFAULT)) { if (opt_verbosity>0) printf("%s%s: %s\n", group->prefix, testcase->name, (testcase->flags & TT_SKIP) ? "SKIPPED" : "DISABLED"); ++n_skipped; return SKIP; } if (opt_verbosity>0 && !opt_forked) { printf("%s%s: ", group->prefix, testcase->name); } else { if (opt_verbosity==0) printf("."); cur_test_prefix = group->prefix; cur_test_name = testcase->name; } #ifndef NO_FORKING if ((testcase->flags & TT_FORK) && !(opt_forked||opt_nofork)) { outcome = testcase_run_forked_(group, testcase); } else { #else { #endif outcome = testcase_run_bare_(testcase); } if (outcome == OK) { ++n_ok; if (opt_verbosity>0 && !opt_forked) puts(opt_verbosity==1?"OK":""); } else if (outcome == SKIP) { ++n_skipped; if (opt_verbosity>0 && !opt_forked) puts("SKIPPED"); } else { ++n_bad; if (!opt_forked) printf("\n [%s FAILED]\n", testcase->name); } if (opt_forked) { exit(outcome==OK ? 0 : (outcome==SKIP?MAGIC_EXITCODE : 1)); return 1; /* unreachable */ } else { return (int)outcome; } } int tinytest_set_flag_(struct testgroup_t *groups, const char *arg, int set, unsigned long flag) { int i, j; size_t length = LONGEST_TEST_NAME; char fullname[LONGEST_TEST_NAME]; int found=0; if (strstr(arg, "..")) length = strstr(arg,"..")-arg; for (i=0; groups[i].prefix; ++i) { for (j=0; groups[i].cases[j].name; ++j) { struct testcase_t *testcase = &groups[i].cases[j]; snprintf(fullname, sizeof(fullname), "%s%s", groups[i].prefix, testcase->name); if (!flag) { /* Hack! */ printf(" %s", fullname); if (testcase->flags & TT_OFF_BY_DEFAULT) puts(" (Off by default)"); else if (testcase->flags & TT_SKIP) puts(" (DISABLED)"); else puts(""); } if (!strncmp(fullname, arg, length)) { if (set) testcase->flags |= flag; else testcase->flags &= ~flag; ++found; } } } return found; } static void usage(struct testgroup_t *groups, int list_groups) { puts("Options are: [--verbose|--quiet|--terse] [--no-fork]"); puts(" Specify tests by name, or using a prefix ending with '..'"); puts(" To skip a test, prefix its name with a colon."); puts(" To enable a disabled test, prefix its name with a plus."); puts(" Use --list-tests for a list of tests."); if (list_groups) { puts("Known tests are:"); tinytest_set_flag_(groups, "..", 1, 0); } exit(0); } static int process_test_alias(struct testgroup_t *groups, const char *test) { int i, j, n, r; for (i=0; cfg_aliases && cfg_aliases[i].name; ++i) { if (!strcmp(cfg_aliases[i].name, test)) { n = 0; for (j = 0; cfg_aliases[i].tests[j]; ++j) { r = process_test_option(groups, cfg_aliases[i].tests[j]); if (r<0) return -1; n += r; } return n; } } printf("No such test alias as @%s!",test); return -1; } static int process_test_option(struct testgroup_t *groups, const char *test) { int flag = TT_ENABLED_; int n = 0; if (test[0] == '@') { return process_test_alias(groups, test + 1); } else if (test[0] == ':') { ++test; flag = TT_SKIP; } else if (test[0] == '+') { ++test; ++n; if (!tinytest_set_flag_(groups, test, 0, TT_OFF_BY_DEFAULT)) { printf("No such test as %s!\n", test); return -1; } } else { ++n; } if (!tinytest_set_flag_(groups, test, 1, flag)) { printf("No such test as %s!\n", test); return -1; } return n; } void tinytest_set_aliases(const struct testlist_alias_t *aliases) { cfg_aliases = aliases; } int tinytest_main(int c, const char **v, struct testgroup_t *groups) { int i, j, n=0; #ifdef _WIN32 const char *sp = strrchr(v[0], '.'); const char *extension = ""; if (!sp || stricmp(sp, ".exe")) extension = ".exe"; /* Add an exe so CreateProcess will work */ snprintf(commandname, sizeof(commandname), "%s%s", v[0], extension); commandname[MAX_PATH]='\0'; #endif for (i=1; i= 1) printf("%d tests ok. (%d skipped)\n", n_ok, n_skipped); return (n_bad == 0) ? 0 : 1; } int tinytest_get_verbosity_(void) { return opt_verbosity; } void tinytest_set_test_failed_(void) { if (opt_verbosity <= 0 && cur_test_name) { if (opt_verbosity==0) puts(""); printf("%s%s: ", cur_test_prefix, cur_test_name); cur_test_name = NULL; } cur_test_outcome = FAIL; } void tinytest_set_test_skipped_(void) { if (cur_test_outcome==OK) cur_test_outcome = SKIP; } char * tinytest_format_hex_(const void *val_, unsigned long len) { const unsigned char *val = (unsigned char *) val_; char *result, *cp; size_t i; if (!val) return strdup("null"); if (!(result = (char *) malloc(len*2+1))) return strdup(""); cp = result; for (i=0;i> 4]; *cp++ = "0123456789ABCDEF"[val[i] & 0x0f]; } *cp = 0; return result; } axe-0.3.1/tests/tinytest/tinytest.h000066400000000000000000000103401263567001600173550ustar00rootroot00000000000000/* tinytest.h -- Copyright 2009-2012 Nick Mathewson * * 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. */ #ifndef TINYTEST_H_INCLUDED_ #define TINYTEST_H_INCLUDED_ /** Flag for a test that needs to run in a subprocess. */ #define TT_FORK (1<<0) /** Runtime flag for a test we've decided to skip. */ #define TT_SKIP (1<<1) /** Internal runtime flag for a test we've decided to run. */ #define TT_ENABLED_ (1<<2) /** Flag for a test that's off by default. */ #define TT_OFF_BY_DEFAULT (1<<3) /** If you add your own flags, make them start at this point. */ #define TT_FIRST_USER_FLAG (1<<4) typedef void (*testcase_fn)(void *); struct testcase_t; /** Functions to initialize/teardown a structure for a testcase. */ struct testcase_setup_t { /** Return a new structure for use by a given testcase. */ void *(*setup_fn)(const struct testcase_t *); /** Clean/free a structure from setup_fn. Return 1 if ok, 0 on err. */ int (*cleanup_fn)(const struct testcase_t *, void *); }; /** A single test-case that you can run. */ struct testcase_t { const char *name; /**< An identifier for this case. */ testcase_fn fn; /**< The function to run to implement this case. */ unsigned long flags; /**< Bitfield of TT_* flags. */ const struct testcase_setup_t *setup; /**< Optional setup/cleanup fns*/ void *setup_data; /**< Extra data usable by setup function */ }; #define END_OF_TESTCASES { NULL, NULL, 0, NULL, NULL } /** A group of tests that are selectable together. */ struct testgroup_t { const char *prefix; /**< Prefix to prepend to testnames. */ struct testcase_t *cases; /** Array, ending with END_OF_TESTCASES */ }; #define END_OF_GROUPS { NULL, NULL} struct testlist_alias_t { const char *name; const char **tests; }; #define END_OF_ALIASES { NULL, NULL } /** Implementation: called from a test to indicate failure, before logging. */ void tinytest_set_test_failed_(void); /** Implementation: called from a test to indicate that we're skipping. */ void tinytest_set_test_skipped_(void); /** Implementation: return 0 for quiet, 1 for normal, 2 for loud. */ int tinytest_get_verbosity_(void); /** Implementation: Set a flag on tests matching a name; returns number * of tests that matched. */ int tinytest_set_flag_(struct testgroup_t *, const char *, int set, unsigned long); /** Implementation: Put a chunk of memory into hex. */ char *tinytest_format_hex_(const void *, unsigned long); /** Set all tests in 'groups' matching the name 'named' to be skipped. */ #define tinytest_skip(groups, named) \ tinytest_set_flag_(groups, named, 1, TT_SKIP) /** Run a single testcase in a single group. */ int testcase_run_one(const struct testgroup_t *,const struct testcase_t *); void tinytest_set_aliases(const struct testlist_alias_t *aliases); /** Run a set of testcases from an END_OF_GROUPS-terminated array of groups, as selected from the command line. */ int tinytest_main(int argc, const char **argv, struct testgroup_t *groups); #endif axe-0.3.1/tests/tinytest/tinytest_demo.c000066400000000000000000000177371263567001600203750ustar00rootroot00000000000000/* tinytest_demo.c -- Copyright 2009-2012 Nick Mathewson * * 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. */ /* Welcome to the example file for tinytest! I'll show you how to set up * some simple and not-so-simple testcases. */ /* Make sure you include these headers. */ #include "tinytest.h" #include "tinytest_macros.h" #include #include #include #include #include #ifdef _WIN32 #include #else #include #endif /* ============================================================ */ /* First, let's see if strcmp is working. (All your test cases should be * functions declared to take a single void * as an argument.) */ void test_strcmp(void *data) { (void)data; /* This testcase takes no data. */ /* Let's make sure the empty string is equal to itself */ if (strcmp("","")) { /* This macro tells tinytest to stop the current test * and go straight to the "end" label. */ tt_abort_msg("The empty string was not equal to itself"); } /* Pretty often, calling tt_abort_msg to indicate failure is more heavy-weight than you want. Instead, just say: */ tt_assert(strcmp("testcase", "testcase") == 0); /* Occasionally, you don't want to stop the current testcase just because a single assertion has failed. In that case, use tt_want: */ tt_want(strcmp("tinytest", "testcase") > 0); /* You can use the tt_*_op family of macros to compare values and to fail unless they have the relationship you want. They produce more useful output than tt_assert, since they display the actual values of the failing things. Fail unless strcmp("abc, "abc") == 0 */ tt_int_op(strcmp("abc", "abc"), ==, 0); /* Fail unless strcmp("abc, "abcd") is less than 0 */ tt_int_op(strcmp("abc", "abcd"), < , 0); /* Incidentally, there's a test_str_op that uses strcmp internally. */ tt_str_op("abc", <, "abcd"); /* Every test-case function needs to finish with an "end:" label and (optionally) code to clean up local variables. */ end: ; } /* ============================================================ */ /* Now let's mess with setup and teardown functions! These are handy if you have a bunch of tests that all need a similar environment, and you want to reconstruct that environment freshly for each one. */ /* First you declare a type to hold the environment info, and functions to set it up and tear it down. */ struct data_buffer { /* We're just going to have couple of character buffer. Using setup/teardown functions is probably overkill for this case. You could also do file descriptors, complicated handles, temporary files, etc. */ char buffer1[512]; char buffer2[512]; }; /* The setup function needs to take a const struct testcase_t and return void* */ void * setup_data_buffer(const struct testcase_t *testcase) { struct data_buffer *db = malloc(sizeof(struct data_buffer)); /* If you had a complicated set of setup rules, you might behave differently here depending on testcase->flags or testcase->setup_data or even or testcase->name. */ /* Returning a NULL here would mean that we couldn't set up for this test, so we don't need to test db for null. */ return db; } /* The clean function deallocates storage carefully and returns true on success. */ int clean_data_buffer(const struct testcase_t *testcase, void *ptr) { struct data_buffer *db = ptr; if (db) { free(db); return 1; } return 0; } /* Finally, declare a testcase_setup_t with these functions. */ struct testcase_setup_t data_buffer_setup = { setup_data_buffer, clean_data_buffer }; /* Now let's write our test. */ void test_memcpy(void *ptr) { /* This time, we use the argument. */ struct data_buffer *db = ptr; /* We'll also introduce a local variable that might need cleaning up. */ char *mem = NULL; /* Let's make sure that memcpy does what we'd like. */ strcpy(db->buffer1, "String 0"); memcpy(db->buffer2, db->buffer1, sizeof(db->buffer1)); tt_str_op(db->buffer1, ==, db->buffer2); /* tt_mem_op() does a memcmp, as opposed to the strcmp in tt_str_op() */ db->buffer2[100] = 3; /* Make the buffers unequal */ tt_mem_op(db->buffer1, <, db->buffer2, sizeof(db->buffer1)); /* Now we've allocated memory that's referenced by a local variable. The end block of the function will clean it up. */ mem = strdup("Hello world."); tt_assert(mem); /* Another rather trivial test. */ tt_str_op(db->buffer1, !=, mem); end: /* This time our end block has something to do. */ if (mem) free(mem); } void test_timeout(void *ptr) { time_t t1, t2; (void)ptr; t1 = time(NULL); #ifdef _WIN32 Sleep(5000); #else sleep(5); #endif t2 = time(NULL); tt_int_op(t2-t1, >=, 4); tt_int_op(t2-t1, <=, 6); end: ; } /* ============================================================ */ /* Now we need to make sure that our tests get invoked. First, you take a bunch of related tests and put them into an array of struct testcase_t. */ struct testcase_t demo_tests[] = { /* Here's a really simple test: it has a name you can refer to it with, and a function to invoke it. */ { "strcmp", test_strcmp, }, /* The second test has a flag, "TT_FORK", to make it run in a subprocess, and a pointer to the testcase_setup_t that configures its environment. */ { "memcpy", test_memcpy, TT_FORK, &data_buffer_setup }, /* This flag is off-by-default, since it takes a while to run. You * can enable it manually by passing +demo/timeout at the command line.*/ { "timeout", test_timeout, TT_OFF_BY_DEFAULT }, /* The array has to end with END_OF_TESTCASES. */ END_OF_TESTCASES }; /* Next, we make an array of testgroups. This is mandatory. Unlike more heavy-duty testing frameworks, groups can't nest. */ struct testgroup_t groups[] = { /* Every group has a 'prefix', and an array of tests. That's it. */ { "demo/", demo_tests }, END_OF_GROUPS }; /* We can also define test aliases. These can be used for types of tests that * cut across groups. */ const char *alltests[] = { "+..", NULL }; const char *slowtests[] = { "+demo/timeout", NULL }; struct testlist_alias_t aliases[] = { { "ALL", alltests }, { "SLOW", slowtests }, END_OF_ALIASES }; int main(int c, const char **v) { /* Finally, just call tinytest_main(). It lets you specify verbose or quiet output with --verbose and --quiet. You can list specific tests: tinytest-demo demo/memcpy or use a ..-wildcard to select multiple tests with a common prefix: tinytest-demo demo/.. If you list no tests, you get them all by default, so that "tinytest-demo" and "tinytest-demo .." mean the same thing. */ tinytest_set_aliases(aliases); return tinytest_main(c, v, groups); } axe-0.3.1/tests/tinytest/tinytest_macros.h000066400000000000000000000160401263567001600207240ustar00rootroot00000000000000/* tinytest_macros.h -- Copyright 2009-2012 Nick Mathewson * * 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. */ #ifndef TINYTEST_MACROS_H_INCLUDED_ #define TINYTEST_MACROS_H_INCLUDED_ /* Helpers for defining statement-like macros */ #define TT_STMT_BEGIN do { #define TT_STMT_END } while (0) /* Redefine this if your test functions want to abort with something besides * "goto end;" */ #ifndef TT_EXIT_TEST_FUNCTION #define TT_EXIT_TEST_FUNCTION TT_STMT_BEGIN goto end; TT_STMT_END #endif /* Redefine this if you want to note success/failure in some different way. */ #ifndef TT_DECLARE #define TT_DECLARE(prefix, args) \ TT_STMT_BEGIN \ printf("\n %s %s:%d: ",prefix,__FILE__,__LINE__); \ printf args ; \ TT_STMT_END #endif /* Announce a failure. Args are parenthesized printf args. */ #define TT_GRIPE(args) TT_DECLARE("FAIL", args) /* Announce a non-failure if we're verbose. */ #define TT_BLATHER(args) \ TT_STMT_BEGIN \ if (tinytest_get_verbosity_()>1) TT_DECLARE(" OK", args); \ TT_STMT_END #define TT_DIE(args) \ TT_STMT_BEGIN \ tinytest_set_test_failed_(); \ TT_GRIPE(args); \ TT_EXIT_TEST_FUNCTION; \ TT_STMT_END #define TT_FAIL(args) \ TT_STMT_BEGIN \ tinytest_set_test_failed_(); \ TT_GRIPE(args); \ TT_STMT_END /* Fail and abort the current test for the reason in msg */ #define tt_abort_printf(msg) TT_DIE(msg) #define tt_abort_perror(op) TT_DIE(("%s: %s [%d]",(op),strerror(errno), errno)) #define tt_abort_msg(msg) TT_DIE(("%s", msg)) #define tt_abort() TT_DIE(("%s", "(Failed.)")) /* Fail but do not abort the current test for the reason in msg. */ #define tt_failprint_f(msg) TT_FAIL(msg) #define tt_fail_perror(op) TT_FAIL(("%s: %s [%d]",(op),strerror(errno), errno)) #define tt_fail_msg(msg) TT_FAIL(("%s", msg)) #define tt_fail() TT_FAIL(("%s", "(Failed.)")) /* End the current test, and indicate we are skipping it. */ #define tt_skip() \ TT_STMT_BEGIN \ tinytest_set_test_skipped_(); \ TT_EXIT_TEST_FUNCTION; \ TT_STMT_END #define tt_want_(b, msg, fail) \ TT_STMT_BEGIN \ if (!(b)) { \ tinytest_set_test_failed_(); \ TT_GRIPE(("%s",msg)); \ fail; \ } else { \ TT_BLATHER(("%s",msg)); \ } \ TT_STMT_END /* Assert b, but do not stop the test if b fails. Log msg on failure. */ #define tt_want_msg(b, msg) \ tt_want_(b, msg, ); /* Assert b and stop the test if b fails. Log msg on failure. */ #define tt_assert_msg(b, msg) \ tt_want_(b, msg, TT_EXIT_TEST_FUNCTION); /* Assert b, but do not stop the test if b fails. */ #define tt_want(b) tt_want_msg( (b), "want("#b")") /* Assert b, and stop the test if b fails. */ #define tt_assert(b) tt_assert_msg((b), "assert("#b")") #define tt_assert_test_fmt_type(a,b,str_test,type,test,printf_type,printf_fmt, \ setup_block,cleanup_block,die_on_fail) \ TT_STMT_BEGIN \ type val1_ = (a); \ type val2_ = (b); \ int tt_status_ = (test); \ if (!tt_status_ || tinytest_get_verbosity_()>1) { \ printf_type print_; \ printf_type print1_; \ printf_type print2_; \ type value_ = val1_; \ setup_block; \ print1_ = print_; \ value_ = val2_; \ setup_block; \ print2_ = print_; \ TT_DECLARE(tt_status_?" OK":"FAIL", \ ("assert(%s): " printf_fmt " vs " printf_fmt,\ str_test, print1_, print2_)); \ print_ = print1_; \ cleanup_block; \ print_ = print2_; \ cleanup_block; \ if (!tt_status_) { \ tinytest_set_test_failed_(); \ die_on_fail ; \ } \ } \ TT_STMT_END #define tt_assert_test_type(a,b,str_test,type,test,fmt,die_on_fail) \ tt_assert_test_fmt_type(a,b,str_test,type,test,type,fmt, \ {print_=value_;},{},die_on_fail) #define tt_assert_test_type_opt(a,b,str_test,type,test,fmt,die_on_fail) \ tt_assert_test_fmt_type(a,b,str_test,type,test,type,fmt, \ {print_=value_?value_:"";},{},die_on_fail) /* Helper: assert that a op b, when cast to type. Format the values with * printf format fmt on failure. */ #define tt_assert_op_type(a,op,b,type,fmt) \ tt_assert_test_type(a,b,#a" "#op" "#b,type,(val1_ op val2_),fmt, \ TT_EXIT_TEST_FUNCTION) #define tt_int_op(a,op,b) \ tt_assert_test_type(a,b,#a" "#op" "#b,long,(val1_ op val2_), \ "%ld",TT_EXIT_TEST_FUNCTION) #define tt_uint_op(a,op,b) \ tt_assert_test_type(a,b,#a" "#op" "#b,unsigned long, \ (val1_ op val2_),"%lu",TT_EXIT_TEST_FUNCTION) #define tt_ptr_op(a,op,b) \ tt_assert_test_type(a,b,#a" "#op" "#b,const void*, \ (val1_ op val2_),"%p",TT_EXIT_TEST_FUNCTION) #define tt_str_op(a,op,b) \ tt_assert_test_type_opt(a,b,#a" "#op" "#b,const char *, \ (val1_ && val2_ && strcmp(val1_,val2_) op 0),"<%s>", \ TT_EXIT_TEST_FUNCTION) #define tt_mem_op(expr1, op, expr2, len) \ tt_assert_test_fmt_type(expr1,expr2,#expr1" "#op" "#expr2, \ const void *, \ (val1_ && val2_ && memcmp(val1_, val2_, len) op 0), \ char *, "%s", \ { print_ = tinytest_format_hex_(value_, (len)); }, \ { if (print_) free(print_); }, \ TT_EXIT_TEST_FUNCTION \ ); #define tt_want_int_op(a,op,b) \ tt_assert_test_type(a,b,#a" "#op" "#b,long,(val1_ op val2_),"%ld",(void)0) #define tt_want_uint_op(a,op,b) \ tt_assert_test_type(a,b,#a" "#op" "#b,unsigned long, \ (val1_ op val2_),"%lu",(void)0) #define tt_want_ptr_op(a,op,b) \ tt_assert_test_type(a,b,#a" "#op" "#b,const void*, \ (val1_ op val2_),"%p",(void)0) #define tt_want_str_op(a,op,b) \ tt_assert_test_type(a,b,#a" "#op" "#b,const char *, \ (strcmp(val1_,val2_) op 0),"<%s>",(void)0) #endif axe-0.3.1/utils/000077500000000000000000000000001263567001600134365ustar00rootroot00000000000000axe-0.3.1/utils/make-tarball.sh000066400000000000000000000006151263567001600163300ustar00rootroot00000000000000#!/bin/bash version=$1 git tag -v "$version" if [ $? -ne 0 ] then echo "Invalid tag: $version" exit 1 fi set -xe rm -f ../axe_${version}.orig.tar* git archive -o ../axe_${version}.orig.tar $version tar -rf ../axe_${version}.orig.tar --owner=0 --group=0 src/libqes/ tar --delete -vf ../axe_${version}.orig.tar .gitmodules src/libqes/.gitmodules src/libqes/.git xz ../axe_${version}.orig.tar