Abstract. As is typical in evolutionary algorithms, fitness evaluation in GP takes the majority of the computational effort. In this paper we demonstrate the use of the Graphics Processing Unit (GPU) to accelerate the evaluation of individuals. We show that for both binary and floating point based data types, it is possible to get speed increases of several hundred times over a typical CPU implementation. This allows for evaluation of many thousands of fitness cases, and hence should enable more ambitious solutions to be evolved using GP.

Abstract. We extend our analysis of repetitive patterns found in genetic programming genomes to tree based GP. As in linear GP, repetitive patterns are present in large numbers. Size fair crossover limits bloat in automatic programming, preventing the evolution of recurring motifs. We examine these complex properties in detail: e.g. using depth v. size Catalan binary tree shape plots, subgraph and subtree matching, information entropy, syntactic and semantic fitness correlations and diffuse introns. We relate this emergent phenomenon to considerations about building blocks in GP and how GP works. 1

We examine the behavior of an evolutionary search on neutral networks in a simple linear GP system of a Boolean function space problem. To this end we draw parallels between notions in RNA-folding problems and in Genetic Programming, observe parameters of neutral networks and discuss the population dynamics via the occupation probability of network nodes in runs on their way to the optimal solution.

simultaneously measure expression of thousands of genes using millions of probes. We use correlations between measurements for the same gene across 6685 human tissue samples from NCBI’s GEO database to indicated the quality of individual HG-U133A probes. Low concordance indicates a poor probe. Regular expressions can be data mined by a Backus-Naur form (BNF) context-free grammar using strongly typed genetic programming written in gawk and using egrep. The automatically produced motif is better at predicting poor DNA sequences than an existing human generated RE, suggesting runs of Cytosine and Guanine and mixtures should all be avoided. 1

© 2009 Langdon and Harrison; licensee BioMed Central Ltd. This is an Open Access article distributed under the terms of the Creative Commons Attribution License

Test case generation constitutes a critical activity in software testing that is cost-intensive, time-consuming and error-prone when done manually. Hence, an automation of this process is required. One automation approach is search-based testing for which the task of generating test data is transformed into an optimization problem which is solved using metaheuristic search techniques. However, only little work has been done so far applying search-based testing techniques to systems that depend on continuous input signals. This paper proposes two novel approaches to generating input signals from within search-based testing techniques for continuous systems. These approaches are then shown to be very effective when experimentally applied to the problem of approximating a set of realistic signals.

Self-modifying Cartesian Genetic Programming (SMCGP) is a general purpose, graph-based, developmental form of Genetic Programming founded on Cartesian Genetic Programming. In addition to the usual computational functions, it includes functions that can modify the program encoded in the genotype. This means that programs can be iterated to produce an infinite sequence of programs (phenotypes) from a single evolved genotype. It also allows programs to acquire more inputs and produce more outputs during this iteration. We discuss how SMCGP can be used and the results obtained in several different problem domains, including digital circuits, generation of patterns and sequences, and mathematical problems. We find that SMCGP can efficiently solve all the problems studied. In addition, we prove mathematically that evolved programs can provide general solutions to a number of problems: n-input even-parity, n-input adder, and sequence approximation to p.

Genetic Programming (GP) is an automated method for creating computer programs starting from a high-level description of the problem to be solved. Many variants of GP have been proposed in the recent years. In this paper we are reviewing the main GP variants with linear representation. Namely, Linear Genetic Programming, Gene Expression

RNAnet [3]

Graphic Processing Units (GPUs) are fast, highly parallel units. In addition to processing 3D graphics, modern GPUs can be programmed for more general-purpose computation. A GPU consists of a large number of ‘shader processors’, and conceptually operates as a single instruction multiple data (SIMD) or multiple instruction multiple data (MIMD) stream processor. A modern GPU can have several hundred of these stream processors, which, combined with their relatively low cost, makes them an attractive platform for scientific computing. In the last two years, the genetic programming community has begun to exploit GPUs to accelerate the evaluation of individuals in a population [1, 4]. CGP was the first GP technique implemented in a general-purpose fashion on GPUs. By ‘general purpose’, we mean a technique that can be applied to a number of GP applications and not just a single, specialized task. Implementing CGP on GPUs has resulted in very significant performance increases. In this chapter, we discuss several of our implementations of CGP on GPUs. To begin with, we start with an overview of the hardware and software used, before discussing applications and the speed-ups obtained. 8.2 The Architecture of Graphics Processing Units Graphics processors are specialized stream processors used to render graphics. Typically, a GPU is able to perform graphics manipulations much faster than a generalpurpose CPU, as graphics processors are specifically designed to handle certain primitive operations. Internally, a GPU contains a number of small processors that are used to perform calculations on 3D vertex information and on textures. These processors operate in parallel with each other, and work on different parts of the