Free mathematics software for linux

TheCurves is an application that plots a parameterized family of curves based on algebraic formulas specified by the user. This project is meant as an educational tool for mathematics, physics, and engineering.
When the program is run as an applet in a Web page, the plot parameters and formulas are configurable by HTML and dynamically scriptable, so that the applet can be initialized to present a specific plot when the page is opened or to change plots when the user clicks on a control in the Web page.
Enhancements:
- This version now uses the ant build system.

Womcat Bookmarks is a project that maintains Web bookmarks in a set of hierarchical folders.
It can output the bookmarks as an HTML page and as an RSS 2.0 file that can be placed on a Web site.
The RSS file maps folder names into the "category" element. It can download other RSS files, treating them as categorized bookmarks to create a local database of Web bookmarks that can be browsed by subject.
It supports RSS discovery by allowing posting RSS file URLs as new items.
It also acts as a basic RSS feed reader. It also includes a Weak Subscriptions feature, which is a bit like a personalized version of BlogDex.
Main features:
- Womcat Bookmarks are intended to point to other Womcat Bookmarks. Womcat allows for 2 types of RSS items: recommendations and referrals. A recommendation is an RSS item that points to an ordinary web page. A referral is an RSS item that points to another RSS file (which may or may not be generated by Womcat Bookmarks). An XML extension element http://www.womcat.org/:type is used to distinguish between these two possibilities.
- Womcat Bookmarks is subject-oriented. RSS puts subjects in the element separated by forward slashes. Womcat Bookmarks requires that every recommendation be contained in a subject. Subjects can also be contained in each other. So if subject Algebra is contained in subject Mathematics, then the category will be Mathematics/Algebra.
- Although Womcat Bookmarks subjects for one user form a hierarchy, it cannot be expected that different users will have equivalent or even consistent hierarchies. The most that can be hoped for is that different users might use the same titles for individual subjects. Thus Programming Languages/C is not a very good hierarchy, because "C" by itself is potentially ambiguous. Better is Programming Languages/C Programming Language. In effect subjects are globally considered to live in a flat namespace, and their titles should be unambiguous in a global context without any dependence on position in a users hierarchy. The end result is to facilitate merging of Womcat Bookmarks (i.e. RSS data) from different users such that they can be usefully browsed by subject.
- Womcat Bookmarks are considered to be an accumulating collection of bookmarks, not a transient collection of news items, with items only being deleted if they cease to be relevant (or cease to exist). This is problematic when Womcat is used to read RSS files that may or may not be accumulative or transient in intent. I propose to add an extension element to deal with this, along the lines of specifying a period that the file covers, and optionally another link to a different RSS file that covers that period, e.g. "1 month" for a file that only contains links added up to a month ago, "forever" for a file that contains all current bookmarks. This will also be useful as a way for RSS readers not to have to re-read an accumulated bookmarks file that has grown very large.
Enhancements:
- Various improvements to user interface: ability to stop downloads, pre-delete multiple mentions, add more links between objects in pages. Also update versions of libraries used by the application.

ATGeogebra provides a simple archetype product to display GeoGebra files.

GeoGebra is a free and multi-platform dynamic mathematics software for schools that joins geometry, algebra and calculus .

If you have any interest in educational technology, you should take a look at this fine piece of software: http://www.geogebra.org

The basic idea of ATGeogebra is to be able to show Geogebra worksheet files ( .ggb ) within a plone site.

The .ggb files have to be loaded with Geogebras java applet and the product does that for you.

The software jar files are inside the product’s skins directory and all you have to do is to create a "Geogebra Activity" item and upload the .ggb file.

You will find a sample Geogebra worksheet ( .ggb ) inside the product’s samples directory ( same as shown in the screenshot above ).

If you use CMFContentPanels, a special viewlet will be installed.

This is a initial release. Its very simple, but fully functional.

Amanith Framework is a Crossplatform & Opensource C++ Vector Graphic Framework.
Amanith gives to developers a complete and reliable set of classes to work with geometric elements (lines, curves, paths, meshes, and so on); it provides many powerful modelling operators (like cut, join, flatten and so on) and, at the same time, the fastest rendering layer totally built on top of OpenGL.
Some other useful classes included in Amanith complete the framework with: fonts and pixelmaps support, hierarchycal animations, fast and robust tesselation, bitmap to vector tracing, mathematics and calculus functions, matrices, distance and intersection queries.
Main features:
Open Sourced!
- Open source has made Amanith possible, so we wanna Amanith to be open source too.
- This mean that Amanith source code is fully available for everyone.
Cross Platform
- Same source tree can be compiled without modifications under multiple targets.
- Linux, Win32, Mac, FreeBSD, NetBSD, OpenBSD, Solaris, IRIX, AIX are only few of them.
Modular
- All the framework is heavily based on a light plug-in system.
- This make fast and easy to include or esclude everything you want.
Standards adherence
- The Amanith philosophy is to support many open standards as possible.
- Png, Jpeg, Svg, Xml, OpenGl, Ansi c++, and many others.

Geomview is an interactive 3D viewing program for Unix. Geomview lets you view and manipulate three-dimensional objects: you use the mouse to rotate, translate, zoom in and out, and so on.

Geomview can be used as a standalone viewer for static objects or as a display engine for other programs which produce dynamically changing geometry. Geomview can display objects described in a variety of file formats. Geomview comes with a wide selection of example objects, and you can create your own objects too.

Geomview runs on most Unix platforms, including GNU/Linux. Geomview can run under Microsoft Windows using Cygwin. Geomview is free software available under the terms of the GNU Lesser General Public License (GPL).

You can also use Geomview to handle the display of data coming from another program that is running simultaneously. As the other program changes the data, the Geomview image reflects the changes. Programs that generate objects and use Geomview to display them are called external modules. External modules can control almost all aspects of Geomview. The idea here is that many aspects of the display and interaction parts of geometry software are independent of the geometric content and can be collected together in a single piece of software that can be used in a wide variety of situations. The author of the external module can then concentrate on implementing the desired algorithm and leave the display aspects to Geomview. Geomview comes with a collection of sample external modules, and the manual describes how to write your own.

Geomview allows multiple independently controllable objects and cameras. It provides interactive control for motion, appearances (including lighting, shading, and materials), picking on an object, edge or vertex level, snapshots in many image file, PostScript, or Renderman RIB format, and adding or deleting objects is provided through direct mouse manipulation, control panels, and keyboard shortcuts.

Geomview supports the following simple data types: polyhedra with shared vertices (.off), quadrilaterals, rectangular meshes, vectors, and Bezier surface patches of arbitrary degree including rational patches. Object hierarchies can be constructed with lists of objects and instances of object(s) transformed by one or many 4x4 matrices. Arbitrary portions of changing hierarchies may be transmitted by creating named references.

The full specification for object file formats is in the OOGL (Object Oriented Graphics Language) Reference section of the Geomview manual. If you already have Geomview you might want to try out the OOGL tutorial.

Geomview can be used as a Mathematica graphics output device; this makes viewing Mathematica graphics much more interactive. The same is true for Maple. Geomview began as an effort at the Geometry Center at the University of Minnesota to provide interactive geometry software which is particularly appropriate for mathematics research and education. In particular, Geomview can display objects in hyperbolic and spherical space as well as Euclidean space.

Time::Skew is a Perl module that computes local clock skew with respect to a remote clock.

SYNOPISI

use Time::Skew

# Init Convex Hull and timing data
my $hull=[];
my $result={};

# Iterate data point introduction
Time::Skew::convexhull($result,$datapoint,$hull);

This module supports the computation of the skew between two clocks: the (relative) skew is the speed with which two clocks diverge. For instance, if yesterday two clocks, at the same time, showed respectively 10:00 and 10:05, while today when the former shows 10:00 the latter shows 10:04, we say that their relative skew is 1 minute/24 hours, roughly 7E-4.

The module contains one single subroutine, which accepts as input a pair of timestamps, associated to a message from host A to host B: the timestamps correspond to the time when the message was sent, and to the time when message is received. Each timestamp reflects the value of the local clock where the operation takes place: the clock of host A for the send, the clock of B for the receive.

Please note that the module does _not_ contain any message exchange facility, but only the mathematics needed to perform the skew approximation, once timestamps are known.

The subroutine takes as argument:

a reference to a hash where values related to the timing of the network path from A to B;
a 2-elems array (a data point in the sequel) containing the timestamp of the receive event, and the differece between the send timestamp and the receive timestamp for one message;
a stack containing some data points, those that form the convex hull.

The usage is very simple, and is illustrated by the following example:

#!/usr/bin/perl -w
use strict;
use Time::Skew;

# Initialize data
my $hull=[];
my $result={};
while ( 1 ) {
# Exchange message and acquire a new data point
my $datapoint = acquire();
# Call the convexhull subroutine
Time::Skew::convexhull($result,$datapoint,$hull);
# After first message some results are still undefined
( defined $result->{skewjitter} ) || next;
# here you can use the results

};
}

The data returned in the "result" hash is the following:

result->{skew} the clock skew;
result->{skewjitter} the variance of the skew estimate, used to estimate convergence;
result->{jitter} difference between the current delay and the previous delay;
result->{delay} the communication delay, decremented by a constant (yet unknown) value, used to compute communication jitter;
result->{elems} the number of data points in the convex hull;
result->{select} the index of the data point in the convex hull used to compute the skew;
result->{itimestamp} the timestamp, first element in the data point just passed to the subroutine;
result->{delta} the timestamp difference, second element in the data point just passed to the subroutine;

The data returned in the "hull" stack is a series of data points, selected from those passed to successive calls of the subroutine. The number of data points in the "hull" stack usually does not exceed 20 units.

The algorithm is very fast: each call consists in scanning at most all data points in the "hull" stack, performing simple arithmetic operations for each element.

The algorithm must be fed with a sequence of data points before returning significant results. The accuracy of the estimate keeps growing while new data points are passed to the subroutine. A rough rule of thumb to evaluate estimate accuracy is to observe the skew jitter, and assume it corresponds to the skew estimate accuracy. Paths with quite regular communication delay (small jitter) converge faster.

Quetzal is a Live OpenBSD System.
Main features:
- Symbolic Mathematics Package Maxima + wxMaxima Frontend;
- GNU Image Manipulation Program-GIMP + Full Help/Docs;
- Scripting Language and Graphical Toolkit TCL/TK;
- Object Oriented Scripting Language Python;
- Graphical Toolkit wxWidgets + wxPython;
- Common Unix Printing System-CUPS;
- Internet Messaging System Gaim;
- Complete TeX distribution;
- Text Editor SciTE;
- Remote Desktop;
- PDF Viewer Xpdf;
- File Manager Rox;
- OpenOffice.org Suite;
- Thunderbird Mail Client;
- Firefox Internet Navigator;
- Audio Player XMMS + MP3 Plugin;
- GhostScript & GV Postscript Viewer;
- Dockable Clock, Moon Clock & Audio Mixer.