Free partial differential equations software for linux

Systems of Ordinary Differential Equations RubySode (Sode.rb) is a Ruby program to generate a Ruby program to solve a single (or a system of) ordinary differential equation(s). A long Taylor series method, pioneered by Prof. Y.F. Chang, who taught at the University of Nebraska in the late 1970s when I was a graduate student there, is used.
The number of Taylor series terms can be specified in the problem file, though it is usually 30.
Enhancements:
- Minir code cleanup. Some tests have been made more meaningful (add, sub, mult, and div).

Simple Equation makes it simple to put equations on the Web. Simple Equation project does not bother the user with the layout of the equation; it just displays it. The focus is on being simple to use.

One of the biggest obstacles to using mathematical expressions on the web is that the user currently needs to worry about layout. Web users should not have to learn a layout engine.

The class is built as a recursive parser. It is pretty easy to add operations to the parser, but it will not scale to a huge set of operations. That is OK, we want to keep things simple. At some point a layout engine may be required for a complexity level. This is not a layout engine.

Currently, only graphical output is generated, but it is hoped that MathML output can be generated automatically if the browser supports it instead of the graphic.

CBL Partial Updater is an AJAX library for PHP. Unlike other libraries, all operations are controlled by the server side.

By using the library, an existing PHP script can be converted to an AJAX application in less than a minute.

GREYCstoration is an image regularization algorithm which processes an image by locally removing small variations of pixel intensities while preserving significant global image features, such as sharp edges and corners.
The most direct application of image regularization is denoising. By extension, GREYCstoration can also be used to inpaint or resize images.
GREYCstoration is based on state-of-the-art methods using nonlinear multi-valued diffusion PDEs (Partial Differential Equations) for image regularization. This kind of method generally outperforms basic image filtering techniques (such as convolution, median filtering, etc.), classically encountered in painting programs.
Other image denoising plugins are available (for instance, Noise Ninja, Neat Image ) but are not free, and the corresponding algorithms are kept secret.
Enhancements:
- This release consumes far less memory than the previous version (2.4.2), so it can deal with very large images.
- There are now processing modes for 16-bit/components and 32-bit float-valued images, as well as multi-thread support.
- A brand new plug-in for the GIMP is provided.

Equation Grapher is a 2D implicit equation grapher.

Equation Grapher allows you to plot equations of the form f(x,y) = g(x,y), with all of the standard operators (log, exp, sqrt, ...) as well as differentiation.

Example equations:

y = sin(x)
x = sin(y)
(xy)^2 = sin(cos(x^2 + y^2))
y = deriv(exp(-x^2/2),x)

Vamos Automotive Simulator project, as the name suggest is an automotive simulation framework with an emphasis on thorough physical modeling and good C++ design. Vamos includes a real-time, first-person, 3D driving application.

Vamos is young and its goals are only partially met. I invite anyone whos interested to contribute.

Thorough physical modeling

Vamos models most major systems of a car. The drivetrain includes a simulation of the engine, clutch, transmission and a limited-slip differential. Tires and suspension are also modeled. If I missed something, let me know.

Good C++ Design

The geometry, track, car and world modules are in their own namespaces. Care has been taken to avoid cyclic dependencies. Standard Library components like strings, vectors and maps are favored over arrays. Some of the modules and classes have aged more gracefully than others. If you see a design area that needs improvement, feel free to pitch in.

Aeris is a nice, light maccy theme for KDE. Enjoy this, and please comment any suggestions you have.

Overall design, QtCurve theme, color scheme, (partial) Emerald theme: SaikoBee

Design suggestions, The freakin sweet buttons for the Emerald theme: Pox "Insane Vector Man"

Special thanks: Snicket, for coming up with the name for this theme!

Time::Elapse is a Perl extension for monitoring time conveniently during tasks.

Time::Elapse is a very simple class with one method: lapse.

Basically, the lapse method eats the brains of the variable, squirrels away whatever value it may have held internally, (much like space aliens are known to do in the movies), and also stores the current time within it. Then, whenever you access the value of the variable, the alien within formats the time differential between when you initialized the variable, and when you printed it, and returns that (along with any value the variable may hold, as well). :-) Every time you print it, you get the updated differential, returned by the method hidden inside the variable itself. The output will be formatted as HH:MM:SS.000000 [in Microseconds].

Frankly it doesnt do much more than time(), but then again the simplest things rarely do.

All it really does is hides the calculations that anyone else would have had to set up manually in a clever way and then produce a reasonably formatted output which lends itself equally well to single-line output or inlining with other text.

SYNOPSIS

Usage

To use Elapse is simplicity itself:

use Time::Elapse;

# somewhere in your program...
Time::Elapse->lapse(my $now);
# or you can do:
# Time::Elapse->lapse(my $now = "processing");

#...rest of program execution

print "Time Wasted: $nown";

To update the description and reset the time counter mid-stream, simply assign to the variable

$now = "parsing";

somewhere in the middle of the program. The new value is stored, while the original time is replaced with the current time.

Sample Output

Output looks something like this, using above code:

Time Wasted: 00:00:05.565763
or
Time Wasted: 00:00:03.016700 [processing]
(more output)
Time Wasted: 00:00:02.003764 [parsing]

Additional example code

You can also use this during a Net::FTP download loop of files to show elapsed time for each files download.

foreach my $file (@files_to_download)
{
# extract localfile name from $file
# ...
Time::Elapse->lapse(my $now = "Downloading $localfile.");
$ftp->get($file, $localfile) or carp("### Could not download $file! $!") and next;
print "Done. Elapsed : $nown";
# ...
}

This can also be a useful trick when youre processing a lot of data from multiple sources.