GNU/Linux AI & Alife HOWTO, John Eikenberry [best books to read for self development TXT] 📗
- Author: John Eikenberry
- Performer: -
Book online «GNU/Linux AI & Alife HOWTO, John Eikenberry [best books to read for self development TXT] 📗». Author John Eikenberry
GCL is maximally efficient on such calls. It has a conservative
garbage collector which allows great freedom for the C compiler
to put Lisp values in arbitrary registers.
It has a source level Lisp debugger for interpreted code, with
display of source code in an Emacs window. Its profiling tools
(based on the C profiling tools) count function calls and the
time spent in each function.
GNU Prolog
� Web site: gnu-prolog.inria.fr
� Web site: pauillac.inria.fr/~diaz/gnu-prolog/
GNU Prolog is a free Prolog compiler with constraint solving
over finite domains developed by Daniel Diaz.
GNU Prolog accepts Prolog+constraint programs and produces
native binaries (like gcc does from a C source). The obtained
executable is then stand-alone. The size of this executable can
be quite small since GNU Prolog can avoid to link the code of
most unused builtin predicates. The performances of GNU Prolog
are very encouraging (comparable to commercial systems).
Beside the native-code compilation, GNU Prolog offers a
classical interactive interpreter (toplevel) with a debugger.
The Prolog part conforms to the ISO standard for Prolog with
many extensions very useful in practice (global variables, OS
interface, sockets,…).
GNU Prolog also includes an efficient constraint solver over
Finite Domains (FD). This opens contraint logic pogramming to
the user combining the power of constraint programming to the
declarativity of logic programming.
IBAL
� Web site: www.eecs.harvard.edu/~avi/IBAL/
IBAL (pronounced “eyeball”) is a general-purpose language for
probabilistic modeling, parameter estimation and decision
making. It generalizes Bayesian networks, hidden Markov models,
stochastic context free grammars, Markov decision processes, and
allows many new possibilities. It also provides a convenient
programming-language framework with libraries, automatic type
checking and so on.
lush
� Web site: lush.sourceforge.net
Lush is an object-oriented programming language designed for
researchers, experimenters, and engineers interested in large-scale numerical and graphic applications. Lush is designed to be
used in situations where one would want to combine the
flexibility of a high-level, weakly-typed interpreted language,
with the efficiency of a strongly-typed, natively-compiled
language, and with the easy integration of code written in C,
C++, or other languages.
Maude
� Web site: maude.cs.uiuc.edu
Maude is a high-performance reflective language and system
supporting both equational and rewriting logic specification and
programming for a wide range of applications. Maude has been
influenced in important ways by the OBJ3 language, which can be
regarded as an equational logic sublanguage. Besides supporting
equational specification and programming, Maude also supports
rewriting logic computation.
Mercury
� Web page: www.cs.mu.oz.au/research/mercury/
Mercury is a new, purely declarative logic programming language.
Like Prolog and other existing logic programming languages, it
is a very high-level language that allows programmers to
concentrate on the problem rather than the low-level details
such as memory management. Unlike Prolog, which is oriented
towards exploratory programming, Mercury is designed for the
construction of large, reliable, efficient software systems by
teams of programmers. As a consequence, programming in Mercury
has a different flavor than programming in Prolog.
Mozart
� Web page: www.mozart-oz.org/
The Mozart system provides state-of-the-art support in two
areas: open distributed computing and constraint-based
inference. Mozart implements Oz, a concurrent object-oriented
language with dataflow synchronization. Oz combines concurrent
and distributed programming with logical constraint-based
inference, making it a unique choice for developing multiagent
systems. Mozart is an ideal platform for both general-purpose
distributed applications as well as for hard problems requiring
sophisticated optimization and inferencing abilities. We have
developed applications in scheduling and timetabling, in
placement and configuration, in natural language and knowledge
representation, multiagent systems and sophisticated
collaborative tools.
SWI Prolog
� Web page: www.swi-prolog.org
SWI is a free version of prolog in the Edinburgh Prolog family.
It is licensed under the LGPL with many nice features for an AI
researcher, such as; a large library of builtin predicates, a
module system, garbage collection, a two-way interface with the
C/C++ language, coroutines, multithreading, multiple constraint
library, the XPCE graphics toolkit, plus many more.
Push
� Web site: hampshire.edu/lspector/push.html
Push is a programming language intended primarily for use in
evolutionary computation systems (such as genetic programming
systems), as the language in which evolving programs are
expressed. Push has an unusually simple syntax, which
facilitates the development (or evolution) of mutation and
recombination operators that generate and manipulate programs.
Despite this simple syntax, Push provides more expressive power
than most other program representations that are used for
program evolution.
Includes several libraries/systems for working with GP (all info
on the Push page). PushGP is a genetic programming system that
evolves programs in the Push programming language. Pushpop is an
“autoconstructive evolution” system that also evolves Push
programs. SwarmEvolve 2.0 is an autoconstuctive evolution
system in which flying agents, controlled by Push programs,
evolve in a 3D environment.
Kali Scheme
� Web site: http://community.schemewiki.org/kali-scheme/
Kali Scheme is a distributed implementation of Scheme that
permits efficient transmission of higher-order objects such as
closures and continuations. The integration of distributed
communication facilities within a higher-order programming
language engenders a number of new abstractions and paradigms
for distributed computing. Among these are user-specified load-balancing and migration policies for threads, incrementally-linked distributed computations, agents, and parameterized
client-server applications. Kali Scheme supports concurrency and
communication using first-class procedures and continuations. It
integrates procedures and continuations into a message-based
distributed framework that allows any Scheme object (including
code vectors) to be sent and received in a message.
RScheme
� Web site:www.rscheme.org
RScheme is an object-oriented, extended version of the Scheme
dialect of Lisp. RScheme is freely redistributable, and offers
reasonable performance despite being extraordinarily portable.
RScheme can be compiled to C, and the C can then compiled with a
normal C compiler to generate machine code. By default, however,
RScheme compiles to bytecodes which are interpreted by a
(runtime) virtual machine. This ensures that compilation is fast
and keeps code size down. In general, we recommend using the
(default) bytecode code generation system, and only compiling
your time-critical code to machine code. This allows a nice
adjustment of space/time tradeoffs. (see web site for details)
Scheme 48
� Web site: s48.org/
Scheme 48 is a Scheme implementation based on a virtual machine
architecture. Scheme 48 is designed to be straightforward,
flexible, reliable, and fast. It should be easily portable to
32-bit byte-addressed machines that have POSIX and ANSI C
support. In addition to the usual Scheme builtin procedures
and a development environment, library software includes support
for hygienic macros (as described in the Revised^4 Scheme
report), multitasking, records, exception handling, hash tables,
arrays, weak pointers, and FORMAT. Scheme 48 implements and
exploits an experimental module system loosely derived from
Standard ML and Scheme Xerox. The development environment
supports interactive changes to modules and interfaces.
SCM (Scheme)
� Web site: www-swiss.ai.mit.edu/~jaffer/SCM.html
SCM conforms to the Revised^4 Report on the Algorithmic Language
Scheme and the IEEE P1178 specification. Scm is written in C. It
uses the following utilities (all available at the ftp site).
� SLIB (Standard Scheme Library) is a portable Scheme library
which is intended to provide compatibility and utility
functions for all standard Scheme implementations, including
SCM, Chez, Elk, Gambit, MacScheme, MITScheme, scheme->C,
Scheme48, T3.1, and VSCM, and is available as the file
slib2c0.tar.gz. Written by Aubrey Jaffer.
� JACAL is a symbolic math system written in Scheme, and is
available as the file jacal1a7.tar.gz.
� Interfaces to standard libraries including REGEX string
regular expression matching and the CURSES screen management
package.
� Available add-on packages including an interactive debugger,
database, X-window graphics, BGI graphics, Motif, and Open-Windows packages.
� A compiler (HOBBIT, available separately) and dynamic linking
of compiled modules.
Shift
� Web site: www.path.berkeley.edu/shift/
Shift is a programming language for describing dynamic networks
of hybrid automata. Such systems consist of components which
can be created, interconnected and destroyed as the system
evolves. Components exhibit hybrid behavior, consisting of
continuous-time phases separated by discrete-event transitions.
Components may evolve independently, or they may interact
through their inputs, outputs and exported events. The
interaction network itself may evolve.
YAP Prolog
� Web site: www.ncc.up.pt/~vsc/Yap/
� Sourceforge site: sourceforge.net/projects/yap/
YAP is a high-performance Prolog compiler developed at
LIACC/Universidade do Porto. Its Prolog engine is based in the
WAM (Warren Abstract Machine), with several optimizations for
better performance. YAP follows the Edinburgh tradition, and is
largely compatible with DEC-10 Prolog, Quintus Prolog, and
especially with C-Prolog. Work on the more recent version of YAP
strives at several goals:
� Portability: The whole system is now written in C. YAP
compiles in popular 32 bit machines, such as Suns and Linux
PCs, and in a 64 bit machines, the Alphas running OSF Unix
and Linux.
� Performance: We have optimised the emulator to obtain
performance comparable to or better than well-known Prolog
systems. In fact, the current version of YAP performs better
than the original one, written in assembly language.
� Robustness: We have tested the system with a large array of
Prolog applications.
� Extensibility: YAP was designed internally from the beginning
to encapsulate manipulation of terms. These principles were
used, for example, to implement a simple and powerful C-interface. The new version of YAP extends these principles to
accomodate extensions to the unification algorithm, that we
believe will be useful to implement extensions such as
constraint programming.
� Completeness: YAP has for a long time provided most builtins
expected from a Edinburgh Prolog implementation. These
include I/O functionality, database operations, and modules.
Work on YAP aims now at being compatible with the Prolog
standard.
� Openess: We would like to make new development of YAP open to
the user community.
� Research: YAP has been a vehicle for research within and
outside our group. Currently research is going on on
parallelisation and tabulation, and we have started work to
support constraint handling.
8. Missing & Dead
This is my area for old or bad entries. The MIA section is for entires
for which I no longer have a valid home page. If you have any
information regarding where I can find these now please let me know.
The Dead section is for projects that seem dead. Moving them here
allows me to keep my the main sections clean while allowing for
interested parties to correct me in which case I can just move it
back.
8.1. MIA - Projects missing linkage.
CASE
� Web site: www.iu.hio.no/~cell/
� FTP site: 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.
The Cellular Automata Simulation System
� Web site: staff.vbi.vt.edu/dana/ca/cellular.shtml
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:
� any number of dimensions;
� compile time specification of each dimensions size; cell
neighborhoods of any size (though bounded at compile time)
and shape;
� positional and time dependent neighborhoods;
� associating multiple values (fields), including arrays, with
each cell;
� associating a potentially unbounded number of mobile agents [
Agents are mobile entities based on a mechanism of the same
name in the Creatures system,
Comments (0)