Implementation and Evaluation of a Novel ``Branch'' Construct for Genetic Programming

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

  author =       "Kevin A. Gibbs",
  title =        "Implementation and Evaluation of a Novel
                 {``}Branch{''} Construct for Genetic Programming",
  booktitle =    "Genetic Algorithms and Genetic Programming at Stanford
  year =         "2002",
  editor =       "John R. Koza",
  pages =        "93--101",
  address =      "Stanford, California, 94305-3079 USA",
  month =        jun,
  publisher =    "Stanford Bookstore",
  keywords =     "genetic algorithms, genetic programming",
  URL =          "",
  language =     "en",
  oai =          "oai:CiteSeerXPSU:",
  URL =          "",
  abstract =     "This paper describes a technique for implementing a
                 novel type of {"}branch {"} operator within a genetic
                 programming system. This branch construct is a new
                 operator type that allows arbitrary branching from one
                 location in an individual{'}s execution tree to
                 another. The branch can be understood as alternatively
                 allowing arbitrary code reuse or approximating access
                 to a potentially infinite number of automatically
                 defined functions. This paper describes the proposed
                 design of this branch operator. This proposed design is
                 then implemented in a real world system, and the
                 performance effects of the branch operator are
                 evaluated in two well known genetic programming
                 problems: the artificial ant problem and the lawnmower
                 problem. [1,2] The branch is found to provide some
                 performance benefits in both of these problems, and
                 areas for further investigation are outlined.
                 Introduction and Overview In the day-to-day programming
                 done by humans, most all control structures in code
                 originate from a high level. Whether programming in a
                 low-level language like C or a higher-level language
                 like LISP, we are accustomed to using high-level
                 control constructs like functions, loops, if
                 statements, and recursion to control the path of
                 execution and maximize code reuse. The thought of using
                 a branch, or goto or jump",
  notes =        "part of \cite{koza:2002:gagp} Artificial ant. Lawn
                 Mower. {"}allowing arbitrary code reuse{"} or
                 {"}potentially infinite number of ADFs{"}. Goto.
                 {"}branch{"} function with {"}random{"} destination
                 p95. Limits on total number of instructions and number
                 of branch instructions, defaults given if limits
                 reached. lilgp. Branch destinations stored as relative
                 offsets into the array of instructions.


Genetic Programming entries for Kevin A Gibbs