Axiom is a free general purpose computer algebra system . It consists of an interpreter, a compiler environment, and a library that describes a strongly typed, mathematically correct type hierarchy.
| Axiom | |
|---|---|
| Type of | computer algebra system |
| Developer | independent group of people |
| Written on | |
| operating system | cross platform software |
| Latest version | |
| License | modified BSD license |
| Site | axiom-developer.org |
Content
History
The development of the system was started in 1971 by a group of IBM researchers led by Richard Jenks ( born Richard Dimick Jenks ) [2] . Initially, the system was called Scratchpad . The project developed slowly and was mainly viewed as a research platform for developing new ideas in computational mathematics.
In the 1990s, the system was sold to the Numerical Algorithms Group (NAG), named Axiom, and became a commercial product. But for several reasons, the system did not receive commercial success and was withdrawn from the market in October 2001 .
NAG decided to make Axiom free software and open source code under a modified BSD license .
In 2007, Axiom had two open source forks : OpenAxiom and FriCAS .
The development of the system continues, new versions are released every two months [3] .
Project Philosophy
Knut's literary programming technology is used throughout the source code. The Axiom project plans to use proven technologies (such as Coq and ACL2 ) to prove the correctness of the algorithms.
Features
In Axiom, all objects are of type. Examples of types are mathematical structures (such as rings , fields , polynomials ), as well as data structures from computing equipment (for example, lists , trees , hash tables ).
A function can get a type as an argument, and its return value can also be a type. For example, Fraction is a function that takes an IntegralDomain as an argument and returns the relationship field of its argument. As another example, a ring matrices of real numbers can be constructed as SquareMatrix(4, Fraction Integer) . Of course, if you work in this domain, 1 interpreted as a unit matrix and A^-1 allows you to get an inverse matrix A , if it exists.
Some operations can have the same name, and then the types of arguments and result are used to determine which operation is applied, just as in OOP .
The Axiom extension language is called SPAD. The entire mathematical base of Axiom is written in this language. The interpreter accepts almost the same language.
SPAD was further developed under the name A # and later Aldor . The latter, in addition, can be used as an alternative extension language. However, please note that it is distributed under a different license.
Examples
3j characters
Calculation of 3j-symbols and Clebsch-Gordan coefficients .
j3Sum (j1, j2, j3, m1, m2, m3) ==
maxz: = reduce (min, [j1 + j2-j3, j1-m1, j2 + m2])
minz: = max (0, max (- (j3-j2 + m1), - (j3-j1-m2)))
minz> maxz => 0
maxz <0 => 0
sum ((-1) ^ (z + j1-j2-m3) / _
(factorial (z) * factorial (j1 + j2-j3-z) * factorial (j1-m1-z) * _
factorial (j2 + m2-z) * factorial (j3-j2 + m1 + z) * factorial (j3-j1-m2 + z)), _
z = minz..maxz)
j3 (j1, j2, j3, m1, m2, m3) ==
m1 + m2 + m3 ~ = 0 => 0
abs (j1 - j2)> j3 => 0
j1 + j2 <j3 => 0
abs (m1)> j1 => 0
abs (m2)> j2 => 0
abs (m3)> j3 => 0
not integer? (j1 + j2 + j3) => 0
sqrt (_
factorial (j1 + j2-j3) * factorial (j1-j2 + j3) * factorial (-j1 + j2 + j3) / _
factorial (j1 + j2 + j3 + 1) * _
factorial (j1 + m1) * factorial (j1-m1) * _
factorial (j2 + m2) * factorial (j2-m2) * _
factorial (j3 + m3) * factorial (j3-m3)
) * j3Sum (j1, j2, j3, m1, m2, m3)
clebschGordan (j1, j2, j, m1, m2, m) ==
(-1) ^ (j1-j2 + m) * sqrt (2 * j + 1) * j3 (j1, j2, j, m1, m2, -m) General Relativity
The Axiom displays the Christoffel symbols and the Riemann and Ricci tensors in the Schwarzschild solution .
x: = vector ['t,' r, '% theta,'% phi];
dim: = #x;
% nu: = operator '% nu;
% lambda: = operator '% lambda;
lg: = matrix [
[exp (% nu r), 0, 0, 0], _
[0, - exp (% lambda r), 0, 0], _
[0, 0, -r ^ 2, 0], _
[0, 0, 0, -r ^ 2 * sin (% theta) ^ 2] _
];
ug: = inverse lg;
grSetup (metric, names) ==
free x
free dim
free lg
free ug
x: = names
dim: = #x
lg: = metric
ug: = inverse lg
sum (list) == reduce (+, list)
Christoffel (k, l, i) ==
(1/2) * sum [ug (i, m) * (D (log (k, m), x (l)) + D (log (m, l), x (k)) - D (log ( k, l), x (m)))
for m in 1..dim]
Riemann (k, l, m, i) ==
D (Christoffel (k, m, i), x (l)) -
D (Christoffel (k, l, i), x (m)) +
sum [
Christoffel (n, l, i) * Christoffel (k, m, n) -
Christoffel (n, m, i) * Christoffel (k, l, n)
for n in 1..dim]
Ricci (i, k) == sum [Riemann (i, l, k, l) for l in 1..dim]
scalarCurvature () == sum [sum [
ug (i, k) * Ricci (i, k)
for i in 1..dim] for k in 1..dim]
lRiemann (i, i, l, m) == 0
lRiemann (i, k, l, l) == 0
lRiemann (i, k, l, m | i> k) == - lRiemann (k, i, l, m)
lRiemann (i, k, l, m | l> m) == - lRiemann (i, k, m, l)
lRiemann (i, k, l, m) == sum [lg (i, n) * Riemann (k, l, m, n) for n in 1..dim]
showChristoffel () ==
for k in 1..dim repeat
for l in 1..k repeat
for i in 1..dim repeat
if Christoffel (k, l, i) ~ = 0 then
k> l => output infix ('=, [script ('% Gamma, [[k-1, l-1], [i-1]]), _
script ('% Gamma, [[l-1, k-1], [i-1]]), _
Christoffel (k, l, i) :: OUTFORM])
k = l => output infix ('=, _
[script ('% Gamma, [[k-1, l-1], [i-1]]), _
Christoffel (k, l, i) :: OUTFORM])
showRicci () ==
for i in 1..dim repeat
for k in 1..i repeat
if Ricci (i, k) ~ = 0 then
i = k => output infix ('=, [subscript (' R, [i-1, k-1]), Ricci (i, k) :: OUTFORM])
i> k => output infix ('=, [subscript (' R, [i-1, k-1]), _
subscript ('R, [k-1, i-1]), _
Ricci (i, k) :: OUTFORM])
showRiemann () ==
for k in 1..dim repeat
for l in 1..dim repeat
for m in 1..dim repeat
for i in 1..dim repeat
if Riemann (k, l, m, i) ~ = 0 then
output infix ('=, _
[script ('R, [[k-1, l-1, m-1], [i-1]]), Riemann (k, l, m, i) :: OUTFORM]) (21) -> showChristoffel ()
Compiling function sum with type List Expression Integer ->
Expression Integer
Compiling function Christoffel with type (PositiveInteger,
PositiveInteger, PositiveInteger) -> Expression Integer
Compiling function showChristoffel with type () -> Void
% nu (r),
% e% nu (r)
one
% Gamma = ---------------
0.0% lambda (r)
2% e
,
% nu (r)
0 0
% Gamma =% Gamma = -------
1.0 0.1 2
,
% lambda (r)
one
% Gamma = -----------
1.1 2
2 2 1
% Gamma =% gamma = -
2.1 1.2 r
1 r
% Gamma = - ------------
2.2% lambda (r)
% e
3 3 1
% Gamma =% gamma = -
3.1 1.3 r
3 3 cos (% theta)
% Gamma =% gamma = -----------
3.2 2.3 sin (% theta)
2
1 r sin (% theta)
% Gamma = - --------------
3.3% lambda (r)
% e
2
% Gamma = - cos (% theta) sin (% theta)
3.3
Type: Void
(22) -> Ricci (3.3)
Compiling function Riemann with type (PositiveInteger,
PositiveInteger, PositiveInteger, PositiveInteger) -> Expression
Integer
Compiling function Ricci with type (PositiveInteger, PositiveInteger)
-> Expression Integer
% lambda (r)
- r% nu (r) + r% lambda (r) + 2% e - 2
(22) ---------------------------------------------
% lambda (r)
2% e
Type: Expression Integer Gallery
Axiom interface in Mozilla Firefox browser
Axiom simplifies the equation of heat
Work with matrices in Axiom
Documentation
Axiom is a literary program . Source code is available in the volume collection at: axiom-developer.org . These volumes contain the current source code of the system.
The following documents are currently available:
- General Table of Contents
- Volume 0: Axiom Jenks and Sutor - Basic Tutorial
- Volume 1: Axiom Tutorial - A Simple Introduction
- Volume 2: Axiom Users Guide - Detailed Domain Usage Examples (Unfinished)
- Volume 3: Axiom Programers Guide - Program Guide for Writing Programs (Incomplete)
- Volume 4: Axiom Developers Guide - Short Sketches on Developer -specific Topics (Incomplete)
- Volume 5: Axiom Intepreter - Axiom Interpreter Source Code (Incomplete)
- Volume 6: Axiom Command - The source code of system commands and scripts (unfinished)
- Volume 7: Axiom Hyperdoc - X11 Hyperdoc help browser source code and explanations
- Volume 7.1 Axiom Hyperdoc Pages - The source code of Hyperdoc pages
- Volume 8: Axiom Graphics - X11 Graphics Subsystem Source Code
- Volume 9: Axiom Compiler - Spad source code (unfinished)
- Volume 10: Axiom Algebra Implementation - Outline of Implementation Features (Unfinished)
- Volume 10.1: Axiom Algebra Theory - Sketches Containing Basic Theory
- Volume 10.2: Axiom Algebra Categories - Source Code for Axiom Categories
- Volume 10.3: Axiom Algebra Domains - Axiom Source Domain Code (Incomplete)
- Volume 10.4: Axiom Algebra Packages - Axiom packages source code (unfinished)
- Volume 11: Axiom Browser - Axiom frontend source pages for Firefox browser
- Volume 12: Axiom Crystal - Axiom Crystal Frontend Source Code (unfinished)
Video
An important goal of the Axiom project is to provide documentation. In November 2008, the project announced the first of a series of training videos that are also available on the website: axiom-developer.org . The first video tells about the sources of information about Axiom. [four]
Notes
- ↑ http://www.axiom-developer.org/axiom-website/releasenotes.html
- ↑ Axiom home page Archived August 18, 2004 on the Wayback Machine .
- ↑ Patches .
- A Axiom Computer Algebra System Information Sources , jgg899, YouTube , November 30, 2008.
Links
- Axiom home page
- OpenAxiom website.
- Site FriCAS.
- Computer algebra system "Axiom"
- Taranchuk V. B. The main functions of computer algebra systems (rus.) . - Minsk: BSU, 2013. - 59 p.