JGraphT -- A Java library for graph data structures and algorithms

Mathematical software and graph-theoretical algorithmic packages to efficiently model, analyze and query graphs are crucial in an era where large-scale spatial, societal and economic network data are abundantly available. One such package is JGraphT, a programming library which contains very efficient and generic graph data-structures along with a large collection of state-of-the-art algorithms. The library is written in Java with stability, interoperability and performance in mind. A distinctive feature of this library is the ability to model vertices and edges as arbitrary objects, thereby permitting natural representations of many common networks including transportation, social and biological networks. Besides classic graph algorithms such as shortest-paths and spanning-tree algorithms, the library contains numerous advanced algorithms: graph and subgraph isomorphism; matching and flow problems; approximation algorithms for NP-hard problems such as independent set and TSP; and several more exotic algorithms such as Berge graph detection. Due to its versatility and generic design, JGraphT is currently used in large-scale commercial, non-commercial and academic research projects. In this work we describe in detail the design and underlying structure of the library, and discuss its most important features and algorithms. A computational study is conducted to evaluate the performance of JGraphT versus a number of similar libraries. Experiments on a large number of graphs over a variety of popular algorithms show that JGraphT is highly competitive with other established libraries such as NetworkX or the BGL.Comment: Major Revisio

Efficient data structures for backtrack search SAT solvers

The implementation of efficient Propositional Satisfiability (SAT) solvers entails the utilization of highly efficient data structures, as illustrated by most of the recent state-of-the-art SAT solvers. However, it is in general hard to compare existing data structures, since different solvers are often characterized by fairly different algorithmic organizations and techniques, and by different search strategies and heuristics. This paper aims the evaluation of data structures for backtrack search SAT solvers, under a common unbiased SAT framework. In addition, advantages and drawbacks of each existing data structure are identified. Finally, new data structures are proposed, that are competitive with the most efficient data structures currently available, and that may be preferable for the next generation SAT solvers

Monitoring Java Programs with Java PathExplorer

AbstractWe present recent work on the development of Java PathExplorer (JPaX), a tool for monitoring the execution of Java programs. JPaX can be used during program testing to gain increased information about program executions, and can potentially furthermore be applied during operation to survey safety critical systems. The tool facilitates automated instrumentation of a program's byte code, which will then emit events to an observer during its execution. The observer checks the events against user provided high level requirement specifications, for example temporal logic formulae, and against lower level error detection procedures, usually concurrency related such as deadlock and data race algorithms. High level requirement specifications together with their underlying logics are defined in rewriting logic using Maude, and then can either be directly checked using Maude rewriting engine, or be first translated to efficient data structures and then checked in Java

Sorting Algorithms in MOQA

AbstractA high-level overview of the MOQA language is presented. The representation of its data structure, a labeled series-parallel partial order, is shown along with some of the functions allowed upon this data structure. The combination of MOQA's data structure and its functions capture the required calculus to statically obtain the average-case time of algorithms written in this language. The implementation of these concepts is discussed and algorithms written in this implementation are presented. A detailed analysis of one of these implemented algorithms, quicksort, critically compares its average-case time in MOQA against the average-case time of standard quicksort. While the asymptotic average of quicksort in MOQA remains unchanged, extra constant costs are incurred by the MOQA method. It is shown that these costs result from molding the algorithm around the MOQA data structure and functions versus the general approach of choosing the data structure and functions that best match the algorithm. This limitation is balanced against an approach that aims to obtain the average-case time of algorithms statically

Classifying and recognizing students' sorting algorithm implementations in a data structures and algorithms course

We discuss an instrument for recognizing and classifying algorithms (Aari) in terms of whiteboxtesting. We examined freshmen students' sorting algorithm implementations in a datastructures and algorithms course in two rounds: at the beginning of the course before thestudents received any instruction on sorting algorithms, and after taking lectures on sortingalgorithms. We evaluated the performance of Aari with the implementations of each roundseparately. The results show that the sorting algorithms (in Java), which Aari has been trainedto recognize (Insertion sort, Selection sort, Bubble sort, Quicksort and Mergesort), arerecognized with an average accuracy of about 90%. When considering all the submitted sortingalgorithm implementations (including the variations of the standard algorithms), Aari achievedan overall accuracy being 71% and 81% for the first and second round, respectively. The manual analysis of the implementations revealed that students have manymisconceptions related to sorting algorithms. For example, they include unnecessary swaps intheir Insertion or Selection sort implementations. Based on the data, we present acategorization of these types of variations. We also discuss how these categories can be used toimprove education of sorting methods, and to further develop Aari as a white-box testing tool,which gives feedback to the students on their inappropriate solutions and asks them to correctthe problem; something black-box testing is not capable of doing

A friendly notebook on Data Structures and Algorithms

The purpose of this document is to provide study material that can be used for independent study by the students of the subject ’Data Structures and Algorithms’. We have tried to write it in a student-friendly way that encourages students to learn as well as enjoy. The document reviews the main concepts of the subject providing clear examples to help students. Each chapter also proposes a set of exercises to reinforce students’ knowledge

Verifying algorithms and data structures in Dafny

Trabajo de Fin de Grado en Ingeniería Informática y Matemáticas (Universidad Complutense, Facultad de Informática, curso 2015/2016)La verificación formal de un programa es la demostración de que este funciona de acuerdo a una descripción del comportamiento esperado en toda posible ejecución. La especificación de lo deseado puede utilizar técnicas diversas y entrar en mayor o menor detalle, pero para ganarse el título de formal esta ha de ser matemáticamente rigurosa. El estudio y ejercicio manual de alguna de esas técnicas forma parte del currículo común a los estudios de grado de la Facultad de Informática y del itinerario de Ciencias de la Computación de la Facultad de Ciencias Matemáticas de la Universidad Complutense de Madrid, como es el caso de la verificación con pre- y postcondiciones o lógica de Hoare. En el presente trabajo se explora la automatización de estos métodos mediante el lenguaje y verificador Dafny, con el que se especifican y verifican algoritmos y estructuras de datos de diversa complejidad. Dafny es un lenguaje de programación diseñado para integrar la especificación y permitir la verificación automática de sus programas, con la ayuda del programador y de un demostrador de teoremas en la sombra. Dafny es un proyecto en desarrollo activo aunque suficientemente maduro, que genera programas ejecutables.The formal verification of a program is the proof that it works according to a description of its expected behaviour in any possible execution. The specification of what is desired can use different techniques and go into more or less detail, but to win the formal title it must be mathematically rigorous. The study and manual exercise of some of those techniques is part of the common curriculum of the degree studies at the School of Computer Science and of the Computer Science itinerary at the School of Mathematics at the Universidad Complutense de Madrid, such as verification with pre- and postconditions or Hoare logic. In the current work, the automation of those methods is explored through the language and verifier Dafny, with has been used to specify and verify some algorithms and data structures of diverse complexity. Dafny is a programming language designed to integrate specification and allow automatic verification of its programs, with the help of the programmer and a theorem prover in the shade. Dafny is in active development but mature enough and it generates executable programs.Depto. de Sistemas Informáticos y ComputaciónFac. de InformáticaTRUEunpu

Patenting Computer Data Structures: The Ghost, the Machine and the Federal Circuit

Courts view data structures, the mechanism by which computers store data in meaningful relationships, differently than do computer scientists. While computer scientists recognize that data structures have aspects that are both physical (how they are stored in memory) and logical (the relationships among the stored information), the Federal Circuit, in its attempts to set clear standards of the scope of patentability of data structures, has not fully appreciated their dualistic nature. This i-brief explains what data structures are, explores how courts have wrestled with setting a limiting principle to determine their patentability, and discusses the resultant impact on claim drafting

Using i* to describe data structures

This paper explores the use of the i* language as a notation to describe data structures to be used in classical imperative programs written in e.g. Java or C#. Data structures are described at two levels of abstraction, their specification and their implementation (the data structure properly said). We analyze how iStar 2.0, enriched with both modularization and dependum specialization constructs, can be used in this context.Peer ReviewedPostprint (published version