219,501 research outputs found
Shuffle on array languages generated by array grammars
Motivated by the studies done by G. Siromoney et al. (1973) and Alexan-
dru Mateescu et al. (1998) we examine the language theoretic results related to shuf- fle on trajectories by making use of Siromoney array grammars such as (R : R)AG, (R : C F )AG, (C F : R)AG, (C F : C F )AG, (C S : R)AG, (C S : C S)AG and (C F : C S)AG which are more powerful than the Siromoney matrix grammars (1972)
and are used to make digital pictures
Loo.py: From Fortran to performance via transformation and substitution rules
A large amount of numerically-oriented code is written and is being written
in legacy languages. Much of this code could, in principle, make good use of
data-parallel throughput-oriented computer architectures. Loo.py, a
transformation-based programming system targeted at GPUs and general
data-parallel architectures, provides a mechanism for user-controlled
transformation of array programs. This transformation capability is designed to
not just apply to programs written specifically for Loo.py, but also those
imported from other languages such as Fortran. It eases the trade-off between
achieving high performance, portability, and programmability by allowing the
user to apply a large and growing family of transformations to an input
program. These transformations are expressed in and used from Python and may be
applied from a variety of settings, including a pragma-like manner from other
languages.Comment: ARRAY 2015 - 2nd ACM SIGPLAN International Workshop on Libraries,
Languages and Compilers for Array Programming (ARRAY 2015
Array languages and the N-body problem
This paper is a description of the contributions to the SICSA multicore challenge on many body
planetary simulation made by a compiler group at the University of Glasgow. Our group is part of
the Computer Vision and Graphics research group and we have for some years been developing array
compilers because we think these are a good tool both for expressing graphics algorithms and for
exploiting the parallelism that computer vision applications require.
We shall describe experiments using two languages on two different platforms and we shall compare
the performance of these with reference C implementations running on the same platforms. Finally
we shall draw conclusions both about the viability of the array language approach as compared to
other approaches used in the challenge and also about the strengths and weaknesses of the two, very
different, processor architectures we used
A machine vision extension for the Ruby programming language
Dynamically typed scripting languages have become popular in recent years. Although interpreted languages allow for substantial reduction of software development time, they are often rejected due to performance concerns.
In this paper we present an extension for the programming
language Ruby, called HornetsEye, which facilitates the development
of real-time machine vision algorithms within Ruby. Apart from providing integration of crucial libraries for input and output, HornetsEye provides fast native implementations (compiled code) for a generic set of array operators. Different array operators were compared with equivalent implementations in C++. Not only was it possible to achieve comparable real-time performance, but also to exceed the efficiency of the C++ implementation in several cases.
Implementations of several algorithms were given to demonstrate
how the array operators can be used to create concise
implementations.</p
Array operators using multiple dispatch: a design methodology for array implementations in dynamic languages
Arrays are such a rich and fundamental data type that they tend to be built
into a language, either in the compiler or in a large low-level library.
Defining this functionality at the user level instead provides greater
flexibility for application domains not envisioned by the language designer.
Only a few languages, such as C++ and Haskell, provide the necessary power to
define -dimensional arrays, but these systems rely on compile-time
abstraction, sacrificing some flexibility. In contrast, dynamic languages make
it straightforward for the user to define any behavior they might want, but at
the possible expense of performance.
As part of the Julia language project, we have developed an approach that
yields a novel trade-off between flexibility and compile-time analysis. The
core abstraction we use is multiple dispatch. We have come to believe that
while multiple dispatch has not been especially popular in most kinds of
programming, technical computing is its killer application. By expressing key
functions such as array indexing using multi-method signatures, a surprising
range of behaviors can be obtained, in a way that is both relatively easy to
write and amenable to compiler analysis. The compact factoring of concerns
provided by these methods makes it easier for user-defined types to behave
consistently with types in the standard library.Comment: 6 pages, 2 figures, workshop paper for the ARRAY '14 workshop, June
11, 2014, Edinburgh, United Kingdo
Iso-array rewriting P systems with context-free iso-array rules
A new computing model called P system is a highly distributed and
parallel theoretical model, which is proposed in the area of membrane computing. Ceterchi et al. initially proposed array rewriting P systems by extending the notion of string rewriting P systems to arrays (2003). A theoretical model for picture generation using context-free iso-array grammar rules and puzzle iso-array grammar rules are introduced by Kalyani et al. (2004, 2006). Also iso-array rewriting P systems for iso-picture languages have been studied by Annadurai et al. (2008). In this paper we consider the context-free iso-array rules and context-free puzzle iso-array rules in iso-array rewriting P systems and examine the generative powers
of these P systems
- …