Lua is a programming language originally designed for extending applications,
but also frequently used as a general-purpose, stand-alone language. Lua
combines simple procedural syntax (similar to Pascal) with powerful data
description constructs based on associative arrays and extensible semantics.
Lua is dynamically typed, interpreted from bytecodes, and has automatic memory
management with garbage collection, making it ideal for configuration,
scripting, and rapid prototyping.
A fundamental concept in the design of Lua is to provide meta-mechanisms for
implementing features, instead of providing a host of features directly in
the language. For example, although Lua is not a pure object-oriented
language, it does provide meta-mechanisms for implementing classes and
inheritance. Lua's meta-mechanisms bring an economy of concepts and keep the
language small, while allowing the semantics to be extended in unconventional
ways. Extensible semantics is a distinguishing feature of Lua.
Lua is implemented as a small library of C functions, written in ANSI C, and
compiles unmodified in all known platforms. The implementation goals are
simplicity, efficiency, portability, and low embedding cost.
Lua is a programming language originally designed for extending applications,
but also frequently used as a general-purpose, stand-alone language. Lua
combines simple procedural syntax (similar to Pascal) with powerful data
description constructs based on associative arrays and extensible semantics.
Lua is dynamically typed, interpreted from bytecodes, and has automatic memory
management with garbage collection, making it ideal for configuration,
scripting, and rapid prototyping.
A fundamental concept in the design of Lua is to provide meta-mechanisms for
implementing features, instead of providing a host of features directly in
the language. For example, although Lua is not a pure object-oriented
language, it does provide meta-mechanisms for implementing classes and
inheritance. Lua's meta-mechanisms bring an economy of concepts and keep the
language small, while allowing the semantics to be extended in unconventional
ways. Extensible semantics is a distinguishing feature of Lua.
Lua is implemented as a small library of C functions, written in ANSI C, and
compiles unmodified in all known platforms. The implementation goals are
simplicity, efficiency, portability, and low embedding cost.
MIX is Donald Knuth's mythical computer as described in his monumental work
The Art Of Computer Programming. As any of its real counterparts, the MIX
features registers, memory cells, an overflow toggle, comparison flags,
input-output devices, and a set of binary instructions executable by its
virtual CPU. You can programme the MIX using an assembly language called
MIXAL, the MIX Assembly Language.
The MIX Development Kit offers an emulation of MIX and MIXAL. The current
version of MDK includes the following applications:
- mixasm A MIXAL compiler, which translates your source files into binary
ones, executable by the MIX virtual machine.
- mixvm A MIX virtual machine which is able to run and debug compiled MIXAL
programs, using a command line interface with readline's line editting
capabilities.
- gmixvm A MIX virtual machine with a GTK+ GUI which allows you running and
debugging your MIXAL programs through a nice graphical interface.
- mixvm.el An elisp program which allows you to run mixvm within an Emacs
GUD window, simultaneously viewing your MIXAL source file in another
buffer.
P2c is a tool for translating Pascal programs into C. The input consists
of a set of source files in any of the following Pascal dialects: HP
Pascal, Turbo/UCSD Pascal, DEC VAX Pascal, Oregon Software Pascal/2,
Macintosh Programmer's Workshop Pascal, Sun/Berkeley Pascal, Texas
Instruments Pascal, Apollo Domain Pascal. Modula-2 syntax is also
supported. Output is a set of .c and .h files that comprise an
equivalent program in any of several dialects of C. Output code may be
kept machine- and dialect independent, or it may be targeted to a
specific machine and compiler. Most reasonable Pascal programs are
converted into fully functional C which will compile and run with no
further modifications, although p2c sometimes chooses to generate
readable code at the expense of absolute generality. P2c endeavors to
insert notes and warning messages into the output code to point out
areas which may require human intervention. Output code is arranged to
be readable and efficient, and to make use of C idioms wherever
possible. The main goal of the translation is to produce C files which
are pleasant and "natural" enough to be acceptable as the new source
files for a program. In a pinch, p2c will also serve as an ad hoc Pascal
compiler. The p2cc script makes it easy to use p2c as a compiler.
This module was created as a low-level inteface to any IMAP server. It
was built to be a 'clear box' solution to working with an IMAP
environment. The idea is that anything an IMAP client should be able
to do, and any information available via the IMAP specs, should be
available to a client interface and user. This way, the full strength
of the IMAP protocol and data can be utilized, ideally in the most
network-efficient mannger possible, rather than being contrained only
to a subset of commands or data-limited responses. If the server says
it, the client should be able to see it.
This module also takes steps to be able to handle anticipated
situations for the user rather than forcing a per-implementation
behavior for such expected events, such as referrals. IMAP::Client
will fully support referrals, and will transparently handle them for
whatever command is issued to them (so long as the referral s for
anonymous or the same user with the same password - a new user or
different password would require a new username/password to be
obtained. As of 0.01, this is not supported, however the framework is
down.
Before a calculation can be performed on a parallel computer, it must
first be decomposed into tasks which are assigned to different processors.
Efficient use of the machine requires that each processor have about the
same amount of work to do and that the quantity of interprocessor
communication is kept small. Finding an optimal decomposition is provably
hard, but due to its practical importance, a great deal of effort has been
devoted to developing heuristics for this problem. The decomposition
problem can be addressed in terms of graph partitioning.
Chaco implements a variety of algorithms for graph partitioning and is
used at most of the major parallel computing centers around the world to
simplify the development of parallel applications, and to ensure that high
performance is obtained. Chaco has contributed to a wide variety of
computational studies including investigation of the molecular structure
of liquid crystals, evaluating the design of a chemical vapor deposition
reactor and modeling automobile collisions.
Note: this port includes a patch provided by Walter Landry for use within
MBDyn.
At the suggestion of Linas Vepstas on the Gnu Scientific Library (GSL) list,
this GPL'd suite of random number tests will be named "Dieharder". Using a
movie sequel pun for the name is a double tribute to George Marsaglia, whose
"Diehard battery of tests" of random number generators has enjoyed years of
enduring usefulness as a test suite.
The dieharder suite is more than just the diehard tests cleaned up and given a
pretty GPL'd source face in native C: tests from the Statistical Test Suite
(STS) developed by the National Institute for Standards and Technology (NIST)
are being incorporated, as are new tests developed by rgb. Where possible,
tests are parametrized and controllable so that failure, at least, is
unambiguous.
A further design goal is to provide some indication of *why* a generator fails
a test, where such information can be extracted during the test process and
placed in usable form. For example, the bit-distribution tests should
(eventually) be able to display the actual histogram for the different bit
n-tuplets.
Dieharder is by design extensible. It is intended to be the "Swiss army knife
of random number test suites", or if you prefer, "the last suite you'll ever
ware" for testing random numbers.
Math::Sequence defines a class for simple mathematic sequences with a
recursive definition such as x_(n+1) = 1 / (x_n + 1). Creation of a
Math::Sequence object is described below in the paragraph about the
constructor.
Math::Sequence uses Math::Symbolic to parse and modify the recursive
sequence definitions. That means you specify the sequence as a string
which is parsed by Math::Symbolic. Alternatively, you can pass the
constructor a Math::Symbolic tree directly.
Because Math::Sequence uses Math::Symbolic for its implementation, all
results will be Math::Symbolic objects which may contain other variables
than the sequence variable itself.
Each Math::Sequence object is an iterator to iterate over the elements of
the sequence starting at the first element (which was specified by the
starting element, the second argument to the new() constructor). It offers
facilities to cache all calculated elements and access any element
directly, though unless the element has been cached in a previous
calculation, this is just a shortcut for repeated use of the iterator.
TestU01 is a software library, implemented in the ANSI C language, and
offering a collection of utilities for the empirical statistical testing
of uniform random number generators.
The library implements several types of random number generators in generic
form, as well as many specific generators proposed in the literature or
found in widely-used software. It provides general implementations of the
classical statistical tests for random number generators, as well as several
others proposed in the literature, and some original ones. These tests can
be applied to the generators predefined in the library and to user-defined
generators. Specific tests suites for either sequences of uniform random
numbers in [0,1] or bit sequences are also available. Basic tools for
plotting vectors of points produced by generators are provided as well.
Additional software permits one to perform systematic studies of the
interaction between a specific test and the structure of the point sets
produced by a given family of random number generators. That is, for a given
kind of test and a given class of random number generators, to determine how
large should be the sample size of the test, as a function of the generator's
period length, before the generator starts to fail the test systematically.
LyX is a document processor that encourages an approach to writing
based on the structure of your documents (WYSIWYM) and not simply
their appearance (WYSIWYG).
LyX combines the power and flexibility of TeX/LaTeX with the ease
of use of a graphical interface. This results in world-class support
for creation of mathematical content (via a fully integrated equation
editor) and structured documents like academic articles, theses,
and books. In addition, staples of scientific authoring such as
reference list and index creation come standard. But you can also
use LyX to create a letter or a novel or a theatre play or film
script. A broad array of ready, well-designed document layouts are
built in.
LyX is for people who want their writing to look great, right out
of the box. No more endless tinkering with formatting details,
"finger painting" font attributes or futzing around with page
boundaries. You just write. On screen, LyX looks like any word
processor; its printed output - or richly cross-referenced PDF,
just as readily produced - looks like nothing else.