Free ordinary software for linux

Modest Ordinary Differential Equation Library is a C++ library to model rate equations.
MODEL is a numeric simulation library written during my PhD to simulate systems of rate equations describing Vertical Cavity Surface Emitting Lasers (VCSELs). I decided to write one myself after looking at existing libraries and deciding that they were either too complicated to use (having a target user base of mathematicians) or too opaque (i like to know what the code is doing, exactly).
Since most of my programming before has been done in C/C++, what you see here is a C++ library composed of various interacting classes which have the following main functionalities:
deterministic integration of any system of well-behaved differential equations.
- stochastic integration of these systems, with the possibility of specifying the correlations present in the noise
- nonlinear rootfinder, to find stationary solutions
- eigenvalue determination, for stability analysis
- easy time modulation of input parameters
- diverse data collecting classes for data analysis
- Small signal analysis (first order)
The following will be added RSN:
- Fourier transforms, for spectral analysis (although this can be done in an external program)
- Periodic solution finder
It furthermore provides a numerical vector class, vectorfunction classes, LU solver and random generators.
As I developed it using publicly available resources, GNU/Linux and other GPLed software, I decided that it should be GPL as well. However (Oh no, a "however" ! Lets hope it does not invalidate the copyleft), I would very much appreciate it if you let me know if you have used MODEL in any of your applications/simulations/research and provide a reference (this way, I can refer to your work, too).
At the moment, MODEL has the rather arbitrary version number 1.0. Meaning it is useful. Period. Some interfaces (especially the stochastics) might still change, and I would like to add some ieee floating point exception trapping to avoid silly numerical errors.
Enhancements:
- Add features/limitations/changes here

Dircproxy is an IRC proxy server ("bouncer"). Dircproxy is designed for people who use IRC from lots of different workstations or clients, but wish to remain connected and see what they missed while they were away.
You connect to IRC through dircproxy, and it keeps you connected to the server, even after you detach your client from it.
While youre detached, it logs channel and private messages as well as important events, and when you reattach itll download those logs to you using ordinary IRC protocol.
Main features:
- Runs on console, as a daemon or from inetd.
- Able to proxy many simultaneous users and IRC connections.
- Uses IRC server passwords to authenticate.
- Remains connected to server when you detach. To reattach you just use the IRC server password again, no special commands!
- Completely non-blocking throughout.
- Can connect to servers that also require a password.
- Can have a list of servers on the same network to connect to, it will cycle this list.
- Throttles data sent to server to ensure you are never flooded off.
- Can check servers to make sure they dont become "stoned".
- Reconnects to servers if connection is dropped.
- Can automatically join channels for you on first attach.
- Rejoins channels if you are kicked off.
- Can leave channels when you detach and rejoin when you come back.
- Can take measures to ensure you dont appear "idle" on IRC.
- Host and password based security.
- Easy to configure and get running.

Clorox is shared memory for AJAX applications. Clorox provides data structures that look exactly like ordinary JavaScript objects but that actually make AJAX RPC calls behind the scenes to fetch data.
Since many web applications can be thought of as viewers over structured data (grids of map cells, arrays of email messages, etc), and RPCs and callback functions are a pain, this abstraction makes writing applications much easier. Additionally, Clorox makes it simple to define data caching and prefetching policies to boost performance.
No new languages: Clorox applications are 100% JavaScript, and they play well with other toolkits.
Clorox is a new way of writing highly-interactive web applications. Its based on a single observation: that many web applications serve as viewers over structured data. Email clients display lists of messages. Mapping applications display grids of map cells. Search auto-complete applications display nodes in a trie containing completion strings. Today, such applications are often written using AJAX. Clorox argues that we can make these applications both higher performance and easier to write by exploiting the underlying logical structure of their data, a structure which is ignored by AJAX. (Note that the logical structure of the data is entirely separate from their physical representation on the server.)
In place of the asynchronous, RPC-based abstraction furnished by AJAX, Clorox provides the illusion of synchronously-accessed data structures shared between the web browser and web server, which is to say, it provides a shared memory abstraction. These data structures look exactly like ordinary JavaScript objects on the client side, allowing programmers to focus on what they do best (writing compelling web applications) without worrying about data locality, message reordering, callback functions, or data prefetching. Additionally, to free programmers from concerns over locking, Clorox allows multiple operations on these data structures to be grouped into atomic actions.
Clorox applications are 100% JavaScript: application programmers write JavaScript code which is processed by the Clorox compiler into more JavaScript. Clorox applications can thus run on any modern web browser without the need for special plugins, and your code will never be locked up in some proprietary format.
We think the best way to learn to use a new piece of software is by playing around with it, so the rest of this document will explain how to build a sample application using the Clorox system.
Enhancements:
- A small bug was fixed to correct a problem with dim() methods.
- The homepage URL was updated.

Model Builder is a graphical tool for designing, simulating, and analyzing mathematical models consisting of a system of ordinary differential equations (ODEs).
Main features:
- Equation-based model definition. No need to learn to program to define and run your models. Just type-in you differential equations
- Graphic output of simulation. You can save the graphics in the most common formats: png, svg, pdf, etc.
- Spreadsheet view of the results. From the spreadsheet you can make customized plots from your variables. You can also export your data to a .csv text file
- Latex rendering of your system of equations.
- Intuitive graphical interface.
- Uncertainty analysis module (coming soon!)

DOLFIN project is the C++ interface of FEniCS, providing a consistent PSE (Problem Solving Environment) for solving ordinary and partial differential equations.
Main features:
- Simple, consistent and intuitive object-oriented API
- Automatic and efficient evaluation of variational forms through FFC
- Automatic and efficient assembly of linear systems
- Support for general families of finite elements, including continuous and discontinuous Lagrange finite elements of arbitrary order on triangles and tetrahedra through FIAT
- Support for arbitrary mixed elements, including Taylor-Hood
- High-performance parallel linear algebra through PETSc with simple C++ wrappers
- Triangular and tetrahedral meshes, including adaptive mesh refinement and mesh hierarchies
- Multi-adaptive mcG(q)/mdG(q) and mono-adaptive cG(q)/dG(q) ODE solvers
- Support for a range of output formats for post-processing, including DOLFIN XML, MATLAB, Octave, OpenDX, GiD, Tecplot and Paraview/VTK
- SWIG-generated Python interface PyDOLFIN (experimental) in addition to the standard C++ interface

Sort::Half::Maker is a Perl module to create half-sort subs easily.

SYNOPSIS

use Sort::Half::Maker qw(make_halfsort);

$sub = make_halfsort(
start => [ qw(x y z) ],
end => [ qw(a b c) ],
fallback => sub { $_[0] cmp $_[1] },
);
@list = sort $sub qw(a y f h w z b t x);
# qw(x y z f h t w a b)

Before anything, what it a half-sort?

A half-sort is a sort subroutine defined by a starting list, an ending list and an ordinary sort subroutine. Elements in the starting list always go first in comparison to others and keep the original order. Elements in the ending list always go last in comparison to others and keep their original order. The remaining elements are sorted via the given ordinary sort subroutine.

An example, please?

Imagine we want to sort the list of key/value pairs of a hash, such that qw(name version abstract license author) come first and qw(meta-spec) comes last, using case-insensitive comparison in-between. With this module, this is done so:

$sub = make_halfsort(
start => [ qw(name version abstract license author) ],
end => [ qw(meta-spec) ],
fallback => sub { lc $_[0] cmp lc $_[1] }
);
my @pairs = map { ($_, $h{$_}) } sort $sub keys(%h);

Why is it good for?

I dont see many uses for it. I played with the concept while writing a patch to improve META.yml generation by ExtUtils::MakeMaker. There we wanted to dump some keys (like name, version, abstract, license, author) before and then the ones the module author provided as extra information.

FUNCTIONS

make_halfsort
$sub = make_halfsort(start => @start_list,
end => @end_list,
fallback => &sort_sub
);
@sorted = sort $sub @unsorted;

Builds a sort subroutine which can be used with sort. It splits the sorted list into (possibly) three partitions: the elements contained in @start_list, the elements contained in @end_list and the remaining ones. For the elements in @start_list and @end_list, the list order is preserved. For the remaining ones, the given sort sub (or the default) is used.

If fallback is ommited, it defaults to use the sort sub sub ($$) { $_[0] cmp $_[1] }.

The arguments start or end may be ommited as well. But if you omit both, you could have done it without a half-sort.