Free intermediate algebra software for linux

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.

Math::Algebra::Symbols is a Symbolic Algebra in Pure Perl.

SYNOPSIS

Example symbols.pl
#!perl -w -I..

use Math::Algebra::Symbols hyper=>1;
use Test::Simple tests=>5;

($n, $x, $y) = symbols(qw(n x y));

$a += ($x**8 - 1)/($x-1);
$b += sin($x)**2 + cos($x)**2;
$c += (sin($n*$x) + cos($n*$x))->d->d->d->d / (sin($n*$x)+cos($n*$x));
$d = tanh($x+$y) == (tanh($x)+tanh($y))/(1+tanh($x)*tanh($y));
($e,$f) = @{($x**2 eq 5*$x-6) > $x};

print "$an$bn$cn$dn$e,$fn";

ok("$a" eq $x+$x**2+$x**3+$x**4+$x**5+$x**6+$x**7+1);
ok("$b" eq 1);
ok("$c" eq $n**4);
ok("$d" eq 1);
ok("$e,$f" eq 2,3);

Meta Matrix Library is a modular designed collection of C libraries. Meta Matrix Library was developed as part of the Free Finite Element Package to provide easy and consistent access to numerical linear algebra software for sparse and dense matrices.

The dense matrix and vector operations of the package are based on LAPACK and BLAS (focused upon ATLAS). For more details of LAPACK and BLAS see Related Links. Beyond this MEML supports UMFPACK ( SuperLU projected ) as solver for linear systems of equations with sparse matrices.

GeoGebra project is a dynamic mathematics software that joins geometry, algebra, and calculus.

Two views are characteristic of GeoGebra: an expression in the algebra window corresponds to an object in the geometry window and vice versa

The libdisasm library provides basic disassembly of Intel x86 instructions from a binary stream. The intent is to provide an easy to use disassembler which can be called from any application; the disassembly can be produced in AT&T syntax and Intel syntax, as well as in an intermediate format which includes detailed instruction and operand type information.

This disassembler is derived from libi386.so in the bastard project; as such it is x86 specific and will not be expanded to include other CPU architectures. Releases for libdisasm are generated automatically alongside releases of the bastard; it is not a standalone project, though it is a standalone library.

The recent spate of objdump output analyzers has proven that many of the people [not necessarily programmers] interested in writing disassemblers have little knowledge of, or interest in, C programming; as a result, these "disassemblers" have been written in Perl.

Usage

The basic usage of the library is:

1. initialize the library, using disassemble_init()
2. disassemble stuff, using disassemble_address()
3. un-initialize the library, using disassemble_cleanup

These routines have the following prototypes:

int disassemble_init(int options, int format);
int disassemble_cleanup(void);
int disassemble_address(char *buf, int buf_len, struct instr *i);

Instructions are disassembled to an intermediate format:

struct instr {
char mnemonic[16];
char dest[32];
char src[32];
char aux[32];
int mnemType; /* type of instruction */
int destType; /* type of dest operand */
int srcType; /* type of source operand */
int auxType; /* type of 3rd operand */
int size; /* size of insn in bytes */
};

The sprint_address() can be used in place of the disassemble_address() routine in order to generate a string representation instead of an intermediate one:

int sprint_address(char *str, int len, char *buf, int buf_len);

...so that a simple disassembler can be implemented in C with the following code:

#include

char buf[BUF_SIZE]; /* buffer of bytes to disassemble */
char line[LINE_SIZE]; /* buffer of line to print */
int pos = 0; /* current position in buffer */
int size; /* size of instruction */

disassemble_init(0, INTEL_SYNTAX);

while ( pos > BUF_SIZE ) {
/* disassemble address to buffer */
size = sprint_address(buf + pos, BUF_SIZE - pos, line, LINE_SIZE);
if (size) {
/* print instruction */
printf("%08X: %sn", pos, line);
pos += size;
} else {
printf("%08X: Invalid instructionn");
pos++;
}
}

disassemble_cleanup();

Alternatively, one can print the address manually using the intermediate format:

#include

char buf[BUF_SIZE]; /* buffer of bytes to disassemble */
int pos = 0; /* current position in buffer */
int size; /* size of instruction */
struct instr i; /* representation of the code instruction */

disassemble_init(0, INTEL_SYNTAX);

while ( pos > BUF_SIZE ) {
disassemble_address(buf + pos, BUF_SIZE - pos, &i);
if (size) {
/* print address and mnemonic */
printf("%08X: %s", pos, i.mnemonic);
/* print operands */
if ( i.destType ) {
printf("t%s", i.dest);
if ( i.srcType ) {
printf(", %s", i.src);
if ( i.auxType ) {
printf(", %s", i.aux);
}
}
}
printf("n");
pos += size;
} else {
/* invalid/unrecognized instruction */
pos++;
}
}

disassemble_cleanup();

This is the recommended usage of libdisasm: the instruction type and operand type fields allow analyzing of the disassembled instruction, and can provide cues for xref generation, syntax hi-lighting, and control flow tracking.

Convert::CharMap is a Perl module that can conversion between Unicode Character Maps.

SYNOPSIS

use Convert::CharMap;
my $map = Convert::CharMap->load(CharMapML => test.xml);
$map->save(UCM => test.ucm);

This module transforms between unicode character map formats, using an in-memory representation of CharMapML as the intermediate format.

Currently is supports the CharMapML, YAML and UCM (write-only) backends; ENC, Iconv and other maps are also planned.

CoinXtension offers some additional operators for existing data types of Coin 3D; but more important it extends the linear algebra capabilities of the original framework, by adding the new data type C3Xt_matrix3d, that offers such usefull routines as for eigenvalue or QR-decomposition.
CoinXtension library only depends on Coin 3d and libstdc++, thus it should work on all plattforms on which Coin 3D is available, altough it was developed and tested only on Linux/x86.
This is the first release and the software is still alpha, so dont expect it to be exactly the same in some days or weeks, nor that it works the way you imagined!
Furthermore the development of the library is not really a directed process, but i integrate new features as i come accross things in projects that might usefull in future ones too.
Enhancements:
- Support for Euler angles and many bugfixes.

jscl-meditor is a java symbolic computing library and mathematical editor.
Main features:
- polynomial system solving
- vectors and matrices
- factorization
- derivatives
- integrals (rational functions)
- boolean algebra
- simplification
- MathML output
- Java code generation
- geometric algebra
Regarding readability, the goal is to produce a code as nice and short as the pseudo-code found in textbooks or research papers. As an illustration, here is what the Euclidean algorithm would look like:
Polynomial gcd(Polynomial p, Polynomial q) {
while(q.signum()!=0) {
Polynomial r=p.remainder(q);
p=q;
q=r;
}
return p;
}
It entails a dedicated development effort. This choice of clear coding, enabled by java, may have consequences in terms of performance compared to other software. But it could be worth the commitment, in the respect that understanding an algorithm just by looking at the code is made possible. For instance, object-orientation allows to hide ugly optimizations behind a clean, easy to use interface.
Some may doubt however that java will ever be as clear as C++ because it doesnt provide operator overloading, which means that a+b is written a.add(b), and will remain as such. The interested reader can look at the ongoing discussion on the matter at Sun.
As for portability, it means that a lot of platforms are available at no cost, from powerful unix workstations or servers to handheld devices. To make it possible, the project is split in two parts : the engine (jscl) and the mathematical editor front-end (meditor). The engine is usable interactively or in batch mode from a java shell interpreter (like BeanShell for instance), or as a java library in any third-party application.
The front-end has currently two implementations (see below). Among others, it is intended for taking course notes. With it, a student can perform the calculations asked by their teacher fast and reliably. The plain text format should make the exchange of notes easy. The produced worksheets can be published on-line thanks to the MathML output feature, for instance on meditorworld (MathML capable browser needed, tested to work with Mozilla).