GNU/Linux AI & Alife HOWTO
John Eikenberry v1.7, 9 Feb 2002
This howto mainly contains information about, and links to,
various AI related software libraries, applications, etc. that work on the GNU/Linux platform. All of it is (at least) free for personal use. The new master page for this document is
http://zhar.net/gnu-linux/howto/
The GNU/Linux OS has evolved from its origins in hackerdom to a full blown UNIX, capable of rivaling any commercial UNIX. It now provides an inexpensive base to build a great workstation. It has shed its hardware dependencies, having been ported to DEC Alphas, Sparcs, PowerPCs, and many others. This potential speed boost along with its networking support will make it great for workstation clusters. As a workstation it allows for all sorts of research and development, including artificial intelligence and artificial life.
The purpose of this Howto is to provide a source to find out about various software packages, code libraries, and anything else that will help someone get started working with (and find resources for) artificial intelligence, artificial life, etc. All done with GNU/Linux specifically in mind.
All this software should be available via the net (ftp || http). The links to where to find it will be provided in the description of each package. There will also be plenty of software not covered on these pages (which is usually platform independent) located on one of the resources listed on the links section of the Master Site (given above).
If you find any mistakes, know of updates to one of the items below, or have problems compiling any of the applications, please mail me at: jae@NOSPAM-zhar.net and I'll see what I can do.
If you know of any AI/Alife applications, class libraries, etc. Please
email me
about them. Include your name, ftp and/or http sites where they can be found, plus a brief overview/commentary on the software (this info would make things a lot easier on me... but don't feel obligated ;).
I know that keeping this list up to date and expanding it will take quite a bit of work. So please be patient (I do have other projects). I hope you will find this document helpful.
Copyright (c) 1996-2000 John A. Eikenberry
LICENSE
This document may be reproduced and distributed in whole or in part, in any medium physical or electronic, provided that this license notice is displayed in the reproduction. Commercial redistribution is permitted and encouraged. Thirty days advance notice, via email to the author, of redistribution is appreciated, to give the authors time to provide updated documents.
A. REQUIREMENTS OF MODIFIED WORKS
All modified documents, including translations, anthologies, and partial documents, must meet the following requirements:
*
*
*
*
endorsement of the resulting document without the original author's permission. *
In addition it is requested (not required) that:
*
redistribution, if an email address is provided in the document. *
As a special exception, anthologies of LDP documents may include a single copy of these license terms in a conspicuous location within the anthology and replace other copies of this license with a reference to the single copy of the license without the document being considered "modified" for the purposes of this section.
Mere aggregation of LDP documents with other documents or programs on the same media shall not cause this license to apply to those other works.
All translations, derivative documents, or modified documents that incorporate this document may not have more restrictive license terms than these, except that you may require distributors to make the resulting document available in source format.
Traditional AI is based around the ideas of logic, rule systems, linguistics, and the concept of rationality. At its roots are programming languages such as Lisp and Prolog. Expert systems are the largest successful example of this paradigm. An expert system consists of a detailed knowledge base and a complex rule system to utilize it. Such systems have been used for such things as medical diagnosis support and credit checking systems.
These are libraries of code or classes for use in programming within the artificial intelligence field. They are not meant as stand alone applications, but rather as tools for building your own applications.
; ACL2:
www.telent.net/cliki/ACL2 *
ACL2 (A Computational Logic for Applicative Common Lisp) is a theorem prover for industrial applications. It is both a mathematical logic and a system of tools for constructing proofs in the logic. ACL2 works with GCL (GNU Common Lisp).
; AI Search II:
www.bell-labs.com/topic/books/ooai-book/ *
Submitted by: Peter M. Bouthoorn
Basically, the library offers the programmer a set of search algorithms that may be used to solve all kind of different problems. The idea is that when developing problem solving software the programmer should be able to concentrate on the representation of the problem to be solved and should not need to bother with the implementation of the search algorithm that will be used to actually conduct the search. This idea has been realized by the implementation of a set of search classes that may be incorporated in other software through C++'s features of derivation and inheritance. The following search algorithms have been implemented:
*
*
*
*
*
*
*
*
This library has a corresponding book, " Object-Oriented Artificial Instelligence, Using C++".
; Chess In Lisp (CIL):
chess.onenet.net/pub/chess/uploads/projects/ *
The CIL (Chess In Lisp) foundation is a Common Lisp implementaion of all the core functions needed for development of chess applications. The main purpose of the CIL project is to get AI researchers interested in using Lisp to work in the chess domain.
; DAI:
starship.python.net/crew/gandalf/DNET/AI/ *
A library for the Python programming language that provides an object oriented interface to the CLIPS expert system tool. It includes an interface to COOL (CLIPS Object Oriented Language) that allows:
*
*
*
*
; HTK:
htk.eng.cam.ac.uk *
The Hidden Markov Model Toolkit (HTK) is a portable toolkit for building and manipulating hidden Markov models. HTK consists of a set of library modules and tools available in C source form. The tools provide sophisticated facilities for speech analysis, HMM training, testing and results analysis. The software supports HMMs using both continuous density mixture Gaussians and discrete distributions and can be used to build complex HMM systems. The HTK release contains extensive documentation and examples.
; JACK:
www.pms.informatik.uni-muenchen.de/software/jack/ *
JACK is a new library providing constraint programming and search for Java.
*
A high-level language to write constraint solvers. *
A generic search engine for JCHR to solve constraint problems. *
An interactive tool to visualize JCHR computations. *
Source and documentation available from link above.
; LK:
www.cs.utoronto.ca/neto/research/lk/ *
LK is an implementation of the Lin-Kernighan heuristic for the Traveling Salesman Problem and for the minimum weight perfect matching problem. It is tuned for 2-d geometric instances, and has been applied to certain instances with up to a million cities. Also included are instance generators and Perl scripts for munging TSPLIB instances.
This implementation introduces ``efficient cluster compensation'', an experimental algorithmic technique intended to make the Lin-Kernighan heuristic more robust in the face of clustered data.
; Nyquist:
www.cs.cmu.edu/afs/cs.cmu.edu/project/music/web/music.html *
The Computer Music Project at CMU is developing computer music and interactive performance technology to enhance human musical experience and creativity. This interdisciplinary effort draws on Music Theory, Cognitive Science, Artificial Intelligence and Machine Learning, Human Computer Interaction, Real-Time Systems, Computer Graphics and Animation, Multimedia, Programming Languages, and Signal Processing. A paradigmatic example of these interdisciplinary efforts is the creation of interactive performances that couple human musical improvisation with intelligent computer agents in real-time.
; PDKB:
lynx.eaze.net/pdkb/web/ *
sourceforge.net/project/pdkb *
Public Domain Knowledge Bank (PDKB) is an Artificial Intelligence Knowledge Bank of common sense rules and facts. It is based on the Cyc Upper Ontology and the MELD language.
; Python Fuzzy Logic Module:
ftp://ftp.csh.rit.edu/pub/members/retrev/
*
A simple python module for fuzzy logic. The file is 'fuz.tar.gz' in this directory. The author plans to also write a simple genetic algorithm and a neural net library as well. Check the 00_index file in this directory for release info.
; QUANT1:
linux.irk.ru/projects/QUANT/ *
QUANT/1 stands for type QUANTifier. It aims to be an alternative to Prolog-like (Resulutional-like) systems. Main features include a lack of necessity for eliminating Quantifiers, scolemisation, ease of comprehension, large scale formulae operation, acceptance of nonHorn formulaes, and Iterative deeping. The actual library implemented in this project is called ATPPCF (Automatic Theorem Prover in calculus of Positively Constructed Formulae).
ATPPCF will be a library (inference engine) and an extension of the Predicate Calculus Language as a new logical language. The library will be incorporable in another software such as TCL, Python, Perl. The engine's primary inference method will be the "search of inference in language of Positively Constructed Formulas (PCFs)" (a subset of Predicate Calculus well translated in both directions). The language will be used as scripting language to the engine. But there will be possibility to replace it with extensions languages of main software.
; Screamer:
www.cis.upenn.edu/screamer-tools/home.html *
Screamer is an extension of Common Lisp that adds support for nondeterministic programming. Screamer consists of two levels. The basic nondeterministic level adds support for backtracking and undoable side effects. On top of this nondeterministic substrate, Screamer provides a comprehensive constraint programming language in which one can formulate and solve mixed systems of numeric and symbolic constraints. Together, these two levels augment Common Lisp with practically all of the functionality of both Prolog and constraint logic programming languages such as CHiP and CLP(R). Furthermore, Screamer is fully integrated with Common Lisp. Screamer programs can coexist and interoperate with other extensions to Common Lisp such as CLOS, CLIM and Iterate.
; !ThoughtTreasure?:
www.signiform.com/tt/htm/tt.htm *
for use in any application. It consists of a database of a little over 100K rules and a C API to integrate it with your applications. Python, Perl, Java and TCL wrappers are already available.
These are various applications, software kits, etc. meant for research in the field of artificial intelligence. Their ease of use will vary, as they were designed to meet some particular research interest more than as an easy to use commercial package.
; ASA - Adaptive Simulated Annealing:
www.ingber.com/#ASA-CODE *
ftp.ingber.com/ *
ASA (Adaptive Simulated Annealing) is a powerful global optimization C-code algorithm especially useful for nonlinear and/or stochastic systems.
ASA is developed to statistically find the best global fit of a nonlinear non-convex cost-function over a D-dimensional space. This algorithm permits an annealing schedule for 'temperature' T decreasing exponentially in annealing-time k, T = T_0 exp(-c k^1/D). The introduction of re-annealing also permits adaptation to changing sensitivities in the multi-dimensional parameter-space. This annealing schedule is faster than fast Cauchy annealing, where T = T_0/k, and much faster than Boltzmann annealing, where T = T_0/ln k.
; Babylon:
ftp.gmd.de/gmd/ai-research/Software/Babylon/ *
BABYLON is a modular, configurable, hybrid environment for developing expert systems. Its features include objects, rules with forward and backward chaining, logic (Prolog) and constraints. BABYLON is implemented and embedded in Common Lisp.
; cfengine:
www.iu.hio.no/cfengine/ *
Cfengine, or the configuration engine is a very high level language for building expert systems which administrate and configure large computer networks. Cfengine uses the idea of classes and a primitive form of intelligence to define and automate the configuration of large systems in the most economical way possible. Cfengine is design to be a part of computer immune systems.
; CLEARS:
*
The CLEARS system is an interactive graphical environment for computational semantics. The tool allows exploration and comparison of different semantic formalisms, and their interaction with syntax. This enables the user to get an idea of the range of possibilities of semantic construction, and also where there is real convergence between theories.
; CLIG:
www.ags.uni-sb.de/konrad/clig.html *
CLIG is an interactive, extendible grapher for visualizing linguistic data structures like trees, feature structures, Discourse Representation Structures (DRS), logical formulas etc. All of these can be freely mixed and embedded into each other. The grapher has been designed both to be stand-alone and to be used as an add-on for linguistic applications which display their output in a graphical manner.
; CLIPS:
www.ghg.net/clips/CLIPS.html *
CLIPS is a productive development and delivery expert system tool which provides a complete environment for the construction of rule and/or object based expert systems.
CLIPS provides a cohesive tool for handling a wide variety of knowledge with support for three different programming paradigms: rule-based, object-oriented and procedural. Rule-based programming allows knowledge to be represented as heuristics, or "rules of thumb," which specify a set of actions to be performed for a given situation. Object-oriented programming allows complex systems to be modeled as modular components (which can be easily reused to model other systems or to create new components). The procedural programming capabilities provided by CLIPS are similar to capabilities found in languages such as C, Pascal, Ada, and LISP.
; EMA-XPS - A Hybrid Graphic Expert System Shell:
www.iai.uni-wuppertal.de/EMA-XPS/ *
EMA-XPS is a hybrid graphic expert system shell based on the ASCII-oriented shell Babylon 2.3 of the German National Research Center for Computer Sciences (GMD). In addition to Babylon's AI-power (object oriented data representation, forward and backward chained rules - collectible into sets, horn clauses, and constraint networks) a graphic interface based on the X11 Window System and the OSF/Motif Widget Library has been provided.
; FOOL & FOX:
rhaug.de/fool/ *
ftp.informatik.uni-oldenburg.de/pub/fool/ *
FOOL stands for the Fuzzy Organizer OLdenburg. It is a result from a project at the University of Oldenburg. FOOL is a graphical user interface to develop fuzzy rulebases. FOOL will help you to invent and maintain a database that specifies the behavior of a fuzzy-controller or something like that.
FOX is a small but powerful fuzzy engine which reads this database, reads some input values and calculates the new control value.
; FUF and SURGE:
www.cs.bgu.ac.il/research/projects/surge/index.htm *
ftp.cs.bgu.ac.il/pub/fuf/ *
FUF is an extended implementation of the formalism of functional unification grammars (FUGs) introduced by Martin Kay specialized to the task of natural language generation. It adds the following features to the base formalism:
*
backtracking). *
*
These extensions allow the development of large grammars which can be processed efficiently and can be maintained and understood more easily. SURGE is a large syntactic realization grammar of English written in FUF. SURGE is developed to serve as a black box syntactic generation component in a larger generation system that encapsulates a rich knowledge of English syntax. SURGE can also be used as a platform for exploration of grammar writing with a generation perspective.
; The Grammar Workbench:
www.cs.kun.nl/agfl/ *
Seems to be obsolete??? Its gone from the site, though its parent project is still ongoing.
The Grammar Workbench, or GWB for short, is an environment for the comfortable development of Affix Grammars in the AGFL-formalism. Its purposes are:
*
*
*
*
*
; GSM Suite:
www.slip.net/andrewm/gsm/ *
The GSM Suite is a set of programs for using Finite State Machines in a graphical fashion. The suite consists of programs that edit, compile, and print state machines. Included in the suite is an editor program, gsmedit, a compiler, gsm2cc, that produces a C++ implementation of a state machine, a !PostScript generator, gsm2ps, and two other minor programs. GSM is licensed under the GNU Public License and so is free for your use under the terms of that license.
; Illuminator:
documents.cfar.umd.edu/resources/source/illuminator.html *
Illuminator is a toolset for developing OCR and Image Understanding applications. Illuminator has two major parts: a library for representing, storing and retrieving OCR information, heretofore called dafslib, and an X-Windows "DAFS" file viewer, called illum. Illuminator and DAFS lib were designed to supplant existing OCR formats and become a standard in the industry. They particularly are extensible to handle more than just English.
The features of this release:
*
*
Greek, Italian, MICR, Norwegian, Russian, Spanish, Swedish, keyboards *
*
*
bounding boxes image fragment for a selected entity, change type, change content, hierarchy mode *
; Isabelle:
isabelle.in.tum.de *
Isabelle is a popular generic theorem prover developed at Cambridge University and TU Munich. Existing logics like Isabelle/HOL provide a theorem proving environment ready to use for sizable applications. Isabelle may also serve as framework for rapid prototyping of deductive systems. It comes with a large library including Isabelle/HOL (classical higher-order logic), Isabelle/HOLCF (Scott's Logic for Computable Functions with HOL), Isabelle/FOL (classical and intuitionistic first-order logic), and Isabelle/ZF (Zermelo-Fraenkel set theory on top of FOL).
; Jess, the Java Expert System Shell:
herzberg.ca.sandia.gov/jess/ *
Jess is a clone of the popular CLIPS expert system shell written entirely in Java. With Jess, you can conveniently give your applets the ability to 'reason'. Jess is compatible with all versions of Java starting with version 1.0.2. Jess implements the following constructs from CLIPS: defrules, deffunctions, defglobals, deffacts, and deftemplates.
; learn:
sunsite.unc.edu/pub/Linux/apps/cai/ *
Learn is a vocable learning program with memory model.
; LISA:
lisa.sourceforge.net *
LISA (Lisp-based Intelligent Software Agents) is a production-rule system heavily influenced by JESS (Java Expert System Shell). It has at its core a reasoning engine based on the Rete pattern matching algorithm. LISA also provides the ability to reason over ordinary CLOS objects.
; NICOLE:
nicole.sourceforge.net *
NICOLE (Nearly Intelligent Computer Operated Language Examiner) is a theory or experiment that if a computer is given enough combinations of how words, phrases and sentences are related to one another, it could talk back to you. It is an attempt to simulate a conversation by learning how words are related to other words. A human communicates with NICOLE via the keyboard and NICOLE responds back with its own sentences which are automatically generated, based on what NICOLE has stored in it's database. Each new sentence that has been typed in, and NICOLE doesn't know about, is included into NICOLE's database, thus extending the knowledge base of NICOLE.
; Otter: An Automated Deduction System:
www-unix.mcs.anl.gov/AR/otter/ *
Our current automated deduction system Otter is designed to prove theorems stated in first-order logic with equality. Otter's inference rules are based on resolution and paramodulation, and it includes facilities for term rewriting, term orderings, Knuth-Bendix completion, weighting, and strategies for directing and restricting searches for proofs. Otter can also be used as a symbolic calculator and has an embedded equational programming system.
; PVS:
pvs.csl.sri.com/ *
PVS is a verification system: that is, a specification language integrated with support tools and a theorem prover. It is intended to capture the state-of-the-art in mechanized formal methods and to be sufficiently rugged that it can be used for significant applications. PVS is a research prototype: it evolves and improves as we develop or apply new capabilities, and as the stress of real use exposes new requirements.
; SNePS:
www.cse.buffalo.edu/sneps/ *
ftp.cse.buffalo.edu/pub/sneps/ *
The long-term goal of The SNePS Research Group is the design and construction of a natural-language-using computerized cognitive agent, and carrying out the research in artificial intelligence, computational linguistics, and cognitive science necessary for that endeavor. The three-part focus of the group is on knowledge representation, reasoning, and natural-language understanding and generation. The group is widely known for its development of the SNePS knowledge representation/reasoning system, and Cassie, its computerized cognitive agent.
; Soar:
ai.eecs.umich.edu/soar/ *
Soar has been developed to be a general cognitive architecture. We intend ultimately to enable the Soar architecture to:
intelligent agent, from highly routine to extremely difficult, open-ended problems *
procedural, declarative, episodic, and possibly iconic *
*
*
*
In other words, our intention is for Soar to support all the capabilities required of a general intelligent agent.
; TCM:
wwwis.cs.utwente.nl:8080/tcm/index.html *
ftp.cs.vu.nl/pub/tcm/ *
TCM (Toolkit for Conceptual Modeling) is our suite of graphical editors. TCM contains graphical editors for Entity-Relationship diagrams, Class-Relationship diagrams, Data and Event Flow diagrams, State Transition diagrams, Jackson Process Structure diagrams and System Network diagrams, Function Refinement trees and various table editors, such as a Function-Entity table editor and a Function Decomposition table editor. TCM is easy to use and performs numerous consistency checks, some of them immediately, some of them upon request.
; WEKA:
lucy.cs.waikato.ac.nz/ml/ *
WEKA (Waikato Environment for Knowledge Analysis) is an state-of-the-art facility for applying machine learning techniques to practical problems. It is a comprehensive software "workbench" that allows people to analyse real-world data. It integrates different machine learning tools within a common framework and a uniform user interface. It is designed to support a "simplicity-first" methodology, which allows users to experiment interactively with simple machine learning tools before looking for more complex solutions.
Connectionism is a technical term for a group of related techniques. These techniques include areas such as Artificial Neural Networks, Semantic Networks and a few other similar ideas. My present focus is on neural networks (though I am looking for resources on the other techniques). Neural networks are programs designed to simulate the workings of the brain. They consist of a network of small mathematical-based nodes, which work together to form patterns of information. They have tremendous potential and currently seem to be having a great deal of success with image processing and robot control.
These are libraries of code or classes for use in programming within the Connectionist field. They are not meant as stand alone applications, but rather as tools for building your own applications.
; ANSI-C Neural Networks:
www.geocities.com/!CapeCanaveral?/1624/ *
This site contains ANSC-C source code for 8 types of neural nets, including:
*
*
*
*
*
*
*
*
They were designed to help turn the theory of a particular network model into the design for a simulator implementation , and to help with embeding an actual application into a particular network model.
; Software for Flexible Bayesian Modeling:
www.cs.utoronto.ca/radford/fbm.software.html *
This software implements flexible Bayesian models for regression and classification applications that are based on multilayer perceptron neural networks or on Gaussian processes. The implementation uses Markov chain Monte Carlo methods. Software modules that support Markov chain sampling are included in the distribution, and may be useful in other applications.
; BELIEF:
www.cs.cmu.edu/afs/cs/project/ai-repository/ai/areas/reasonng/probabl/belief/ *
BELIEF is a Common Lisp implementation of the Dempster and Kong fusion and propagation algorithm for Graphical Belief Function Models and the Lauritzen and Spiegelhalter algorithm for Graphical Probabilistic Models. It includes code for manipulating graphical belief models such as Bayes Nets and Relevance Diagrams (a subset of Influence Diagrams) using both belief functions and probabilities as basic representations of uncertainty. It uses the Shenoy and Shafer version of the algorithm, so one of its unique features is that it supports both probability distributions and belief functions. It also has limited support for second order models (probability distributions on parameters).
; bpnn.py:
www.enme.ucalgary.ca/nascheme/python/bpnn.py *
A simple back-propogation ANN in Python.
; CONICAL:
strout.net/conical/ *
CONICAL is a C++ class library for building simulations common in computational neuroscience. Currently its focus is on compartmental modeling, with capabilities similar to GENESIS and NEURON. A model neuron is built out of compartments, usually with a cylindrical shape. When small enough, these open-ended cylinders can approximate nearly any geometry. Future classes may support reaction-diffusion kinetics and more. A key feature of CONICAL is its cross-platform compatibility; it has been fully co-developed and tested under Unix, DOS, and Mac OS.
; IDEAL:
www.rpal.rockwell.com/ideal.html *
IDEAL is a test bed for work in influence diagrams and Bayesian networks. It contains various inference algorithms for belief networks and evaluation algorithms for influence diagrams. It contains facilities for creating and editing influence diagrams and belief networks.
IDEAL is written in pure Common Lisp and so it will run in Common Lisp on any platform. The emphasis in writing IDEAL has been on code clarity and providing high level programming abstractions. It thus is very suitable for experimental implementations which need or extend belief network technology.
At the highest level, IDEAL can be used as a subroutine library which provides belief network inference and influence diagram evaluation as a package. The code is documented in a detailed manual and so it is also possible to work at a lower level on extensions of belief network methods.
IDEAL comes with an optional graphic interface written in CLIM. If your Common Lisp also has CLIM, you can run the graphic interface.
; Jet's Neural Architecture:
www.voltar-confed.org/jneural/ *
Jet's Neural Architecture is a C++ framework for doing neural net projects. The goals of this project were to make a fast, flexible neural architecture that isn't stuck to one kind of net and to make sure that end users could easily write useful applications. All the documentation is also easily readable.
; Joone:
joone.sourceforge.net *
Joone is a neural net framework to create, train and test neural nets. The aim is to create a distributed environment based on !JavaSpaces? both for enthusiastic and professional users, based on the newest Java technologies. Joone is composed of a central engine that is the fulcrum of all applications that already exist or will be developed. The neural engine is modular, scalable, multitasking and tensile. Everyone can write new modules to implement new algorithms or new architectures starting from the simple components distributed with the core engine. The main idea is to create the basis to promote a zillion of AI applications that revolve around the core framework.
; Matrix Class:
ftp.cs.ucla.edu/pub/ *
A simple, fast, efficient C++ Matrix class designed for scientists and engineers. The Matrix class is well suited for applications with complex math algorithms. As an demonstration of the Matrix class, it was used to implement the backward error propagation algorithm for a multi-layer feed-forward artificial neural network.
; nunu:
ruby.ddiworld.com/jreed/web/software/nn.html *
nunu is a multi-layered, scriptable, back-propagation neural network. It is build to be used for intensive computation problems scripted in shell scripts. It is written in C++ using the STL. nn is based on material from the "Introduction to the Theory of Neural Computation" by John Hertz, Anders Krogh, and Richard G. Palmer, chapter 6.
; Pulcinella:
iridia.ulb.ac.be/pulcinella/Welcome.html *
Pulcinella is written in !CommonLisp, and appears as a library of Lisp functions for creating, modifying and evaluating valuation systems. Alternatively, the user can choose to interact with Pulcinella via a graphical interface (only available in Allegro CL). Pulcinella provides primitives to build and evaluate uncertainty models according to several uncertainty calculi, including probability theory, possibility theory, and Dempster-Shafer's theory of belief functions; and the possibility theory by Zadeh, Dubois and Prade's. A User's Manual is available on request.
; S-!ElimBel?:
www.spaces.uci.edu/thiery/elimbel/ *
S-!ElimBel? is an algorithm that computes the belief in a Bayesian network, implemented in MIT-Scheme. This algorithm has the particularity of being rather easy to understand. Moreover, one can apply it to any kind of Bayesian network - it being singly connected or muliply connected. It is, however, less powerful than the standard algorithm of belief propagation. Indeed, the computation has to be reconducted entirely for each new evidence added to the network. Also, one needs to run the algorithm as many times as one has nodes for which the belief is wanted.
; scnANNlib:
www.sentinelchicken.org/projects/scnANNlib/ *
SCN Artificial Neural Network Library provides a programmer with a simple object-oriented API for constructing ANNs. Currently, the library supports non-recursive networks with an arbitrary number of layers, each with an arbitrary number of nodes. Facilities exist for training with momentum, and there are plans to gracefully extend the functionality of the library in later releases.
; Symbolic Probabilistic Inference (SPI):
ftp.engr.orst.edu/pub/dambrosi/spi/ *
ftp.engr.orst.edu/pub/dambrosi/ *
Contains Common Lisp function libraries to implement SPI type baysean nets. Documentation is very limited. Features:
Dynamic Models, and a TCL/TK based GUI. *
; !TresBel?:
iridia.ulb.ac.be/pub/hongxu/software/ *
Libraries containing (Allegro) Common Lisp code for Belief Functions (aka. Dempster-Shafer evidential reasoning) as a representation of uncertainty. Very little documentation. Has a limited GUI.
; UTCS Neural Nets Research Group Software:
www.cs.utexas.edu/users/nn/pages/software/software.html *
A bit different from the other entries, this is a reference to a collection of software rather than one application. It was all developed by the UTCS Neural Net Research Group. Here's a summary of the packages available:
Natural Language Processing
processing
*
*
DISCERN - Processing script-based stories, including
*
*
*
*
*
*
*
Self-Organization
*
*
*
Neuroevolution
tasks
***Non-Markov Double Pole Balancing ***
*
ESP)
***JavaSANE - Java software package for applying SANE to new tasks ***
***SANE-C - C version, predecessor of JavaSANE ***
***Pole Balancing - Neuron-level SANE on the Pole Balancing task ***
*
software for evolving neural networks using structure
*
; Various (C++) Neural Networks:
www.dontveter.com/nnsoft/nnsoft.html *
Example neural net codes from the book, The Pattern Recognition Basics of AI. These are simple example codes of these various neural nets. They work well as a good starting point for simple experimentation and for learning what the code is like behind the simulators. The types of networks available on this site are: (implemented in C++)
*
*
*
*
*
*
*
*
These are various applications, software kits, etc. meant for research in the field of Connectionism. Their ease of use will vary, as they were designed to meet some particular research interest more than as an easy to use commercial package.
; Aspirin - MIGRAINES:
(am6.tar.Z on ftp site)
sunsite.unc.edu/pub/academic/computer-science/neural-networks/programs/Aspirin/ *
The software that we are releasing now is for creating, and evaluating, feed-forward networks such as those used with the backpropagation learning algorithm. The software is aimed both at the expert programmer/neural network researcher who may wish to tailor significant portions of the system to his/her precise needs, as well as at casual users who will wish to use the system with an absolute minimum of effort.
; DDLab:
www.santafe.edu/wuensch/ddlab.html *
ftp.santafe.edu/pub/wuensch/ *
DDLab is an interactive graphics program for research into the dynamics of finite binary networks, relevant to the study of complexity, emergent phenomena, neural networks, and aspects of theoretical biology such as gene regulatory networks. A network can be set up with any architecture between regular CA (1d or 2d) and "random Boolean networks" (networks with arbitrary connections and heterogeneous rules). The network may also have heterogeneous neighborhood sizes.
; GENESIS:
www.bbb.caltech.edu/GENESIS/ *
genesis.bbb.caltech.edu/pub/genesis/ *
GENESIS (short for GEneral NEural SImulation System) is a general purpose simulation platform which was developed to support the simulation of neural systems ranging from complex models of single neurons to simulations of large networks made up of more abstract neuronal components. GENESIS has provided the basis for laboratory courses in neural simulation at both Caltech and the Marine Biological Laboratory in Woods Hole, MA, as well as several other institutions. Most current GENESIS applications involve realistic simulations of biological neural systems. Although the software can also model more abstract networks, other simulators are more suitable for backpropagation and similar connectionist modeling.
; !JavaBayes?:
www.cs.cmu.edu/People/javabayes/index.html/ *
The !JavaBayes? system is a set of tools, containing a graphical editor, a core inference engine and a parser.
*
expected value for variables). *
*
univariate functions. *
; Jbpe:
cs.felk.cvut.cz/koutnij/studium/jbpe.html *
Jbpe is a back-propagation neural network editor/simulator.
Features
*
back. *
*
number of learning periods / desired network energy can be specified as a criterion. *
*
; neuralnets:
members.home.net/neuralnets/neuralnets/ *
neuralnets is a text-based program that allows someone to build, configure, train and run a Neural Network application. The code is written in Java and is easily extended or included within other code. The application comes ready to go with a Back Prop algorithm included. Well known applications...stock market, weather prediction, scheduling, image recognition, expert systems, research...basically anywhere you may need to make a complicated decision.
; Neural Network Generator:
www.idsia.ch/rafal/research.html *
ftp.idsia.ch/pub/rafal *
The Neural Network Generator is a genetic algorithm for the topological optimization of feedforward neural networks. It implements the Semantic Changing Genetic Algorithm and the Unit-Cluster Model. The Semantic Changing Genetic Algorithm is an extended genetic algorithm that allows fast dynamic adaptation of the genetic coding through population analysis. The Unit-Cluster Model is an approach to the construction of modular feedforward networks with a backbone structure.
NOTE: To compile this on Linux requires one change in the Makefiles. You will need to change '-ltermlib' to '-ltermcap'.
; Neureka ANS (nn/xnn):
www.bgif.no/neureka/ *
ftp.ii.uib.no/pub/neureka/ *
nn is a high-level neural network specification language. The current version is best suited for feed-forward nets, but recurrent models can and have been implemented, e.g. Hopfield nets, Jordan/Elman nets, etc. In nn, it is easy to change network dynamics. The nn compiler can generate C code or executable programs (so there must be a C compiler available), with a powerful command line interface (but everything may also be controlled via the graphical interface, xnn). It is possible for the user to write C routines that can be called from inside the nn specification, and to use the nn specification as a function that is called from a C program. Please note that no programming is necessary in order to use the network models that come with the system (`netpack').
xnn is a graphical front end to networks generated by the nn compiler, and to the compiler itself. The xnn graphical interface is intuitive and easy to use for beginners, yet powerful, with many possibilities for visualizing network data.
NOTE: You have to run the install program that comes with this to get the license key installed. It gets put (by default) in /usr/lib. If you (like myself) want to install the package somewhere other than in the /usr directory structure (the install program gives you this option) you will have to set up some environmental variables (NNLIBDIR & NNINCLUDEDIR are required). You can read about these (and a few other optional variables) in appendix A of the documentation (pg 113).
; NEURON:
www.neuron.yale.edu/ *
ftp.neuron.yale.edu/neuron/unix/ *
NEURON is an extensible nerve modeling and simulation program. It allows you to create complex nerve models by connecting multiple one-dimensional sections together to form arbitrary cell morphologies, and allows you to insert multiple membrane properties into these sections (including channels, synapses, ionic concentrations, and counters). The interface was designed to present the neural modeler with a intuitive environment and hide the details of the numerical methods used in the simulation.
; PDP++:
www.cnbc.cmu.edu/PDP++/ *
cnbc.cmu.edu/pub/pdp++/ *
unix.hensa.ac.uk/mirrors/pdp++/ *
As the field of Connectionist modeling has grown, so has the need for a comprehensive simulation environment for the development and testing of Connectionist models. Our goal in developing PDP++ has been to integrate several powerful software development and user interface tools into a general purpose simulation environment that is both user friendly and user extensible. The simulator is built in the C++ programming language, and incorporates a state of the art script interpreter with the full expressive power of C++. The graphical user interface is built with the Interviews toolkit, and allows full access to the data structures and processing modules out of which the simulator is built. We have constructed several useful graphical modules for easy interaction with the structure and the contents of neural networks, and we've made it possible to change and adapt many things. At the programming level, we have set things up in such a way as to make user extensions as painless as possible. The programmer creates new C++ objects, which might be new kinds of units or new kinds of processes; once compiled and linked into the simulator, these new objects can then be accessed and used like any other.
; RNS:
www.cs.cmu.edu/afs/cs/project/ai-repository/ai/areas/neural/systems/rns/ *
RNS (Recurrent Network Simulator) is a simulator for recurrent neural networks. Regular neural networks are also supported. The program uses a derivative of the back-propagation algorithm, but also includes other (not that well tested) algorithms.
Features include
or CPU constraints *
*
*
annealing and more *
and random bit patterns with Hamming distances can be chosen for you *
*
*
; Simple Neural Net (in Python):
http://www.amk.ca/python/unmaintained/
*
Simple neural network code, which implements a class for 3-level networks (input, hidden, and output layers). The only learning rule implemented is simple backpropagation. No documentation (or even comments) at all, because this is simply code that I use to experiment with. Includes modules containing sample datasets from Carl G. Looney's NN book. Requires the Numeric extensions.
; SCNN:
www.uni-frankfurt.de/fb13/iap/e_ag_rt/SCNN/ *
SCNN is an universal simulating system for Cellular Neural Networks (CNN). CNN are analog processing neural networks with regular and local interconnections, governed by a set of nonlinear ordinary differential equations. Due to their local connectivity, CNN are realized as VLSI chips, which operates at very high speed.
; Semantic Networks in Python:
strout.net/info/coding/python/ai/index.html *
The semnet.py module defines several simple classes for building and using semantic networks. A semantic network is a way of representing knowledge, and it enables the program to do simple reasoning with very little effort on the part of the programmer.
The following classes are defined:
something which can be related to other things, and about which you can store facts. *
which may exist between two entities. One special relation, "IS_A", is predefined because it has special meaning (a sort of logical inheritance). *
exists between two entities. *
With these three object types, you can very quickly define knowledge about a set of objects, and query them for logical conclusions.
; SNNS:
www.informatik.uni-stuttgart.de/ipvr/bv/projekte/snns/ *
ftp.informatik.uni-stuttgart.de/pub/SNNS/ *
Stuttgart Neural Net Simulator (version 4.1). An awesome neural net simulator. Better than any commercial simulator I've seen. The simulator kernel is written in C (it's fast!). It supports over 20 different network architectures, has 2D and 3D X-based graphical representations, the 2D GUI has an integrated network editor, and can generate a separate NN program in C. SNNS is very powerful, though a bit difficult to learn at first. To help with this it comes with example networks and tutorials for many of the architectures. ENZO, a supplementary system allows you to evolve your networks with genetic algorithms.
; SPRLIB/ANNLIB:
www.ph.tn.tudelft.nl/sprlib/ *
SPRLIB (Statistical Pattern Recognition Library) was developed to support the easy construction and simulation of pattern classifiers. It consist of a library of functions (written in C) that can be called from your own program. Most of the well-known classifiers are present (k-nn, Fisher, Parzen, ....), as well as error estimation and dataset generation routines.
ANNLIB (Artificial Neural Networks Library) is a neural network simulation library based on the data architecture laid down by SPRLIB. The library contains numerous functions for creating, training and testing feed-forward networks. Training algorithms include back-propagation, pseudo-Newton, Levenberg-Marquardt, conjugate gradient descent, BFGS.... Furthermore, it is possible
Kohonen maps and other more exotic network architectures using the same data types.
; TOOLDIAG:
www.inf.ufes.br/thomas/home/tooldiag.html *
ftp.inf.ufes.br/pub/tooldiag/ *
TOOLDIAG is a collection of methods for statistical pattern recognition. The main area of application is classification. The application area is limited to multidimensional continuous features, without any missing values. No symbolic features (attributes) are allowed. The program in implemented in the 'C' programming language and was tested in several computing environments.
; XNBC:
www.b3e.jussieu.fr/xnbc/ *
XNBC v8 is a simulation tool for the neuroscientists interested in simulating biological neural networks using a user friendly tool.
XNBC is a software package for simulating biological neural networks.
Four neuron models are available, three phenomenologic models (xnbc, leaky integrator and conditional burster) and an ion-conductance based model. Inputs to the simulated neurons can be provided by experimental data stored in files, allowing the creation of `hybrid'' networks.
Evolutionary computing is actually a broad term for a vast array of programming techniques, including genetic algorithms, complex adaptive systems, evolutionary programming, etc. The main thrust of all these techniques is the idea of evolution. The idea that a program can be written that will evolve toward a certain goal. This goal can be anything from solving some engineering problem to winning a game.
These are libraries of code or classes for use in programming within the evolutionary computation field. They are not meant as stand alone applications, but rather as tools for building your own applications.
; daga:
GARAGe.cps.msu.edu/software/software-index.html *
daga is an experimental release of a 2-level genetic algorithm compatible with the GALOPPS GA software. It is a meta-GA which dynamically evolves a population of GAs to solve a problem presented to the lower-level GAs. When multiple GAs (with different operators, parameter settings, etc.) are simultaneously applied to the same problem, the ones showing better performance have a higher probability of surviving and "breeding" to the next macro-generation (i.e., spawning new "daughter"-GAs with characteristics inherited from the parental GA or GAs. In this way, we try to encourage good problem-solving strategies to spread to the whole population of GAs.
; Ease:
www.sprave.com/Ease/Ease.html *
Ease - Evolutionary Algorithms Scripting Evironment - is an extension to the Tcl scripting language, providing commands to create, modify, and evaluate populations of individuals represented by real number vectors and/or bit strings.
; EO:
geneura.ugr.es/jmerelo/EO.html *
EO is a templates-based, ANSI-C++ compliant evolutionary computation library. It contains classes for any kind of evolutionary computation (specially genetic algorithms) you might come up to. It is component-based, so that if you don't find the class you need in it, it is very easy to subclass existing abstract or concrete class.
; FORTRAN GA:
cuaerospace.com/carroll/ga.html *
This program is a FORTRAN version of a genetic algorithm driver. This code initializes a random sample of individuals with different parameters to be optimized using the genetic algorithm approach, i.e. evolution via survival of the fittest. The selection scheme used is tournament selection with a shuffling technique for choosing random pairs for mating. The routine includes binary coding for the individuals, jump mutation, creep mutation, and the option for single-point or uniform crossover. Niching (sharing) and an option for the number of children per pair of parents has been added. More recently, an option for the use of a micro-GA has been added.
; GAGS:
kal-el.ugr.es/gags.html *
kal-el.ugr.es/GAGS/ *
Genetic Algorithm application generator and class library written mainly in C++. As a class library, and among other thing, GAGS includes:
chromosomes. Genetic operators: 2-point crossover, uniform crossover, bit-flip mutation, transposition (gene interchange between 2 parts of the chromosome), and variable-length operators: duplication, elimination, and random addition. *
wheel and tournament selection. *
iostreams-like class. *
*
As an application generator (written in PERL), you only need to supply it with an ANSI-C or C++ fitness function, and it creates a C++ program that uses the above library to 90% capacity, compiles it, and runs it, saving results and presenting fitness thru gnuplot.
; GAlib: Matthew's Genetic Algorithms Library:
lancet.mit.edu/ga/ *
lancet.mit.edu/pub/ga/ *
lancet.mit.edu/ga/Register.html *
GAlib contains a set of C++ genetic algorithm objects. The library includes tools for using genetic algorithms to do optimization in any C++ program using any representation and genetic operators. The documentation includes an extensive overview of how to implement a genetic algorithm as well as examples illustrating customizations to the GAlib classes.
; GALOPPS:
GARAGe.cps.msu.edu/software/software-index.html *
garage.cps.msu.edu/pub/GA/galopps/ *
GALOPPS is a flexible, generic GA, in 'C'. It was based upon Goldberg's Simple Genetic Algorithm (SGA) architecture, in order to make it easier for users to learn to use and extend.
GALOPPS extends the SGA capabilities several fold:
for Unix users, allowing easy running of GALOPPS 3.2 (single or multiple subpopulations) on one or more processors. GUI writes/reads "standard" GALOPPS input and master files, and displays graphical output (during or after run) of user-selected variables. *
sampling, tournament selection, stochastic universal sampling, linear-ranking-then-SUS. *
(non-permutation) binary or non-binary chromosomes; random initialization of permutation-based chromosomes; or user-supplied initialization of arbitrary types of chromosomes. *
chromosomes, including different user-definable field sizes. *
uniform, all of which operate at field boundaries if a non-binary alphabet is used. *
order-based, and cycle. *
sublist scramble. *
truncation, window scaling, ranking. *
*
; GAS:
starship.skyport.net/crew/gandalf *
ftp.coe.uga.edu/users/jae/ai *
GAS means "Genetic Algorithms Stuff".
GAS is freeware.
Purpose of GAS is to explore and exploit artificial evolutions. Primary implementation language of GAS is Python. The GAS software package is meant to be a Python framework for applying genetic algorithms. It contains an example application where it is tried to breed Python program strings. This special problem falls into the category of Genetic Programming (GP), and/or Automatic Programming. Nevertheless, GAS tries to be useful for other applications of Genetic Algorithms as well.
; GECO:
ftp://ftp.aic.nrl.navy.mil/pub/galist/src/
*
GECO (Genetic Evolution through Combination of Objects), an extendible object-oriented tool-box for constructing genetic algorithms (in Lisp). It provides a set of extensible classes and methods designed for generality. Some simple examples are also provided to illustrate the intended use.
; GPdata:
ftp.cs.bham.ac.uk/pub/authors/W.B.Langdon/gp-code/ *
cs.ucl.ac.uk/genetic/papers/ *
GPdata-3.0.tar.gz (C++) contains a version of Andy Singleton's GP-Quick version 2.1 which has been extensively altered to support:
*
*
*
*
*
*
This ftp site also contains a small C++ program (ntrees.cc) to calculate the number of different there are of a given length and given function and terminal set.
; gpjpp Genetic Programming in Java:
http://www.turbopower.com/kimk/gpjpp.asp
*
*
gpjpp is a Java package I wrote for doing research in genetic programming. It is a port of the gpc++ kernel written by Adam Fraser and Thomas Weinbrenner. Included in the package are four of Koza's standard examples: the artificial ant, the hopping lawnmower, symbolic regression, and the boolean multiplexer. Here is a partial list of its features:
*
*
*
genetic programming test *
checkpoint and restart built into the GPRun class *
*
without recompilation *
*
*
*
*
*
*
; jaga:
cs.felk.cvut.cz/koutnij/studium/jaga/jaga.html *
Simple genetic algorithm package written in Java.
; lil-gp:
GARAGe.cps.msu.edu/software/software-index.html#lilgp *
garage.cps.msu.edu/pub/GA/lilgp/ *
; patched lil-gp *:
www.cs.umd.edu/users/seanl/gp/ *
lil-gp is a generic 'C' genetic programming tool. It was written with a number of goals in mind: speed, ease of use and support for a number of options including:
*
arbitrary and user settable topologies for exchange, for a single processor (i.e., you can do multiple population gp experiments on your PC). *
allocated in single, large memory blocks for speed and to avoid swapping. *
multithreading, coevolution, and other tweaks and features.
; Lithos:
www.esatclear.ie/rwallace/lithos.html *
Lithos is a stack based evolutionary computation system. Unlike most EC systems, its representation language is computationally complete, while also being faster and more compact than the S-expressions used in genetic programming. The version presented here applies the system to the game of Go, but can be changed to other problems by simply plugging in a different evaluation function. ANSI C source code is provided.
; PGAPack:
Parallel Genetic Algorithm Library
www-fp.mcs.anl.gov/CCST/research/reports_pre1998/comp_bio/stalk/pgapack.html *
ftp.mcs.anl.gov/pub/pgapack/ *
PGAPack is a general-purpose, data-structure-neutral, parallel genetic algorithm library. It is intended to provide most capabilities desired in a genetic algorithm library, in an integrated, seamless, and portable manner. Key features are in PGAPack V1.0 include:
*
*
*
*
*
*
*
*
*
*
*
*
; PIPE:
www.idsia.ch/rafal/research.html *
ftp.idsia.ch/pub/rafal *
Probabilistic Incremental Program Evolution (PIPE) is a novel technique for automatic program synthesis. The software is written in C. It
*
requires a minimal amount of programming. User-written, application- independent program parts can easily be reused. *
*
*
*
experiments and collecting results in output files. *
*
*
*
The testing tool can also be used to process programs evolved by lil-gp 1.0. *
; Sugal:
www.trajan-software.demon.co.uk/sugal.htm *
Sugal [soo-gall? is the SUnderland Genetic ALgorithm system. The aim of Sugal is to support research and implementation in Genetic Algorithms on a common software platform. As such, Sugal supports a large number of variants of Genetic Algorithms, and has extensive features to support customization and extension.
These are various applications, software kits, etc. meant for research in the field of evolutionary computing. Their ease of use will vary, as they were designed to meet some particular research interest more than as an easy to use commercial package.
; ADATE:
www-ia.hiof.no/rolando/adate_intro.html *
ADATE (Automatic Design of Algorithms Through Evolution) is a system for automatic programming i.e., inductive inference of algorithms, which may be the best way to develop artificial and general intelligence.
The ADATE system can automatically generate non-trivial and novel algorithms. Algorithms are generated through large scale combinatorial search that employs sophisticated program transformations and heuristics. The ADATE system is particularly good at synthesizing symbolic, functional programs and has several unique qualities.
; esep & xesep:
www.iit.edu/elrad/esep.html *
www.iit.edu/elrad/xesep.html *
This is a new scheduler, called Evolution Scheduler, based on Genetic Algorithms and Evolutionary Programming. It lives with original Linux priority scheduler.This means you don't have to reboot to change the scheduling policy. You may simply use the manager program esep to switch between them at any time, and esep itself is an all-in-one for scheduling status, commands, and administration. We didn't intend to remove the original priority scheduler; instead, at least, esep provides you with another choice to use a more intelligent scheduler, which carries out natural competition in an easy and effective way.
Xesep is a graphical user interface to the esep (Evolution Scheduling and Evolving Processes). It's intended to show users how to start, play, and feel the Evolution Scheduling and Evolving Processes, including sub-programs to display system status, evolving process status, queue status, and evolution scheduling status periodically in as small as one mini-second.
; Corewars:
corewars.sourceforge.net/ *
sourceforge.net/project/corewars/ *
Corewars is a game which simulates a virtual machine with a number of programs. Each program tries to crash the others. The program that lasts the longest time wins. A number of sample programs are provided and new programs can be written by the player. Screenshots are available at the Corewars homepage.
; Corewar VM:
www.jedi.claranet.fr/ *
This is a virtual machine written in Java (so it is a virtual machine for another virtual machine !) for a Corewar game.
; GPsys:
www.cs.ucl.ac.uk/staff/A.Qureshi/gpsys.html *
GPsys (pronounced gipsys) is a Java (requires Java 1.1 or later) based Genetic Programming system developed by Adil Qureshi. The software includes documentation, source and executables.
Feature Summary:
*
*
Strongly Typed
#
#
#
*
Save/Load feature
#
requirements
#
#
*
*
Example Problems
#
#
*
*
*
*
*
; Grany-3:
guillaume.cottenceau.free.fr/html/grany.html *
Grany-3 is a full-featured cellular automaton simulator, made in C++ with Gtk--, flex++/bison++, doxygen and gettext, useful to granular media physicists.
; JGProg:
www.linuxstart.com/groovyjava/JGProg/ *
Genetic Programming (JGProg) is an open-source Java implementation of a strongly-typed Genetic Programming experimentation platform. Two example "worlds" are provided, in which a population evolves and solves the problem.
Alife takes yet another approach to exploring the mysteries of intelligence. It has many aspects similar to EC and Connectionism, but takes these ideas and gives them a meta-level twist. Alife emphasizes the development of intelligence through emergent behavior of complex adaptive systems. Alife stresses the social or group based aspects of intelligence. It seeks to understand life and survival. By studying the behaviors of groups of 'beings' Alife seeks to discover the way intelligence or higher order activity emerges from seemingly simple individuals. Cellular Automata and Conway's Game of Life are probably the most commonly known applications of this field. Complex Systems (abbreviated CS) are very similar to alife in the way the are approached, just more general in definition (ie. alife is a type of complex system). Usually complex system software takes the form of a simulator.
These are libraries of code or classes for use in programming within the artificial life field. They are not meant as stand alone applications, but rather as tools for building your own applications.
; Biome:
wosx30.eco-station.uni-wuerzburg.de/martin/biome/ *
Biome is a C++ library aimed at individual-based/agent-based simulations. It is somewhat similar to Swarm, !EcoSim? or Simex but tries to be more efficient and less monolithic without compromising object- oriented design. Currently there is an event based scheduling system, a C++ified Mersenne-Twister RNG, several general analysis classes, some Qt-based GUI classes, a very basic persistence/database framework (used also for parameter storage) and many other small useful things.
; CASE:
www.iu.hio.no/cell/ *
ftp.iu.hio.no/pub/ *
CASE (Cellular Automaton Simulation Environment) is a C++ toolkit for visualizing discrete models in two dimensions: so-called cellular automata. The aim of this project is to create an integrated framework for creating generalized cellular automata using the best, standardized technology of the day.
; !EcoSim?:
offis.offis.uni-oldenburg.de/projekte/ecotools/project_ecotools4.htm *
In !EcoSim? an ecosystem is described by all static and dynamic properties of the individuals involved in the system as well as time varying properties of the environment. Individuals change their state over time or due to internal and external events. The environment is also defined via dynamic objects which can change. Supports on the fly analysis and animation of generated data. It is a C++ class library designed to support individual-oriented modelling and simulation of ecological systems.
; Integrating Modelling Toolkit:
flock.cbl.umces.edu/imt/ *
The Integrating Modelling Toolkit (IMT) is a generic, comprehensive, and extensible set of abstractions allowing definition and use of interoperable model components. Modellers create an IMT "world" made of IMT "agents" that will perform each a particular phase of a modelling task. The core set of IMT agents can describe generic, modular, distributed model components, either native to the IMT or integrating existing simulation toolkits, specialized for tasks that range from simple calculation of functions in an interpreted language to spatially explicit simulation, model optimization, GIS analysis, visualization and advanced statistical analysis. IMT agents are designed to easily "glue" together in higher-level simulations integrating different modelling paradigms and toolkits. The IMT can be easily extended by users and developers through a convenient plug-in mechanism
; MAML:
www.syslab.ceu.hu/maml/ *
The current version of MAML is basically an extension to Objective-C (using the Swarm libraries). It consists of a couple of 'macro-keywords' that define the general structure of a simulation. The remaining must be filled with pure swarm-code. A MAML-to-Swarm (named xmc) compiler is also being developed which compiles the source code into a swarm application.
; Simex:
www.nmsr.labmed.umn.edu/nmsr/simex/ *
The SIMEX package contains a number of C++ classes that make it easier to build discrete-event, micropopulation models. (There is also some support for differential equation models.) It comes with a tuturial, quite a few examples and fairly decent documentation.
; Swarm:
www.swarm.org *
ftp.swarm.org/pub/swarm/ *
The swarm Alife simulation kit. Swarm is a simulation environment which facilitates development and experimentation with simulations involving a large number of agents behaving and interacting within a dynamic environment. It consists of a collection of classes and libraries written in Objective-C and allows great flexibility in creating simulations and analyzing their results. It comes with three demos and good documentation.
These are various applications, software kits, etc. meant for research in the field of artificial life. Their ease of use will vary, as they were designed to meet some particular research interest more than as an easy to use commercial package.
; Achilles:
achilles.sourceforge.net *
Achilles is an evolution simulation based on Larry Yaeger's !PolyWorld?. It uses Hebbian neural networks, and an extremely simplified physical model that allows virtual organisms to interact freely in a simulated environment.
; Avida:
dllab.caltech.edu/avida/ *
The computer program avida is an auto-adaptive genetic system designed primarily for use as a platform in Artificial Life research. The avida system is based on concepts similar to those employed by the tierra program, that is to say it is a population of self-reproducing strings with a Turing-complete genetic basis subjected to Poisson-random mutations. The population adapts to the combination of an intrinsic fitness landscape (self-reproduction) and an externally imposed (extrinsic) fitness function provided by the researcher. By studying this system, one can examine evolutionary adaptation, general traits of living systems (such as self-organization), and other issues pertaining to theoretical or evolutionary biology and dynamic systems.
; BugsX:
ftp.de.uu.net/pub/research/ci/Alife/packages/bugsx/ *
Display and evolve biomorphs. It is a program which draws the biomorphs based on parametric plots of Fourier sine and cosine series and let's you play with them using the genetic algorithm.
; The Cellular Automata Simulation System:
www.cs.runet.edu/dana/ca/cellular.html *
The system consists of a compiler for the Cellang cellular automata programming language, along with the corresponding documentation, viewer, and various tools. Cellang has been undergoing refinement for the last several years (1991-1995), with corresponding upgrades to the compiler. Postscript versions of the tutorial and language reference manual are available for those wanting more detailed information. The most important distinguishing features of Cellang, include support for:
*
cell neighborhoods of any size (though bounded at compile time) and shape; *
*
with each cell; *
agents
lib/CachedMarkup.php (In template 'browse' < 'body' < 'html'):257: Error: Pure virtual
lib/InlineParser.php:336: Warning: Invalid [] syntax ignored: [[ Agents are mobile entities based on a mechanism of (...repeated 3 times)
lib/CachedMarkup.php (In template 'browse' < 'body' < 'html'):257: Error: Pure virtual