1,652 research outputs found
User-defined data types and operators in occam
This paper describes the addition of user-defined monadic and dyadic operators to occam* [1], together with some libraries that demonstrate their use. It also discusses some techniques used in their implementation in KRoC [2] for a variety of target machines
PASCAL/48 reference manual
PASCAL/48 is a programming language for the Intel MCS-48 series of microcomputers. In particular, it can be used with the Intel 8748. It is designed to allow the programmer to control most of the instructions being generated and the allocation of storage. The language can be used instead of ASSEMBLY language in most applications while allowing the user the necessary degree of control over hardware resources. Although it is called PASCAL/48, the language differs in many ways from PASCAL. The program structure and statements of the two languages are similar, but the expression mechanism and data types are different. The PASCAL/48 cross-compiler is written in PASCAL and runs on the CDC CYBER NOS system. It generates object code in Intel hexadecimal format that can be used to program the MCS-48 series of microcomputers. This reference manual defines the language, describes the predeclared procedures, lists error messages, illustrates use, and includes language syntax diagrams
Manipulation of expressions in a relational algebra
This paper describes a syntax for expressions based on the relational algebra. A tree representation is generated when an expression is analyzed. Transformations on the tree representations of expressions are applied in order to obtain improvements with respect to the speed of evaluation in a data base environment
Type classes for efficient exact real arithmetic in Coq
Floating point operations are fast, but require continuous effort on the part
of the user in order to ensure that the results are correct. This burden can be
shifted away from the user by providing a library of exact analysis in which
the computer handles the error estimates. Previously, we [Krebbers/Spitters
2011] provided a fast implementation of the exact real numbers in the Coq proof
assistant. Our implementation improved on an earlier implementation by O'Connor
by using type classes to describe an abstract specification of the underlying
dense set from which the real numbers are built. In particular, we used dyadic
rationals built from Coq's machine integers to obtain a 100 times speed up of
the basic operations already. This article is a substantially expanded version
of [Krebbers/Spitters 2011] in which the implementation is extended in the
various ways. First, we implement and verify the sine and cosine function.
Secondly, we create an additional implementation of the dense set based on
Coq's fast rational numbers. Thirdly, we extend the hierarchy to capture order
on undecidable structures, while it was limited to decidable structures before.
This hierarchy, based on type classes, allows us to share theory on the
naturals, integers, rationals, dyadics, and reals in a convenient way. Finally,
we obtain another dramatic speed-up by avoiding evaluation of termination
proofs at runtime.Comment: arXiv admin note: text overlap with arXiv:1105.275
A C++11 implementation of arbitrary-rank tensors for high-performance computing
This article discusses an efficient implementation of tensors of arbitrary
rank by using some of the idioms introduced by the recently published C++ ISO
Standard (C++11). With the aims at providing a basic building block for
high-performance computing, a single Array class template is carefully crafted,
from which vectors, matrices, and even higher-order tensors can be created. An
expression template facility is also built around the array class template to
provide convenient mathematical syntax. As a result, by using templates, an
extra high-level layer is added to the C++ language when dealing with algebraic
objects and their operations, without compromising performance. The
implementation is tested running on both CPU and GPU.Comment: 21 pages, 6 figures, 1 tabl
Visual Programming Language for Tacit Subset of J Programming Language
Visual programming is the idea of using graphical icons to create programs. I take a look at available solutions and challenges facing visual languages. Keeping these challenges in mind, I measure the suitability of Blockly and highlight the advantages of using Blockly for creating a visual programming environment for the J programming language. Blockly is an open source general purpose visual programming language designed by Google which provides a wide range of features and is meant to be customized to the user’s needs. I also discuss features of the J programming language that make it suitable for use in visual programming language. The result is a visual programming environment for the tacit subset of the J programming language
JMSL - a language derived from APL
A new AFL-derived language called JMSL is presented which rnodifies seven aspects of APL so that many current and potential APL users could benefit from a language which is easier to learn, read, write, and maintain. JMSL uses ASCII tokens instead of APL symbols to remedy interfacing, extensibility, and readability problems with APL. JMSL revises and extends APL built-in capabilities to provide greater expression and improved symbol-meaning correspondence. JMSL includes a new notation for nested arrays (a powerful data structure which combines the array processing of APL with the tree processing of LISP). JMSL provides hierarchical directories (similar to PASCAL or PL/I records) to allow structures to be indexed by name. JMSL modifies the traditional APL library/workspace storage interface by unifying the syntax of system commands in a way which allows UNIX-like directory storage. JMSL provides high-level control structures similar to those found in block-structured languages, including an event-handling mechanism. JMSL amends the APL scope rules to alleviate problems with side effects and object localization. Some areas of future work are discussed, and a description of JMSL syntax and semantics is included
Type inference for linear algebra with units of measurement
Refining types of numerical data with units of measurement has the potential
to increase safety of programming languages but is restricted to homogeneous
units when checked statically with parametric polymorphism. We lift units to
vectors and show how type inference of linear algebra expressions can statically
determine safety for data with heterogeneous units. The typing is based on
the dyadic product of units that is found in linear transformations and the
corresponding vector spaces. Since it is a refinement of Kennedy’s types for
units we automatically obtain a unification algorithm, which gives principal
types for linear algebra. The extension of unit-unification to numerical data with
heterogeneous units makes the safety of statically checked numerical expressions
available to a significantly larger set of use-cases
Harnessing Higher-Order (Meta-)Logic to Represent and Reason with Complex Ethical Theories
The computer-mechanization of an ambitious explicit ethical theory, Gewirth's
Principle of Generic Consistency, is used to showcase an approach for
representing and reasoning with ethical theories exhibiting complex logical
features like alethic and deontic modalities, indexicals, higher-order
quantification, among others. Harnessing the high expressive power of Church's
type theory as a meta-logic to semantically embed a combination of quantified
non-classical logics, our work pushes existing boundaries in knowledge
representation and reasoning. We demonstrate that intuitive encodings of
complex ethical theories and their automation on the computer are no longer
antipodes.Comment: 14 page
Designing Normative Theories for Ethical and Legal Reasoning: LogiKEy Framework, Methodology, and Tool Support
A framework and methodology---termed LogiKEy---for the design and engineering
of ethical reasoners, normative theories and deontic logics is presented. The
overall motivation is the development of suitable means for the control and
governance of intelligent autonomous systems. LogiKEy's unifying formal
framework is based on semantical embeddings of deontic logics, logic
combinations and ethico-legal domain theories in expressive classic
higher-order logic (HOL). This meta-logical approach enables the provision of
powerful tool support in LogiKEy: off-the-shelf theorem provers and model
finders for HOL are assisting the LogiKEy designer of ethical intelligent
agents to flexibly experiment with underlying logics and their combinations,
with ethico-legal domain theories, and with concrete examples---all at the same
time. Continuous improvements of these off-the-shelf provers, without further
ado, leverage the reasoning performance in LogiKEy. Case studies, in which the
LogiKEy framework and methodology has been applied and tested, give evidence
that HOL's undecidability often does not hinder efficient experimentation.Comment: 50 pages; 10 figure
- …