Genetic Programming in C++: Implementation Issues

Created by W.Langdon from gp-bibliography.bib Revision:1.4549

  author =       "Mike J. Keith and Martin C. Martin",
  title =        "Genetic Programming in {C}++: Implementation Issues",
  booktitle =    "Advances in Genetic Programming",
  publisher =    "MIT Press",
  editor =       "Kenneth E. {Kinnear, Jr.}",
  year =         "1994",
  pages =        "285--310",
  chapter =      "13",
  keywords =     "genetic algorithms, genetic programming",
  size =         "25 pages",
  broken =       "",
  URL =          "",
  URL =          "",
  URL =          "",
  URL =          "",
  abstract =     "The purpose of our current research is to investigate
                 the design and implementation of a Genetic Programming
                 platform in C++, with primary focus on efficiency and
                 flexibility. In this chapter we consider the lower
                 level implementation aspects of such a platform,
                 specifically, the Genome Interpreter. The fact that
                 Genetic Programming is a computationally expensive task
                 means that the overall efficiency of the platform in
                 both memory and time is crucial. In particular, the
                 node representation is the key part of the
                 implementation in which the overhead will be magnified.
                 We first compare a number of ways of storing the
                 topology of the tree. The most efficient representation
                 overall is one in which the program tree is a linear
                 array of nodes in prefix order as opposed to a pointer
                 based tree structure. We consider trade-offs with other
                 linear representations, namely postfix and arbitrary
                 positioning of functions and their arguments. We then
                 consider how to represent which function or terminal
                 each node represents, and demonstrate a very efficient
                 one to two byte representation. Finally, we integrate
                 these approaches and offer a prefix/jump-table (PJT)
                 approach which results in a very small overhead per
                 node in both time and space compared to the other
                 approaches we investigated. In addition to being
                 efficient, our interpreter is also very flexible.
                 Finally, we discuss approaches for handling flow
                 control, encapsulation, recursion, and simulated
                 parallel programming.",
  notes =        "Ideas implemented in Andy Singleton GPQuick

                 Contrasts 5 different genome interpreters (postfix,
                 prefix, Mixfix). Code based on C and C++. Population of

                 check later 1995 for postscript on GP ftp site",

Genetic Programming entries for Mike J Keith Martin C Martin