Download JAR files tagged by using with all dependencies

Randoop is an automatic unit test generator for Java. It automatically creates unit tests for your classes, in JUnit format. Randoop generates unit tests using feedback-directed random test generation. In a nutshell, this technique randomly, but smartly, generates sequences of methods and constructor invocations for the classes under test, and uses the sequences to create tests. Randoop executes the sequences it creates, using the results of the execution to create assertions that capture the behavior or your program and that catch bugs. Randoop has created tests that find previously unkwon errors even in widely-used libraries including Sun and IBM's JDKs. A .NET version of Randoop, used internally at Microsoft, has been used successfully by a team of test engineers to find errors in a core .NET component that has been heavily tested for years. Randoop's combination of randomized test generation and test execution results in a highly effective test generation technique.

Sirix is a versioned, treebased storage system. It provides an ID-less diff-algorithm to import differences between two versions. Furthermore an ID-based diff-algorithm facilitates the comparison of versions stored within Sirix. A GUI with several visualizations for comparing these versions visually is available to aid an analyst. Versions are stored using well known versioning strategies (full, incremental, differential). The architecture is especially well suited for flash-disks because of a COW-principle. In the future we aim to provide throughout security as well as a replaced page-structure to speedup our architecture. A brackit(.org) binding will enable XQuery and the XQuery Update Facility. Temporal XPath axis and possibly diff-functions will help analysts to gain quick knowledge from the stored data.

Sirix is a versioned, treebased storage system. It provides an ID-less diff-algorithm to import differences between two versions (currently XML-documents). Furthermore an ID-based diff-algorithm facilitates the comparison of versions stored within Sirix. A GUI with several visualizations for comparing these versions visually is available to aid an analyst. Versions are stored using well known versioning strategies (full, incremental, differential). The architecture is especially well suited for flash-disks because of a COW-principle. In the future we aim to provide throughout security as well as a replaced page-structure to speedup our architecture. A brackit(.org) binding will enable XQuery and the XQuery Update Facility. Temporal XPath axis and possibly diff-functions will help analysts to gain quick knowledge from the stored data.

Class for building pace regression linear models and using them for prediction. Under regularity conditions, pace regression is provably optimal when the number of coefficients tends to infinity. It consists of a group of estimators that are either overall optimal or optimal under certain conditions. The current work of the pace regression theory, and therefore also this implementation, do not handle: - missing values - non-binary nominal attributes - the case that n - k is small where n is the number of instances and k is the number of coefficients (the threshold used in this implmentation is 20) For more information see: Wang, Y (2000). A new approach to fitting linear models in high dimensional spaces. Hamilton, New Zealand. Wang, Y., Witten, I. H.: Modeling for optimal probability prediction. In: Proceedings of the Nineteenth International Conference in Machine Learning, Sydney, Australia, 650-657, 2002.

Module that defines the HttpChannel API. HttpChannels abstract complex download and upload steps into a simple and easy to use NIO Channel. NIO Channels can be wrapped into an InputStream or OutputStream and used in any way you may find possible to. Aside from that, Channels can be used natively in most next-gen libraries, meaning that you don't even need to wrap anything, just start writing or reading data to or from the channel wth a ByteBuffer. Anyone using the library should try to rely on code from this module only and, only if necessary, on configuration classes that are implementation specific. Relying on any other resource or class is considered an error and should NOT be done. One of the most interesting usages of channels for uploads and download is that you can easily copy data straight from one channel to the other, with less than 10 lines of code! Also, channels allows the implementation of a "tee" mechanism, in which data redden from a single channel can be copied to several other channels on the fly!

The boilerpipe library provides algorithms to detect and remove the surplus "clutter" (boilerplate, templates) around the main textual content of a web page. The library already provides specific strategies for common tasks (for example: news article extraction) and may also be easily extended for individual problem settings. Extracting content is very fast (milliseconds), just needs the input document (no global or site-level information required) and is usually quite accurate. Boilerpipe is a Java library written by Christian Kohlschütter. It is released under the Apache License 2.0. The algorithms used by the library are based on (and extending) some concepts of the paper "Boilerplate Detection using Shallow Text Features" by Christian Kohlschütter et al., presented at WSDM 2010 -- The Third ACM International Conference on Web Search and Data Mining New York City, NY USA.

[](https://drone.io/bitbucket.org/tidalwave/tidalwave-superpom-src/latest) The super POM for all Tidalwave projects. It is not designed for being used by others, as it contains some corporate-specific configurations, but its ancestor [TheseFooolishThings SuperPOM](http://bitbucket.org/tidalwave/thesefoolishthings-superpom-src) has been designed to be reusable. Please have a look at it. This super POM adds to its ancestor: + some Tidalwave variables that refers to the issue tracker, continuous integration system, etc...; + the definitions of versions of a number of commonly used libraries and their dependency management: * [AspectJ](https://www.eclipse.org/aspectj) * [Hamcrest Matchers](http://hamcrest.org/JavaHamcrest) * [JSR 330](https://github.com/google/guice/wiki/JSR330) * [Jakarta XML Binding (JAXB)](https://eclipse-ee4j.github.io/jaxb-ri/) * [Spotbugs annotations](https://spotbugs.readthedocs.io) * [JUnit](https://junit.org/junit5) * [Logback](http://logback.qos.ch) * [Lombok](https://projectlombok.org) * [SLF4J](slf4j.org) * [Spring 5](https://spring.io/projects/spring-framework) * [TestNG](https://testng.org) + the definition for Tidalwave 3rd party repository (stuff that is not available on Maven Central); + a profile for using the [TheseFoolishThings](http://tidalwave.it/projects/thesefoolishthings) Event Bus (```it.tidalwave-spring-messagebus-v1```); + profiles for the [Mycila License plugin](https://github.com/mycila/license-maven-plugin); + configuration of the UMLGraphDoc maven plugin; + the configuration for the TheseFoolishThings TestNG listener (which provides enhanced test logging); + definitions of some custom javadoc tags; + a blacklist for some old artifacts; + some other minor customisations.

Xerces2 is the next generation of high performance, fully compliant XML parsers in the Apache Xerces family. This new version of Xerces introduces the Xerces Native Interface (XNI), a complete framework for building parser components and configurations that is extremely modular and easy to program. The Apache Xerces2 parser is the reference implementation of XNI but other parser components, configurations, and parsers can be written using the Xerces Native Interface. For complete design and implementation documents, refer to the XNI Manual. Xerces2 is a fully conforming XML Schema 1.0 processor. A partial experimental implementation of the XML Schema 1.1 Structures and Datatypes Working Drafts (December 2009) and an experimental implementation of the XML Schema Definition Language (XSD): Component Designators (SCD) Candidate Recommendation (January 2010) are provided for evaluation. For more information, refer to the XML Schema page. Xerces2 also provides a complete implementation of the Document Object Model Level 3 Core and Load/Save W3C Recommendations and provides a complete implementation of the XML Inclusions (XInclude) W3C Recommendation. It also provides support for OASIS XML Catalogs v1.1. Xerces2 is able to parse documents written according to the XML 1.1 Recommendation, except that it does not yet provide an option to enable normalization checking as described in section 2.13 of this specification. It also handles namespaces according to the XML Namespaces 1.1 Recommendation, and will correctly serialize XML 1.1 documents if the DOM level 3 load/save APIs are in use.

Java Prolog Interface (JPI) is an Application Provider Interface (API) for interaction between Java and Prolog programming languages. Is a bidirectional interface that communicate Java applications with Prolog program or database and Prolog procedures with Java class and methods. JPI is an abstraction layer over concrete prolog drivers over Prolog Engines. This API define all mechanism to interact with any Prolog Engine and maintain the application independent to a specific underlying engine. JPI have several connectors to open source prolog engines like SWI, YAP, XSB native engines and tuProlog, jTrolog, jLog Java based prolog engines. JPI study all related Java-Prolog integration libraries and take the betters features from each solution with the propose to achieve a common integration interface. The last feature allows switch the under laying Prolog Engine driver and the application code still be the same. JPI run over any Java Virtual Machine that support Java SE 5 or above. The project was tested over HotSpot, Open J9 and JRockit Virtual Machines over Operating Systems like Windows (7,8,10), Linux (Debian, Ubuntu) and Mac OS X. Can be deployed on Servlets Containers like Jetty, Tomcat or Glassfish Application Server. JPI can be include in any Java Project using the commonest Java Integration Development Enviroment (IDE) like Eclipse, Netbeans, IntelijIDEA and so on. JPI is developed and maintained by Prolobjectlink Project an open source initiative for build logic based applications using Prolog like fundamental Logic Programming Language in the persistence layer and application programming.

The IntelligentGraph SAIL offers an extended capability for embedded calculation support within any RDF graph. When enabled as an RDF4J SAIL, it offers calculation functionality as part of the RDF4J engine, on top of any RDF4J repository, using a variety of script engines including JavaScript, Jython, and Groovy. It preserves the SPARQL capability of RDF4J, but with additional capabilities for calculation debugging and tracing. IntelligentGraph includes the PathQL query language. Just as a spreadsheet cell calculation needs to access other cells, an IntelligentGraph calculation needs to access other nodes within the graph. Although full access to the underlying graph is available to any of the scripts, PathQL provides a succinct, and efficient method to access directly or indirectly related nodes. PathQL can either return just the contents of the referenced nodes, or the contents and the path to the referenced nodes. PathQL can also be used standalone to query the IntelligentGraph-enabled RDF database. This supplements, rather than replaces, SPARQL and GraphQL, as it provides graph-path querying rather than graph-pattern querying capabilities to any IntelligentGraph-enabled RDF database. The principles of IntelligentGraph are described here: https://inova8.com/bg_inova8.com/intelligent-graph-knowledge-graph-embedded-analysis/ The full PathQL syntax is described here: https://inova8.com/bg_inova8.com/pathpatternql-intelligently-finding-knowledge-as-a-path-through-a-maze-of-facts/ Using Jupyter as an IDE to IntelligentGraph and RDF4J, shown here: https://inova8.com/bg_inova8.com/intelligentgraph-getting-started/ IntelligentGraph source is here in GitHub: https://github.com/peterjohnlawrence/com.inova8.intelligentgraph IntelligentGraph Docker containers are available here: https://hub.docker.com/repository/docker/inova8/intelligentgraph