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.
mess822 is a library for parsing Internet mail messages. The mess822
package contains several applications that work with qmail:
* ofmipd rewrites messages from dumb clients. It supports a database
of recognized senders and From lines, using cdb for fast lookups.
* new-inject is an experimental new version of qmail-inject. It
includes a flexible user-controlled hostname rewriting mechanism.
* iftocc can be used in .qmail files. It checks whether a known
address is listed in To or Cc.
* 822header, 822field, 822date, and 822received extract various
pieces of information from a mail message.
* 822print converts a message into an easier-to-read format.
mess822 supports the full complexity of RFC 822 address lists, including
address groups, source routes, spaces around dots, etc. It also supports
common RFC 822 extensions: backslashes in atoms, dots in phrases,
addresses without host names, etc. It extracts each address as an
easy-to-use string, with a separate string for the accompanying comment.
mess822 converts RFC 822 dates into libtai's struct caltime format. It
supports numeric time zones, the standard old-fashioned time zones, and
many nonstandard time zones.
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.
This module provides basic functions used in descriptive statistics. It
borrows very heavily from Statistics::Descriptive::Full (which is included
with Statistics::Descriptive) with one major difference. This module is
optimized for discretized data e.g. data from an A/D conversion that has a
discrete set of possible values. E.g. if your data is produced by an 8 bit
A/D then you'd have only 256 possible values in your data set. Even though
you might have a million data points, you'd only have 256 different values
in those million points. Instead of storing the entire data set as
Statistics::Descriptive does, this module only stores the values it's seen
and the number of times it's seen each value.
For very large data sets, this storage method results in significant speed
and memory improvements. In a test case with 2.6 million data points from
a real world application, Statistics::Descriptive::Discrete took 40
seconds to calculate a set of statistics instead of the 561 seconds
required by Statistics::Descriptive::Full. It also required only 4MB of
RAM instead of the 400MB used by Statistics::Descriptive::Full for the
same data set.
SuperLU_MT (version 2.0)
========================
SuperLU_MT contains a set of subroutines to solve a sparse linear system
A*X=B. It uses Gaussian elimination with partial pivoting (GEPP).
The columns of A may be preordered before factorization; the
preordering for sparsity is completely separate from the factorization.
SuperLU_MT is a parallel extension to the serial SuperLU library.
SuperLU_MT is implemented in ANSI C, with multithreading extension,
for example, using POSIX threads. Currently, only the LU factorization
routine, which is the most time-consuming part of the solution process,
is parallelized on machines with a shared address space. The other
routines, such as column preordering and the forward and back substitutions
are performed sequentially. This "alpha" release contains only
double-precision real data type.
Xiaoye S. Li, Lawrence Berkeley National Lab, xiaoye@nersc.gov
James Demmel, Univ. of California Berkeley, demmel@cs.berkeley.edu
John R. Gilbert, Xerox Palo Alto Research Center, gilbert@parc.xerox.com
NOTE: This library has to be linked with BLAS or a thread safe replacement.