Narrow Results

We show how SymbolicC++, a symbolic and numeric computer algebra system written in C++, can be used to find exact solutions of soliton equations in (2+1)-dimensions.

This paper improves the breadth-first search strategy in directed automated random testing (DART) to generate a fewer number of test data while gaining higher branch coverage, namely Static DART or SDART for short. In addition, the paper extends the test data compilation mechanism in DART, which currently only supports the projects written in C, to generate test data for C++ projects. The main idea of SDART is when it is less likely to increase code coverage with the current path selection strategies, the static test data generation will be applied with the expectation that more branches are covered earlier. Furthermore, in order to extend the test data compilation of DART for C++ context, the paper suggests a general test driver technique for C++ which supports various types of parameters including basic types, arrays, pointers, and derived types. Currently, an experimental tool has been implemented based on the proposal in order to demonstrate its efficacy in practice. The results have shown that SDART achieves higher branch coverage with a fewer number of test data in comparison with that of DART in practice.

Background: The current primary focus of programming language benchmarking studies in the literature is performance with less attention on safety. However, this context has a research gap because the software industry has focused more on software safety than performance to safeguard clients. This paper attempts to address this research gap by benchmarking languages in both safety and performance. Furthermore, this study includes Rust, a relatively new language with promising safety and performance features. Methods: This paper compares six prominent programming languages (in alphabetical order: C, C$++$, Go, Java, Python and Rust) to determine which is the best in terms of safety and performance using quantitative and qualitative methods through actual testing of code and analysis of existing information. Results: The comparisons show that Rust was the safest language, outperforming all the other languages. Regarding performance, Rust, C and C$++$ performed comparably to each other and generally outperformed Go, Java and Python. Conclusion: It is possible to achieve a superior balance of software safety and performance with, at worst, a minimal performance drop; as Rust clearly demonstrates.

Automatic code generation plays an important role in ensuring the reliability and correctness of software programs. Reliable programs can be obtained automatically from verified program specifications by code generators. The target languages of the existing code generators are mainly functional languages, which are relatively less used than C/C$++$. As C/C$++$ is widely used in the industry and many fundamental software facilities and the correctness verification of C/C$++$ programs is difficult and cumbersome, this paper provides an automatic conversion framework that allows to generate C$++$ implementation from verified Isabelle/HOL specifications. The framework is characterized by combining the verification convenience of Isabelle/HOL and the efficiency of C$++$. Since the correctness of the functional Isabelle/HOL specification can be guaranteed by interactive proofs, the correctness of the relevant generated C$++$ implementation can also be maintained.

Most the execution environments, having been derived from LISP, inference on internally defined data-types and come packaged with stand-alone development environments. Data derived from outside these systems must be reformatted before it can be evaluated. This mismatch leads to a duplicate representation of data, which, in turn, introduces both performance and semantic problems.

This paper describes a C₊₊ Embeddable Rule System (CERS) which avoids this mismatch. CERS is a compiled, forward-chaining rule system that inferences directly on arbitrary C₊₊ objects. CERS can be viewed as an extension of C₊₊, where the methods associated with a ruleset class can be defined either procedurally or declaratively. CERS is unique in that rules may match against and manipulate arbitrary, user-defined C₊₊ objects. There is no requirement that the developer anticipated using CERS when defining the class. Thus CERS rules can inference over data objects instantiated in persistent object stores and third-party. C₊₊ abstract data-type libraries.

We discuss the infinitesimal bending of curves and knots in ${{ℛ}}^3$. A brief overview of the results on the infinitesimal bending of curves is outlined. Change of the Willmore energy, as well as of the Möbius energy under infinitesimal bending of knots is considered. Our visualization tool devoted to visual representation of infinitesimal bending of knots is presented.

This paper presents a matrix–vector computational library written in the C++ language. Effective matrix–vector manipulation is an essential aspect of scientific numerical modeling, especially while using the finite element method. Even though there are a lot of matrix libraries written in C++ which are freely or commercially available on the Internet, most of them are either too complicated or too simple, i.e. with very limited capabilities. Therefore, the main idea is to develop a reliable matrix library, as part of the computer code in C++, which will be, at the same time, as simple as possible and as complex as possible. Consequently, the basic motto of the library, which is called SMV++, is "Simple and effective" and it is meant to be of use to researchers dedicated to reliable obtained results and not to the "beauty of programming." The library is developed without use of the template concept and inheritance, with the purpose of understanding it easily and of extending it easily with new possibilities and algorithms. Last but not least, it is aimed at having a simple and intuitive user interface. The bottom line is that the SMV++ is not meant to be of use to someone who is in the software development business. Rather, it is oriented to the user who has a modest programming knowledge (e.g. a Ph.D. student) and who is basically concerned about how to obtain the solution to the considered problem, for which he has to do some "homemade programming," because the available commercial software cannot be applied for all of his/her needs. Consequently, as mentioned, the motto of the library is "Simple and effective"; the effectiveness is in the sense of complexity of possibilities, rather than computational efficiency. However, if one is forced to choose between the two in the development of the library, having in mind the target users, priority is given to simplicity of use.

Robots are given more and more challenging tasks in domains such as transport and delivery, farming or health. Software is a key component for robots, and Robot Operating System (ROS) is a popular open-source middleware for writing robotics applications. Code quality matters a lot because a poorly written software is much more likely to contain bugs and will be harder to maintain over time. Within a code base, finding faulty patterns takes a lot of time and money. We propose a framework to search automatically user-provided faulty code patterns. This framework is based on $F{O}^{++}$, a temporal extension of first-order logic, and Pangolin, a verification engine for C$++$ programs. We formalized with $F{O}^{++}$ five faulty patterns related to ROS and embedded systems. We analyzed with Pangolin 25 ROS packages looking for occurrences of these patterns and found a total of 218 defects. To prevent the faulty patterns from arising in new ROS packages, we propose a design pattern, and we show how Pangolin can be used to enforce it.

Robots are given more and more challenging tasks in domains such as transport and delivery, farming or health. Software is a key component for robots, and Robot Operating System (ROS) is a popular open-source middleware for writing robotics applications. Code quality matters a lot because a poorly written software is much more likely to contain bugs and will be harder to maintain over time. Within a code base, finding faulty patterns takes a lot of time and money. We propose a framework to search automatically user-provided faulty code patterns. This framework is based on FO⁺⁺, a temporal extension of first-order logic, and Pangolin, a verification engine for C++ programs. We formalized with FO⁺⁺ five faulty patterns related to ROS and embedded systems. We analyzed with Pangolin 25 ROS packages looking for occurrences of these patterns and found a total of 218 defects. To prevent the faulty patterns from arising in new ROS packages, we propose a design pattern, and we show how Pangolin can be used to enforce it.

Chains of the CME Group Time and Sales E-mini S&P 500 futures tick prices and their a-b-c-d-increments are studied. A discrete probability distribution based on the Hurwitz zeta function and Dirichlet series is suggested for the price increments. The randomness of the ticks is discussed using the notions of typicalness, chaoticness, and stochasticness introduced by Kolmogorov and Uspenskii and developed by predecessors, them, and pupils. They define randomness in terms of the theory of algorithms.