To install one of these packages, type e.g., the following at the UNIX shell prompt:sage -i db-jones-2005-11-02Note that the package name contains the version number, and it will be downloaded automatically if necessary. |

4ti2-1.3.2.p1.spkg | SPKG.txt: A software package for algebraic, geometric and combinatorial problems on linear spaces. Available at www.4ti2.de. |

4ti2-1.6.2.spkg | SPKG.txt: A software package for algebraic, geometric and combinatorial problems on linear spaces. Available at www.4ti2.de. |

4ti2-1.6.spkg | SPKG.txt: A software package for algebraic, geometric and combinatorial problems on linear spaces. Available at www.4ti2.de. |

4ti2-20061025.spkg | SPKG.txt: |

ace-5.0.p0.spkg | SPKG.txt: |

ace-5.0.spkg | SPKG.txt: |

atlas-3.10.1.p7.spkg | SPKG.txt: This spkg builds ATLAS for Sage. It is build per default on Linux and Solaris, but should also work on OSX and Cygwin. |

atlas-3.7.37.spkg | SPKG.txt: About This is an optional spkg to build ATLAS for Sage. It mostly intended for Linux, but should also work on OSX and Unixes. ChangeLog * 20070815: Michael Abshoff <[email protected]> + new upstream release (3.7.37), initial release ToDo * compile threading support confitionally * break out the "make check" |

atlas-3.7.38.spkg | SPKG.txt: About This is an optional spkg to build ATLAS for Sage. It mostly intended for Linux, but should also work on OSX and Unixes. Maintainer: Michael Abshoff ChangeLog * 20071006: Michael Abshoff <[email protected]> + update to 3.7.38 * 20070815: Michael Abshoff <[email protected]> + new upstream release (3.7.37), initial release + "make check" added in spkg-check ToDo * compile threading support confitionally |

autotools-20121217.spkg | SPKG.txt: This package contains a recent version of Texinfo, GNU m4, and help2man. It contains the git repository of autoconf, automake and libtool. For the latter 3 packages (commonly referred to as "autotools"), many different versions are installed, by checking out the versions from the git repo and building/installing them separately. Since the complete git repository is shipped in the spkg, this does not require internet access. For Texinfo, m4 and help2man, just one version is installed. These are prerequisites for autotools. Moreover, Texinfo is often needed for bootstrapping packages. Even though m4 is already a prerequisite of Sage, autoconf requires an up-to-date version of GNU m4. The package makes wrapper scripts in $SAGE_LOCAL/bin for the various autotools, which call the "correct" version. This means that, if a file "configure" already exists in the current directory, the same autoconf version is run which created the original file. Otherwise, the latest version is run. The goal of all this is to make it easier to patch configure.ac or Makefile.am files inside a spkg. By using the same version of autotools as originally used, the patch files should be relatively small. The environment variables AUTOCONF_VERSION, AUTOMAKE_VERSION and LIBTOOL_VERSION can be used to override the chosen version. |

axiom4sage-0.3.1.spkg | SPKG.txt: This version of the axiom4sage package is built using a variant of the FriCAS fork of the Axiom project that uses hardware independent cached Lisp files to generate the executables. Bill Page July 29, 2007. |

benzene-20130630.spkg | SPKG.txt: Benzene is a program for the efficient generation of all nonisomorphic fusenes and benzenoids with a given number of faces. Fusenes are planar polycyclic hydrocarbons with all bounded faces hexagons. Benzenoids are fusenes that are subgraphs of the hexagonal lattice. |

biopython-1.43.spkg | SPKG.txt: |

biopython-1.44.spkg | SPKG.txt: 1. Download from the web. (insert addresses here) 2. Delete all the pdf's from egenix: rm egenix/mx/*/*.pdf egenix/mx/*/Doc/* |

biopython-1.45.spkg | SPKG.txt: |

biopython-1.47.spkg | SPKG.txt: |

biopython-1.49b.spkg | SPKG.txt: |

biopython-1.51.spkg | SPKG.txt: |

biopython-1.52.p0.spkg | SPKG.txt: Biopython is a set of freely available tools for biological computation written in Python by an international team of developers. It is a distributed collaborative effort to develop Python libraries and applications which address the needs of current and future work in bioinformatics. |

biopython-1.53.p0.spkg | SPKG.txt: Biopython is a set of freely available tools for biological computation written in Python by an international team of developers. It is a distributed collaborative effort to develop Python libraries and applications which address the needs of current and future work in bioinformatics. |

biopython-1.54.p0.spkg | SPKG.txt: Biopython is a set of freely available tools for biological computation written in Python by an international team of developers. It is a distributed collaborative effort to develop Python libraries and applications which address the needs of current and future work in bioinformatics. |

biopython-1.55.p0.spkg | SPKG.txt: |

biopython-1.57.spkg | SPKG.txt: |

biopython-1.60.spkg | SPKG.txt: |

boehm_gc-7.2d.p0.spkg | SPKG.txt: The Boehm-Demers-Weiser conservative garbage collector. |

boost_1_34_1.spkg | SPKG.txt: Describe the package here. |

boost_cropped-1.52.0.spkg | SPKG.txt: Boost provides free peer-reviewed portable C++ source libraries. We emphasize libraries that work well with the C++ Standard Library. Boost libraries are intended to be widely useful, and usable across a broad spectrum of applications. The Boost license encourages both commercial and non-commercial use. We aim to establish "existing practice" and provide reference implementations so that Boost libraries are suitable for eventual standardization. Ten Boost libraries are already included in the C++ Standards Committee's Library Technical Report (TR1) and will be in the new C++0x Standard now being finalized. C++0x will also include several more Boost libraries in addition to those from TR1. More Boost libraries are proposed for TR2. Website: http://www.boost.org/ |

brian-1.2.1.p0.spkg | SPKG.txt: Brian is a simulator for spiking neural networks available on almost all platforms. The motivation for this project is that a simulator should not only save the time of processors, but also the time of scientists. Brian is easy to learn and use, highly flexible and easily extensible. The Brian package itself and simulations using it are all written in the Python programming language, which is an easy, concise and highly developed language with many advanced features and development tools, excellent documentation and a large community of users providing support and extension packages. |

buckygen-1.0.p1.spkg | SPKG.txt: Buckygen is a program for the efficient generation of all nonisomorphic fullerenes. These are triangulations where all vertices have degree 5 or 6. Or if the dual representation is used: cubic plane graphs where all faces are pentagons or hexagons. |

buckygen-1.0.spkg | SPKG.txt: Buckygen is a program for the efficient generation of all nonisomorphic fullerenes. These are triangulations where all vertices have degree 5 or 6. Or if the dual representation is used: cubic plane graphs where all faces are pentagons or hexagons. |

bzip2-1.0.6.spkg | SPKG.txt: bzip2 is a freely available, patent free, high-quality data compressor. It typically compresses files to within 10% to 15% of the best available techniques (the PPM family of statistical compressors), whilst being around twice as fast at compression and six times faster at decompression. |

cbc-2.3.p2.spkg | SPKG.txt: The Computational Infrastructure for Operations Research (COIN-OR**, or simply COIN) project is an initiative to spur the development of open-source software for the operations research community. The COIN Branch and Cut solver (CBC) is an open-source mixed-integer program (MIP) solver written in C++. CBC is intended to be used primarily as a callable library to create customized branch-and-cut solvers. A basic, stand-alone executable version is also available. CBC is an active open-source project led by John Forrest at www.coin-or.org. |

cbc-2.7.5.spkg | SPKG.txt: The Computational Infrastructure for Operations Research (COIN-OR**, or simply COIN) project is an initiative to spur the development of open-source software for the operations research community. The COIN Branch and Cut solver (CBC) is an open-source mixed-integer program (MIP) solver written in C++. CBC is intended to be used primarily as a callable library to create customized branch-and-cut solvers. A basic, stand-alone executable version is also available. CBC is an active open-source project led by John Forrest at www.coin-or.org. |

cbc-2.8.1.p0.spkg | SPKG.txt: The Computational Infrastructure for Operations Research (COIN-OR**, or simply COIN) project is an initiative to spur the development of open-source software for the operations research community. The COIN Branch and Cut solver (CBC) is an open-source mixed-integer program (MIP) solver written in C++. CBC is intended to be used primarily as a callable library to create customized branch-and-cut solvers. A basic, stand-alone executable version is also available. CBC is an active open-source project led by John Forrest at www.coin-or.org. |

ccache-3.1.8.spkg | SPKG.txt: Includes ccache to allow for fast recompiles |

ccache-3.1.9.spkg | SPKG.txt: Includes ccache to allow for fast recompiles |

cddlib-094f.p11.spkg | SPKG.txt: The C-library cddlib is a C implementation of the Double Description Method of Motzkin et al. for generating all vertices (i.e. extreme points) and extreme rays of a general convex polyhedron in R^d given by a system of linear inequalities: P |

cephes-2.8.p1.spkg | SPKG.txt: Cephes Mathematical Library. Latest Linux distribution, dated 6/4/00. Special functions and other goodies in C, including long double precision routines for 68K, 386, and sparc processors. This is the most complete distribution package of the function library (but not the most up-to-date one). It includes these sections-- double: all functions in 64-bit double precision; single: all available functions in 32-bit single precision; long double: all available functions in 80-bit extended precision; 128bit: all available functions in 128-bit long double precision; qlib: all functions in q-type extended (44 to 106 decimal) precision, includes a C++ class for the binary floating point arithmetic and a q-type calculator program; c9x-complex: new C language standard C9X data type for complex variables, header complex.h for GNU C and functions in float complex, double complex, and long double complex precisions. Website: http://www.moshier.net/ Download: http://www.moshier.net/cephes-math-28.tar.gz |

chomp-20100213.p0.spkg | SPKG.txt: CHomP stands for "Computational Homology Project," and it is a collection of software for homology computation. It includes both command-line functions and a C++ library. Website: http://chomp.rutgers.edu |

chomp-20100213.p1.spkg | SPKG.txt: CHomP stands for "Computational Homology Project," and it is a collection of software for homology computation. It includes both command-line functions and a C++ library. Website: http://chomp.rutgers.edu |

chomp-20100213.p2.spkg | SPKG.txt: CHomP stands for "Computational Homology Project," and it is a collection of software for homology computation. It includes both command-line functions and a C++ library. Website: http://chomp.rutgers.edu |

chomp-20100213.spkg | SPKG.txt: |

cliquer-1.21.p1.spkg | SPKG.txt: Cliquer is a set of C routines for finding cliques in an arbitrary weighted graph. It uses an exact branch-and-bound algorithm recently developed by Patr Ostergard. |

cmake-2.4.7.spkg | SPKG.txt: |

conway_polynomials-0.4.p0.spkg | SPKG.txt: Contains a small database of Conway polynomials. |

cremona-20071114.spkg | SPKG.txt: Cremona's programs for enumerating and computating with elliptic curves defined over the rational numbers. (This is the culmination of over 30 years of hard work and careful polish.) MAINTAINTERS: * William Stein * John Cremona * Ralph Philip Weinmann TODO: * must get rid of the -DLONG_IS_64_BIT -- see what is done in FLINT. * |

cryptominisat-2.9.5.spkg | SPKG.txt: CryptoMiniSat is a SAT solver that aims to become a premiere SAT solver with all the features and speed of successful SAT solvers, such as MiniSat and PrecoSat. The long-term goals of CryptoMiniSat are to be an efficient sequential, parallel and distributed solver. There are solvers that are good at one or the other, e.g. ManySat (parallel) or PSolver (distributed), but we wish to excel at all. CryptoMiniSat 2.5 won the SAT Race 2010 among 20 solvers submitted by researchers and industry. |

cryptominisat-2.9.6.spkg | SPKG.txt: CryptoMiniSat is a SAT solver that aims to become a premiere SAT solver with all the features and speed of successful SAT solvers, such as MiniSat and PrecoSat. The long-term goals of CryptoMiniSat are to be an efficient sequential, parallel and distributed solver. There are solvers that are good at one or the other, e.g. ManySat (parallel) or PSolver (distributed), but we wish to excel at all. CryptoMiniSat 2.5 won the SAT Race 2010 among 20 solvers submitted by researchers and industry. |

csdp-6.2.spkg | SPKG.txt: This is a fast SDP solver written in C, with a callable library |

cvxopt-0.8.2.p1.spkg | SPKG.txt: MAINTAINERS: * William Stein * Josh Kantor ---------------------------- Downloaded from www.ee.ucla.edu/~vandenbe/cvxopt/ Removed the examples and doc directory to save 0.5MB space. |

cvxopt-1.1.6.p0.spkg | SPKG.txt: CVXOPT is a free software package for convex optimization based on the Python programming language. It can be used with the interactive Python interpreter, on the command line by executing Python scripts, or integrated in other software via Python extension modules. Its main purpose is to make the development of software for convex optimization applications straightforward by building on Python's extensive standard library and on the strengths of Python as a high-level programming language. |

cython-0.19.1.p0.spkg | SPKG.txt: Cython is a language that makes writing C extensions for the Python language as easy as Python itself. Cython is based on the well-known Pyrex, but supports more cutting edge functionality and optimizations. The Cython language is very close to the Python language, but Cython additio- nally supports calling C functions and declaring C types on variables and class attributes. This allows the compiler to generate very efficient C code from Cython code. This makes Cython the ideal language for wrapping for external C libraries, and for fast C modules that speed up the execution of Python code. Website: http://www.cython.org/ |

database_cremona_ellcurve-2005.11.03.spkg | SPKG.txt: |

database_cremona_ellcurve-20071019.p0.spkg | SPKG.txt: John Cremona's huge database of elliptic curves See: http://www.warwick.ac.uk/staff/J.E.Cremona/ftp/data/ and http://sage.math.washington.edu/cremona/INDEX.html This is an optional package, not included by default. |

database_cremona_ellcurve-20120113.spkg | SPKG.txt: John Cremona's huge database of elliptic curves See http://www.warwick.ac.uk/~masgaj/ftp/data/ or http://sage.math.washington.edu/cremona/INDEX.html This is an optional package, not included by default. |

database_cremona_ellcurve-20120302.spkg | SPKG.txt: John Cremona's huge database of elliptic curves See http://www.warwick.ac.uk/~masgaj/ftp/data/ or http://sage.math.washington.edu/cremona/INDEX.html This is an optional package, not included by default. |

database_cremona_ellcurve-20120606.spkg | SPKG.txt: John Cremona's huge database of elliptic curves See http://www.warwick.ac.uk/~masgaj/ftp/data/ or http://sage.math.washington.edu/cremona/INDEX.html This is an optional package, not included by default. |

database_cremona_ellcurve-20120827.spkg | SPKG.txt: |

database_cremona_ellcurve-20121022.spkg | SPKG.txt: |

database_gap-4.4.10.spkg | SPKG.txt: GAP's databases of finite groups and table of marks. |

database_gap-4.4.12.p0.spkg | SPKG.txt: The databases of GAP: finite groups and tables of marks |

database_gap-4.4.12.p1.spkg | SPKG.txt: The databases of GAP: finite groups and tables of marks |

database_gap-4.4.9.spkg | SPKG.txt: |

database_gap-4.5.7.spkg | SPKG.txt: The databases of GAP: finite groups and tables of marks |

database_gap-4.6.4.spkg | SPKG.txt: The databases of GAP: finite groups and tables of marks |

database_odlyzko_zeta.spkg | SPKG.txt: |

database_pari-20130516.spkg | SPKG.txt: The collection of optional PARI packages elldata, seadata, galpol, nftables (galdata is included in the standard PARI spkg). See http://pari.math.u-bordeaux.fr/packages.html |

database_sloane_oeis-2005-12.spkg | SPKG.txt: |

database_stein_watkins_mini.p0.spkg | SPKG.txt: |

database_symbolic_data-20070206.spkg | SPKG.txt: |

docutils-0.7.p0.spkg | SPKG.txt: Docutils is a modular system for processing documentation into useful formats, such as HTML, XML, and LaTeX. For input Docutils supports reStructuredText, an easy-to-read, what-you-see-is-what-you-get plaintext markup syntax. |

dot2tex-2.8.7-2.spkg | SPKG.txt: dot2tex is a python module, whose purpose is to give graphs generated by Graphviz a more LaTeX friendly look and feel. This is accomplished by converting xdot output from Graphviz to a series of PSTricks or PGF/TikZ commands. http://www.fauskes.net/code/dot2tex/ |

dot2tex-2.8.7.p2.spkg | SPKG.txt: dot2tex is a Python module, whose purpose is to give graphs generated by Graphviz a more LaTeX friendly look and feel. This is accomplished by converting xdot output from Graphviz to a series of PSTricks or PGF/TikZ commands. See http://www.fauskes.net/code/dot2tex/ or http://dot2tex.googlecode.com/ |

ecl-12.12.1.p4.spkg | SPKG.txt: ECL is an implementation of the Common Lisp language as defined by the ANSI X3J13 specification. The most relevant features: * A bytecodes compiler and interpreter. * Compiles Lisp also with any C/C++ compiler. * It can build standalone executables and libraries. * ASDF, Sockets, Gray streams, MOP, and other useful components. * Extremely portable. * A reasonable license. ECL supports the operating systems Linux, FreeBSD, NetBSD, OpenBSD, Solaris and Windows, running on top of the Intel, Sparc, Alpha and PowerPC processors. Porting to other architectures should be rather easy. Website: http://ecls.sourceforge.net/ |

eclib-20120830.spkg | SPKG.txt: John Cremona's programs for enumerating and computing with elliptic curves defined over the rational numbers. This is the culmination of over 25 years of hard work. |

ecm-6.1.2.p2.spkg | SPKG.txt: MAINTAINER: -- William Stein I obtained the package from http://gforge.inria.fr/projects/ecm/ |

ecm-6.4.4.spkg | SPKG.txt: GMP-ECM - Elliptic Curve Method for Integer Factorization Sources can be obtained from http://gforge.inria.fr/projects/ecm/ |

elliptic_curves-0.7.spkg | SPKG.txt: Includes two databases: * A small subset of the data in John Cremona's database of elliptic curves up to conductor 10000. See http://www.warwick.ac.uk/~masgaj/ftp/data/ or http://sage.math.washington.edu/cremona/INDEX.html * William Stein's database of interesting curves |

extcode-5.13.spkg | SPKG.txt: |

fflas_ffpack-1.6.0.p0.spkg | SPKG.txt: FFLAS-FFPACK is a LGPL-2.1+ source code library for dense linear algebra over word-size finite fields. http://linalg.org/projects/fflas-ffpack |

flint-0.2.p3.spkg | SPKG.txt: Obtained from: svn export https://flint.svn.sourceforge.net/svnroot/flint/trunk |

flint-1.03.p1.spkg | SPKG.txt: Upstream maintainer: Bill Heart Website: www.flintlib.org 2007-12-19 (Michael Abshoff): + update to FLINT 1.03 + reenable mandatory "make check" 2007-12-16 (Michael Abshoff): + disable mandatory "make check" + remove -B flag in make check since it breaks make 2.79 and earlier 2007-12-10 (Michael Abshoff): Update to FLINT 1.02 2007-12-08 (Michael Abshoff): Update to FLINT 1.01 2007-12-06 (Michael Abshoff): Update to FLINT 1.00 2007-11-25 (Michael Abshoff): add "flint_stack_release();" in fmpz_poly.c:1485 to avoid a memory leak. Deteced and fixed by Bill Hart 2007-11-24 (Michael Abshoff): upgraded to svn r1075 2007-10-02 (William Stein): upgraded to svn 1012 2007-10-02 (Robert Bradshaw): upgraded to svn r1068 Obtained from: svn export https://flint.svn.sourceforge.net/svnroot/flint/trunk |

flint-1.2.4.p2.spkg | SPKG.txt: FLINT is a C library for doing number theory, written by William Hart and David Harvey. Website: www.flintlib.org |

flint-2.3.p1.spkg | SPKG.txt: FLINT is a C library for doing number theory, maintained by William Hart. Website: www.flintlib.org |

flintqs-20070817.p8.spkg | SPKG.txt: |

fortran-OSX64-20090120.spkg | SPKG.txt: Renamed gfortran to gfortran-64 and added script called gfortran that injects "-m64" into the commandline. |

freetype-2.3.5.p4.spkg | SPKG.txt: |

fricas-0.3.1.spkg | SPKG.txt: This version of the axiom4sage package is built using a variant of the FriCAS fork of the Axiom project that uses hardware independent cached Lisp files to generate the executables. Bill Page July 29, 2007. |

fricas-1.0.2.spkg | SPKG.txt: FriCAS is an advanced computer algebra system. Its capabilities range from calculus (integration and differentiation) to abstract algebra. It can plot functions and has an integrated help system. FriCAS is a fork of the Axiom project -- its starting point was the wh-sandbox branch of the Axiom project. This version of the fricas package is built using hardware independent cached Lisp files to generate the executables. |

fricas-1.0.3.p0.spkg | SPKG.txt: FriCAS is an advanced computer algebra system. Its capabilities range from calculus (integration and differentiation) to abstract algebra. It can plot functions and has an integrated help system. FriCAS is a fork of the Axiom project -- its starting point was the wh-sandbox branch of the Axiom project. This version of the fricas package is built using hardware independent cached Lisp files to generate the executables. |

fricas-1.0.9.spkg | SPKG.txt: FriCAS is an advanced computer algebra system. Its capabilities range from calculus (integration and differentiation) to abstract algebra. It can plot functions and has an integrated help system. FriCAS is a fork of the Axiom project -- its starting point was the wh-sandbox branch of the Axiom project. This version of the fricas package is built using hardware independent cached Lisp files to generate the executables. |

fricasaldor-1.0.9.spkg | SPKG.txt: FriCAS is an advanced computer algebra system. This package adds an interface to the Aldor (http://www.aldor.org) compiler. In addition to extending the FriCAS by writing new library code in the builtin SPAD language, this package allows to compile Aldor code for FriCAS. Note that this package does not include the Aldor compiler itself and can only be installed if Aldor is already available on the system. |

frobby-0.7.6.spkg | SPKG.txt: The software package Frobby provides a number of computations on monomial ideals. The current main feature is the socle of a monomial ideal, which is largely equivalent to computing the maximal standard monomials, the Alexander dual or the irreducible decomposition. Operations on monomial ideals are much faster than algorithms designed for ideals in general, which is what makes a specialized library for these operations on monomial ideals useful. |

frobby-0.9.0.p1.spkg | SPKG.txt: The software package Frobby provides a number of computations on monomial ideals. The current main feature is the socle of a monomial ideal, which is largely equivalent to computing the maximal standard monomials, the Alexander dual or the irreducible decomposition. Operations on monomial ideals are much faster than algorithms designed for ideals in general, which is what makes a specialized library for these operations on monomial ideals useful. |

frobby-0.9.0.spkg | SPKG.txt: The software package Frobby provides a number of computations on monomial ideals. The current main feature is the socle of a monomial ideal, which is largely equivalent to computing the maximal standard monomials, the Alexander dual or the irreducible decomposition. Operations on monomial ideals are much faster than algorithms designed for ideals in general, which is what makes a specialized library for these operations on monomial ideals useful. |

gap-4.4.9.spkg | SPKG.txt: This is a stripped-down version of GAP. The databases, which are arch independent, are in a separate package and doc and tests are removed. PACKAGE MAINTAINERS: William Stein, Martin Albrecht, and David Joyner ** IMPORTANT **: When you update this package, be sure to put the guava package in the package directory!! DELETED: doc -- some of documentation: rm *.bbl *.aux *.dvi *.idx *.ilg *.l* *.m* *.pdf *.toc *.blg *.ind rm */*.bbl */*.aux */*.dvi */*.idx */*.ilg */*.l* */*.m* */*.pdf */*.ind */*.toc */*.blg tst -- tests bin -- some BIG windows programs, which we don't need since GAP is only going to be used via expect DATABASES (separated out): small -- small group's database; will distribute separately. pkg/tomlib -- just contains the "Table of Marks"; distribute separately. prim trans |

gap-4.6.4.p0.spkg | SPKG.txt: GAP is a system for computational discrete algebra, with particular emphasis on Computational Group Theory. GAP provides a programming language, a library of thousands of functions implementing algebraic algorithms written in the GAP language as well as large data libraries of algebraic objects. See also the overview and the description of the mathematical capabilities. GAP is used in research and teaching for studying groups and their representations, rings, vector spaces, algebras, combinatorial structures, and more. The system, including source, is distributed freely. You can study and easily modify or extend it for your special use. This is a stripped-down version of GAP. The databases, which are architecture-independent, are in a separate package. |

gap_packages-4.4.10.spkg | SPKG.txt: NOTES: grape -- it hardcodes cc as compiler, which of course doesn't work. I've changed to hardcode gcc as compiler, which is more likely to work. Prepared by David Joyner (2006-21-05) This directory contains several "official" and "undeposited" GAP packages available from http://www.gap-system.org/Packages/packages.html. They are all released under the GPL with the following exception: (*) grape contains Brendon McKay's nauty program. To load a package, for example grape, into SAGE type sage: gap('LoadPackage("grape")') All these packages come with documentation in the doc or htm subdirectory (e.g., for grape, it would be in SAGEHOME/local/lib/gap-4.4.7/pkg/grape/htm). A brief description of each package follows: braid is a GAP package for computing with braids, covering curves, and Hurwitz spaces. CTblLib - The GAP Character Table Library DESIGN is a package for classifying, partitioning and studying block designs. FactInt is a package providing routines for factoring integers, in particular: * Pollard's p-1 * Williams' p+1 * Elliptic Curves Method (ECM) * Continued Fraction Algorithm (CFRAC) * Multiple Polynomial Quadratic Sieve (MPQS) GAPDoc is a package containing a definition of a structure for GAP documentation, based on XML. It also contains conversion programs for producing text-, DVI-, PDF- or HTML-versions of such documents, with hyperlinks if possible. GRAPE is a package for computing with graphs and groups, and is primarily designed for constructing and analysing graphs related to groups, finite geometries, and designs. HAP (Homological Algebra Programming) is a GAP package providing some functions for group cohomology computation. LAGUNA package provides functionality for calculation of the normalized unit group of the modular group algebra of the finite p-group and for investigation of Lie algebra associated with group algebras and other associative algebras. SONATA ("System Of Nearrings And Their Applications") is a package which constructs finite nearrings and related objects. TORIC is a GAP package for computing with toric varieties. |

gap_packages-4.4.10_3.spkg | SPKG.txt: |

gap_packages-4.4.10_4.spkg | SPKG.txt: |

gap_packages-4.4.10_6.spkg | SPKG.txt: |

gap_packages-4.4.12.p0.spkg | SPKG.txt: Several "official" and "undeposited" GAP packages available from http://www.gap-system.org/Packages/packages.html |

gap_packages-4.4.12.p1.spkg | SPKG.txt: Several "official" and "undeposited" GAP packages available from http://www.gap-system.org/Packages/packages.html |

gap_packages-4.4.9_2.spkg | SPKG.txt: |

gap_packages-4.5.7.spkg | SPKG.txt: Several "official" and "undeposited" GAP packages available from http://www.gap-system.org/Packages/packages.html |

gap_packages-4.6.4.p1.spkg | SPKG.txt: |

gap_packages-4.6.4.spkg | SPKG.txt: |

gcc-4.6.4.spkg | SPKG.txt: The GNU Compiler Collection, including the C, C++ and Fortran compiler. |

gcc-4.7.2.p0.spkg | SPKG.txt: The GNU Compiler Collection, including the C, C++ and Fortran compiler. |

gcc-4.7.2.spkg | SPKG.txt: The GNU Compiler Collection, including the C, C++ and Fortran compiler. |

gcc-4.7.3.p1.spkg | SPKG.txt: The GNU Compiler Collection, including the C, C++ and Fortran compiler. |

gcc-4.8.0.spkg | SPKG.txt: The GNU Compiler Collection, including the C, C++ and Fortran compiler. |

gcc-4.8.1.spkg | SPKG.txt: The GNU Compiler Collection, including the C, C++ and Fortran compiler. |

gdb-7.5.1.spkg | SPKG.txt: GDB, the GNU Project debugger, allows you to see what is going on "inside" another program while it executes -- or what another program was doing at the moment it crashed. |

gdbm-1.8.3.spkg | SPKG.txt: GNU dbm is a set of database routines that use extendible hashing and works similar to the standard UNIX dbm routines. |

gf2x-1.1.p0.spkg | SPKG.txt: gf2x is a C/C++ software package containing routines for fast arithmetic in GF(2)[x] (multiplication, squaring, GCD) and searching for irreducible/primitive trinomials. Website: http://gf2x.gforge.inria.fr/ |

gfan-0.5.p0.spkg | SPKG.txt: From http://www.math.tu-berlin.de/~jensen/software/gfan/gfan.html: Gfan is a software package for computing Groebner fans and tropical varieties. These are polyhedral fans associated to polynomial ideals. The maximal cones of a Groebner fan are in bijection with the marked reduced Groebner bases of its defining ideal. The software computes all marked reduced Groebner bases of an ideal. Their union is a universal Groebner basis. The tropical variety of a polynomial ideal is a certain subcomplex of the Groebner fan. Gfan contains algorithms for computing this complex for general ideals and specialized algorithms for tropical curves, tropical hypersurfaces and tropical varieties of prime ideals. In addition to the above core functions the package contains many tools which are useful in the study of Groebner bases, initial ideals and tropical geometry. |

git-1.7.12.2.p0.spkg | SPKG.txt: Git is a fast, scalable, distributed revision control system with an unusually rich command set that provides both high-operations and full access to internals. -- `man git` |

git-1.7.9.4.spkg | SPKG.txt: Git is a fast, scalable, distributed revision control system with an unusually rich command set that provides both high-operations and full access to internals. -- `man git` |

givaro-3.2.6.p2.spkg | SPKG.txt: MAINTAINER: -- Martin Albrecht -- 2007-11-02 Michael Abshoff * apply rpw's work aorund for OSX 10.5 * add .hgignore -- 2007-02-03 Martin Albrecht <[email protected]> * new upstream release: 3.2.6 * Changes to upstream (everything else below is irrelevant): ./src/library/poly1/givpoly1factor.h (2006-10-21 fix) ./src/kernel/zpz/givgfq.inl (2006-10-21 fix) ./src/kernel/zpz/givgfq.h (2006-10-21 fix) ./aclocal.m4 64-bit (2006-10-29 fix) ./src/library/poly1/givpoly1padic.h (2006-11-09 fix) -- 2006-12-15 William Stein I don't know why, but I had to comment out Rep& amxy( Rep& r, const Rep& a, const Rep& b, const Rep& c ) const { return Integer::amxy(r,a,b,c); } in src/kernel/integer/givinteger.h in order to get Givaro to compile on my computer. I'm guessing maybe amxy was deprecated from the C++ stl? -- 2006-12-10 Martin Albrecht <[email protected]> * delete[] not delete where new[] in GivaroMM -- 2006-11-09 Martin Albrecht <[email protected]> * GCC 4.0.0 on OSX PPC boxes doesn't seem to like "using Poly1Dom<Domain,Dense>::_domain" so we work around this in givpoly1padic.h -- 2006-10-29 Martin Albrecht <[email protected]> * replaced macro AC_LIBTOOL_SYS_DYNAMIC_LINKER with same macro from libtool 1.5.23a in aclocal.m4 to fix build on x86-64 systems as suggested by Kate Minola -- 2006-10-21 Martin Albrecht <[email protected]> * ported constructor with modulus parameter from linbox to givaro * added sage_generator() which returns the generator |

givaro-3.7.1.spkg | SPKG.txt: Givaro is a C++ library for arithmetic and algebraic computations. Its main features are implementations of the basic arithmetic of many mathematical entities: Primes fields, Extensions Fields, Finite Fields, Finite Rings, Polynomials, Algebraic numbers, Arbitrary precision integers and rationals (C++ wrappers over gmp) It also provides data-structures and templated classes for the manipulation of basic algebraic objects, such as vectors, matrices (dense, sparse, structured), univariate polynomials (and therefore recursive multivariate). Website: http://www-lmc.imag.fr/CASYS/LOGICIELS/givaro/ SPKG Repository: https://bitbucket.org/malb/givaro-spkg |

glpk-4.44.p0.spkg | SPKG.txt: The GLPK (GNU Linear Programming Kit) package is intended for solving large-scale linear programming (LP), mixed integer programming (MIP), and other related problems. It is a set of routines written in ANSI C and organized in the form of a callable library. GLPK supports the GNU MathProg modelling language, which is a subset of the AMPL language. The GLPK package includes the following main components: * primal and dual simplex methods * primal-dual interior-point method * branch-and-cut method * translator for GNU MathProg * application program interface (API) * stand-alone LP/MIP solver |

gmp-4.2.1.p10.spkg | SPKG.txt: NOTE: When upgrading GMP, don't forget to update the spkg-install script for polymake. |

gmpy-1.0.1.spkg | SPKG.txt: |

gnuplotpy-1.7.p2.spkg | SPKG.txt: |

graphs-20120404.p4.spkg | SPKG.txt: A database of graphs. Created by Emily Kirkman based on the work of Jason Grout. Since April 2012 it also contains the ISGCI graph database. |

graphviz-2.16.1.p0.spkg | SPKG.txt: Caution: this code is GPL incompatible, so it cannot become a standard spkg. |

gsl-1.15.p1.spkg | SPKG.txt: Website: http://www.gnu.org/software/gsl/ From the website above: The GNU Scientific Library (GSL) is a numerical library for C and C++ programmers. It is free software under the GNU General Public License. The library provides a wide range of mathematical routines such as random number generators, special functions and least-squares fitting. There are over 1000 functions in total with an extensive test suite. If the variable SAGE_CHECK is exported to the value "yes" when building Sage, GSL's test suite is run. |

hermes-0.9.4-linux.spkg | SPKG.txt: |

iconv-1.13.1.p0.spkg | SPKG.txt: |

iconv-1.14.spkg | SPKG.txt: GNU libiconv is a library that is used to enable different languages, with different characters to be handled properly. |

iml-1.0.1.p6.spkg | SPKG.txt: AUTHORS: -- William Stein (2007-02-14) Get it from http://www.cs.uwaterloo.ca/~z4chen/iml.html 1. I had to put the built version of src/repl in that directory, since on OS X it won't build. It's basically empty, so this seems safe. 2. I had to src/config/install-sh executable. 3. I had to create src/cblas.h since on many systems it isn't installed anywhere!? I just used gsl_cblas.h for this purpose, which seems to work fine. 4. Modified some of the examples, and made build scripts that work. 5. *IMPORTANT*: Change lift to iml_lift in padiclift.* and nonsingsolve.*, since otherwise on OSX you'll have horrible weird conflict problems. |

iml-1.0.3.p0.spkg | SPKG.txt: IML is a free library of C source code which implements algorithms for computing exact solutions to dense systems of linear equations over the integers. IML is designed to be used with the ATLAS/BLAS library and GMP bignum library. Written in portable C, IML can be used on both 32-bit and 64-bit machines. It can be called from C++. Website: http://www.cs.uwaterloo.ca/~astorjoh/iml.html |

ipython-0.13.2.spkg | SPKG.txt: From the IPython website: IPython is a multiplatform, Free Software project (BSD licensed) that offers: * An enhanced Python shell designed for efficient interactive work. It includes many enhancements over the default Python shell, including the ability for controlling interactively all major GUI toolkits in a non-blocking manner. * A library to build customized interactive environments using Python as the basic language (but with the possibility of having extended or alternate syntaxes). * A system for interactive distributed and parallel computing (this is part of IPython's new development). |

jinja2-2.5.5.spkg | SPKG.txt: Jinja2 is a library for Python 2.4 and onwards that is designed to be flexible, fast and secure. If you have any exposure to other text-based template languages, such as Smarty or Django, you should feel right at home with Jinja2. It's both designer and developer friendly by sticking to Python's principles and adding functionality useful for templating environments. |

jmol-12.3.27.p3.spkg | SPKG.txt: This updates jar files necessary for Jmol to operate from the command line and the Notebook. It does not contain the Notebook javascript library jmol_lib.js or changes to Notebook or Sage code. |

jsmath-image-fonts-1.3.spkg | SPKG.txt: The jsMath image fonts provide a fall-back for rendering TeX characters in browsers on computers that do not have the TeX fonts installed. |

jsmath-image-fonts-1.3p1.spkg | SPKG.txt: The jsMath image fonts provide a fall-back for rendering TeX characters in browsers on computers that do not have the TeX fonts installed. |

jsmath_image_fonts-1.4.p3.spkg | SPKG.txt: The jsMath image fonts provide a fall-back for rendering TeX characters in browsers on computers that do not have the TeX fonts installed. |

kash3-2008-07-31.p0.spkg | SPKG.txt: This is a binary of KASH from: http://www.math.tu-berlin.de/~kant/download.html It works on OS X and Linux, but nothing else, since that's all that is available for KASH. The Linux binary is 32-bit only, but will run on 64-bit boxes in 32-bit mode. |

kash3-2008-07-31.spkg | SPKG.txt: This is a binary of KASH from: http://www.math.tu-berlin.de/~kant/download.html It works on OS X and Linux, but nothing else, since that's all that is available for KASH. The Linux binary is 32-bit only, but will run on 64-bit boxes in 32-bit mode. |

kash3_linux-2006.01.31.spkg | SPKG.txt: |

kash3_osx-2006.01.31.spkg | SPKG.txt: |

lapack-20071123.p0.spkg | SPKG.txt: MAINTAINERS: Josh Kantor William Stein |

latte_int-1.6.spkg | SPKG.txt: LattE (Lattice point Enumeration) Integrale solves the problems of counting lattice points in and integration over convex polytopes. |

lcalc-1.23.p11.spkg | SPKG.txt: Michael Rubinstein's L-function calculator. |

libcocoa-0.9930.spkg | SPKG.txt: CoCoALib is a GPL C++ library for doing Computations in Commutative Algebra. |

libfplll-4.0.4.spkg | SPKG.txt: fplll is a code distributed under the LGPL that LLL-reduces euclidean lattices. Since version 3, it can also solve the shortest vector problem. Website: http://perso.ens-lyon.fr/damien.stehle/fplll.html |

libgap-4.6.4.p0.spkg | SPKG.txt: This is the |

libm4ri-20130416.spkg | SPKG.txt: M4RI: Library for matrix multiplication, reduction and inversion over GF(2). (See also m4ri/README for a brief overview.) |

libm4rie-20130416.spkg | SPKG.txt: M4RIE: Library for matrix multiplication, reduction and inversion over GF(2^k) for 2 < |

libogg-1.1.4.spkg | SPKG.txt: libogg is the official reference library for the Ogg multimedia container format, and the native file and stream format for the Xiph.org multimedia codecs. As with all Xiph.org technology is it an open format free for anyone to use. Website: http://www.xiph.org/ogg |

libpng-1.2.22.p3.spkg | SPKG.txt: This is libpng. http://www.libpng.org/pub/png/libpng.html |

libpng-1.2.22.spkg | SPKG.txt: This is libpng. http://www.libpng.org/pub/png/libpng.html |

libpng-1.2.35.p5.spkg | SPKG.txt: libpng is the official PNG reference library. It supports almost all PNG features, is extensible, and has been extensively tested for over 13 years. The home site for development versions (i.e., may be buggy or subject to change or include experimental features) is http://libpng.sourceforge.net/, and the place to go for questions about the library is the png-mng-implement mailing list. Website: http://www.libpng.org/pub/png/libpng.html |

libtheora-1.1.1.spkg | SPKG.txt: libtheora is the official reference library for the Theora video codec. Theora is a free and open video compression format from the Xiph.org Foundation. Website: http://www.xiph.org/theora |

lie-2.2.2.p2.spkg | SPKG.txt: 1. Get it from: 2. Comment out the #include <string.h> lines from both of * src/lie.h * src/box/closure.c 3. Makefile -- I had to add -lcurses |

lie-2.2.2.p3.spkg | SPKG.txt: 1. Get it from: 2. Comment out the #include <string.h> lines from both of * src/lie.h * src/box/closure.c 3. Makefile -- I had to add -lcurses *20070906: change default to link against ncurses, curses is uncommon on modern Linux systems. Linking against curses will be better on Solaris. [mabshoff] |

lie-2.2.2.p4.spkg | SPKG.txt: LiE is the name of a software package that enables mathematicians and physicists to perform computations of a Lie group theoretic nature. It focuses on the representation theory of complex semisimple (reductive) Lie groups and algebras, and on the structure of their Weyl groups and root systems. LiE does not compute directly with elements of the Lie groups and algebras themselves; it rather computes with weights, roots, characters and similar objects. Some specialities of LiE are: tensor product decompositions, branching to subgroups, Weyl group orbits, reduced elements in Weyl groups, distinguished coset representatives and much more. These operations have been compiled into the program which results in fast execution: typically one or two orders of magnitude faster than similar programs written in a general purpose program. The LiE programming language makes it possible to customise and extend the package with more mathematical functions. A user manual is provided containing many examples. LiE establishes an interactive environment from which commands can be given that involve basic programming primitives and powerful built-in functions. These commands are read by an interpreter built into the package and passed to the core of the system. This core consists of programs representing some 100 mathematical functions. The interpreter offers on-line facilities which explain operations and functions, and which give background information about Lie group theoretical concepts and about currently valid definitions and values. (from http://www-math.univ-poitiers.fr/~maavl/LiE/description.html ) |

linbox-1.3.2.p0.spkg | SPKG.txt: From http://linalg.org/: LinBox is a C++ template library for exact, high-performance linear algebra computation with dense, sparse, and structured matrices over the integers and over finite fields. |

linbox-20070904.spkg | SPKG.txt: *2007-09-03: merged LinBox ChangeSet 2803, which fixes #498 without the performance regression of the initial workaround (mabshoff) 1. Modified charpoly.h and commentator.C 2. Added linboxwrap (malb) 3. Change the line in configure so tuning doesn't take like 30 minutes and crash the host computer! size_t n |

lrcalc-1.1.6.p0.spkg | SPKG.txt: Littlewood-Richardson Calculator http://math.rutgers.edu/~asbuch/lrcalc/ |

lrs-4.2b.p0.spkg | SPKG.txt: * 2008-05-15 (Marshall Hampton) *initial build 1. Deleted McGill-specific build stuff from makefile 2. Added SAGE_LOCAL gmp build locations |

lrs-4.2b.p1.spkg | SPKG.txt: lrs implements the linear reverse search algorithm of Avis and Fukuda. See the homepage (http://cgm.cs.mcgill.ca/~avis/C/lrs.html) for details. |

macaulay2-1.1-r7210.p1.spkg | SPKG.txt: Macaulay 2 is a software system devoted to supporting research in algebraic geometry and commutative algebra. |

macaulay2-1.1-r7210.spkg | SPKG.txt: Macaulay 2 is a software system devoted to supporting research in algebraic geometry and commutative algebra. |

macaulay2-20061014.p1.spkg | SPKG.txt: CHANGES: 1. I changed M2/Macualay2/packages/Makefile.in to have the following near the top. This speeds up the build a lot and lets it complete on OS X intel where there is a problem with two examples. RemakeAllDocumentation ? |

macaulay2-20061014.spkg | SPKG.txt: |

matplotlib-0.91.1.spkg | SPKG.txt: The following is in the patches subdirectory. It is copied in during the build process. * I replaced setupext.py by a version that adds some SAGE-specific paths so the build doesn't fail (since SAGE includes certain libs that matplotlib depends on). |

matplotlib-1.2.1.spkg | SPKG.txt: From the Matplotlib website: matplotlib is a python 2D plotting library which produces publication quality figures in a variety of hardcopy formats and interactive environments across platforms. matplotlib can be used in python scripts, the python and ipython shell (ala matlab or mathematica), web application servers, and six graphical user interface toolkits. |

maxima-5.12.0.spkg | SPKG.txt: Here's what spkg-dist does: * Removed the foreign language versions of the info files, since they add several MEGS (and they weren't in previous versions of Maxima). This meant making empty directories and changing the Makefile.in's |

maxima-5.20.1.p0.spkg | SPKG.txt: Maxima is a system for the manipulation of symbolic and numerical expressions, including differentiation, integration, Taylor series, Laplace transforms, ordinary differential equations, systems of linear equations, polynomials, and sets, lists, vectors, matrices, and tensors. Maxima yields high precision numeric results by using exact fractions, arbitrary precision integers, and variable precision floating point numbers. Maxima can plot functions and data in two and three dimensions. For more information, see the Maxima web site http://maxima.sourceforge.net |

maxima-5.20.1.spkg | SPKG.txt: Maxima is a system for the manipulation of symbolic and numerical expressions, including differentiation, integration, Taylor series, Laplace transforms, ordinary differential equations, systems of linear equations, polynomials, and sets, lists, vectors, matrices, and tensors. Maxima yields high precision numeric results by using exact fractions, arbitrary precision integers, and variable precision floating point numbers. Maxima can plot functions and data in two and three dimensions. For more information, see the Maxima web site http://maxima.sourceforge.net |

maxima-5.29.1.p3.spkg | SPKG.txt: Maxima is a system for the manipulation of symbolic and numerical expressions, including differentiation, integration, Taylor series, Laplace transforms, ordinary differential equations, systems of linear equations, polynomials, and sets, lists, vectors, matrices, and tensors. Maxima yields high precision numeric results by using exact fractions, arbitrary precision integers, and variable precision floating point numbers. Maxima can plot functions and data in two and three dimensions. For more information, see the Maxima web site http://maxima.sourceforge.net |

mayavi-linux_2.0.20080106.spkg | SPKG.txt: |

mayavi_2.0.20080117.spkg | SPKG.txt: MayaVi2 is a general purpose, cross-platform tool for 2-D and 3-D scientific data visualization. http://code.enthought.com/mayavi2/ https://svn.enthought.com/enthought/wiki/MayaVi http://www.scipy.org/Cookbook/MayaVi |

mayavi_2.1.1-20080307.p1.spkg | SPKG.txt: MayaVi2 is a general purpose, cross-platform tool for 2-D and 3-D scientific data visualization. http://code.enthought.com/mayavi2/ https://svn.enthought.com/enthought/wiki/MayaVi http://www.scipy.org/Cookbook/MayaVi |

mayavi_2.2.0.spkg | SPKG.txt: MayaVi2 is a general purpose, cross-platform tool for 2-D and 3-D scientific data visualization. http://code.enthought.com/mayavi2/ https://svn.enthought.com/enthought/wiki/MayaVi http://www.scipy.org/Cookbook/MayaVi |

mercurial-0.9.4.spkg | SPKG.txt: * 20070106 (William Stein): Modified mercurial/util.py to more intelligently choose the encoding, since this was crashing the install on my sage.math chroot jail. * no changes from default repo, except that there's a sage subdirectory with a better .css file that gets copied to templates/static during the install. And another that gets copied to templates/. * Ran this command in the templates directory: replace ">manifest<" ">browse all files<" *.tmpl I mean, it's *incredibly* unclear what the hecke the "manifest" button is supposed to do. |

mpc-0.5.p0.spkg | SPKG.txt: From http://www.multiprecision.org/mpc: The MPC library is a C library for multiple-precision floating-point computations with correct rounding. MPC has continuously been supported by the INRIA and the current main authors come from the CACAO and TANC project-teams at Loria (Nancy, France) and Ecole Polytechnique (Palaiseau, France) respectively; see more on the web page. MPC is based on the MPFR multiple-precision library. |

mpc-0.8.3-dev-svn793.spkg | SPKG.txt: From http://www.multiprecision.org/mpc : MPC is a C library for the arithmetic of complex numbers with arbitrarily high precision and correct rounding of the result. It is built upon and follows the same principles as MPFR. |

mpc-1.0.p0.spkg | SPKG.txt: From http://www.multiprecision.org/mpc: GNU MPC is a C library for the arithmetic of complex numbers with arbitrarily high precision and correct rounding of the result. It extends the principles of the IEEE-754 standard for fixed precision real floating point numbers to complex numbers, providing well-defined semantics for every operation. At the same time, speed of operation at high precision is a major design goal. |

mpfi-1.5.1.spkg | SPKG.txt: MPFI is a library for interval arithmetic, which is built upon the MPFR multiple precision floating-point arithmetic. MPFI is intended to be a portable library written in C for arbitrary precision interval arithmetic with intervals represented using MPFR reliable floating-point numbers. It is based on the GNU MP library and on the MPFR library. The purpose of an arbitrary precision interval arithmetic is on the one hand to get "guaranteed" results, thanks to interval computation, and on the other hand to obtain accurate results, thanks to multiple precision arithmetic. The MPFI library is built upon MPFR in order to benefit from the correct rounding provided, for each operation or function, by MPFR. Further advantages of using MPFR are its portability and compliance with the IEEE 754 standard for floating-point arithmetic. |

mpfr-2.2.1.p1.spkg | SPKG.txt: 2006-11-29: Just took the standard distribution from http://www.mpfr.org/mpfr-current/ This is now out of date. ------------------------------------------------ HOW TO MAKE the -2.2.0 PACKAGE: * applied cummulative patches as of the date of the file: wget http://www.mpfr.org/mpfr-current/patches The webpage says download it into the top of mpfr-2.2.0 tree and use "GNU patch" to patch it: patch -N -Z -p1 < patches Then update the configure script: autoconf < configure.in > configure CHANGELONG: 2006-10-15: Fix from Mike Rubinstein: In sage-1.4/spkg/build/mpfr-20060930/spkg-install there are a couple of options given to ./configure that are specific to NTL and don't seem to have anything to do with mpfr, namely: NTL_GMP_LIP |

mpfr-3.1.2.p0.spkg | SPKG.txt: The MPFR library is a C library for multiple-precision floating-point computations with correct rounding. MPFR has continuously been supported by the INRIA and the current main authors come from the Caramel and Arénaire project-teams at Loria (Nancy, France) and LIP (Lyon, France) respectively; see more on the credit page. MPFR is based on the GMP multiple-precision library. The main goal of MPFR is to provide a library for multiple-precision floating-point computation which is both efficient and has a well-defined semantics. It copies the good ideas from the ANSI/IEEE-754 standard for double-precision floating-point arithmetic (53-bit significand). |

mpi4py-0.3.1.spkg | SPKG.txt: |

mpir-2.6.0.p3.spkg | SPKG.txt: MPIR is an open source multiprecision integer library derived from version 5.0.1 of the GMP (GNU Multi Precision) project (which was licensed LGPL v2+). See http://www.mpir.org |

mpmath-0.17.spkg | SPKG.txt: Mpmath is a pure-Python library for multiprecision floating-point arithmetic. It provides an extensive set of transcendental functions, unlimited exponent sizes, complex numbers, interval arithmetic, numerical integration and differentiation, root-finding, linear algebra, and much more. Almost any calculation can be performed just as well at 10-digit or 1000-digit precision, and in many cases mpmath implements asymptotically fast algorithms that scale well for extremely high precision work. If available, mpmath will (optionally) use gmpy to speed up high precision operations. |

nauty-24.spkg | SPKG.txt: Nauty has various tools for finding the automorphism group of a graph, generating non-isomorphic graphs with certain properties, etc. |

nauty-25.spkg | SPKG.txt: Nauty has various tools for finding the automorphism group of a graph, generating non-isomorphic graphs with certain properties, etc. |

nauty22.spkg | SPKG.txt: |

ncurses-5.9.p2.spkg | SPKG.txt: Ncurses (new curses, pronounced "enn-curses") started as a freely distributable "clone" of System V Release 4.0 (SVr4) curses. It has outgrown the "clone" description, and now contains many features which are not in SVr4 curses. Curses is a pun on the term "cursor optimization". It is a library of functions that manage an application's display on character-cell terminals (e.g., VT100). The name "ncurses" was first used as the name of the curses library in Pavel Curtis's pcurses, dated 1982. It was apparently developed on a BSD 4.4 system, at Cornell. Parts of pcurses are readily identifiable in ncurses, including the basics for the terminfo compiler (named compile in that package): * the Caps, used to define the terminfo capabilities * awk scripts MKcaptab.awk, MKnames.awk * the library modules used for the terminfo compiler. Besides ncurses, parts of pcurses still survive in 2010, in recognizable form in Solaris. Website: http://invisible-island.net/ncurses |

networkx-1.6.spkg | SPKG.txt: NetworkX (NX) is a Python package for the creation, manipulation, and study of the structure, dynamics, and functions of complex networks. |

normaliz-2.8.p0.spkg | SPKG.txt: Normaliz is a tool for computations in affine monoids, vector configurations, lattice polytopes, and rational cones. For more details see http://www.mathematik.uni-osnabrueck.de/normaliz/ |

nose-1.1.2.spkg | SPKG.txt: nose extends the test loading and running features of unittest, making it easier to write, find and run tests. |

ntl-5.5.2.p3.spkg | SPKG.txt: NTL is a high-performance, portable C++ library providing data structures and algorithms for manipulating signed, arbitrary length integers, and for vectors, matrices, and polynomials over the integers and over finite fields. Website: http://www.shoup.net/ntl/ |

numpy-1.3.0.p2.spkg | SPKG.txt: |

numpy-1.7.0.spkg | SPKG.txt: This package adds numerical linear algebra and other numerical computing capabilities to python. |

numpy-20070718.spkg | SPKG.txt: ----------- svn export http://svn.scipy.org/svn/numpy/trunk ---------- NOTES: The numpy docstrings don't have nearly enough examples yet. Fortunately the following two websites have tons of examples: http://scipy.org/Numpy_Example_List_With_Doc http://www.hjcb.nl/python/Arrays.html |

nzmath-0.6.0.spkg | SPKG.txt: |

openmpi-1.1.4.spkg | SPKG.txt: |

openssl-1.0.0.p0.spkg | SPKG.txt: From wikipedia: OpenSSL is an open source implementation of the SSL and TLS protocols. The core library (written in the C programming language) implements the basic cryptographic functions and provides various utility functions. Wrappers allowing the use of the OpenSSL library in a variety of computer languages are available. |

openssl-1.0.1a.spkg | SPKG.txt: From wikipedia: OpenSSL is an open source implementation of the SSL and TLS protocols. The core library (written in the C programming language) implements the basic cryptographic functions and provides various utility functions. Wrappers allowing the use of the OpenSSL library in a variety of computer languages are available. |

openssl-1.0.1c.p0.spkg | SPKG.txt: From wikipedia: OpenSSL is an open source implementation of the SSL and TLS protocols. The core library (written in the C programming language) implements the basic cryptographic functions and provides various utility functions. Wrappers allowing the use of the OpenSSL library in a variety of computer languages are available. |

ore_algebra-0.1.spkg | SPKG.txt: A Sage implementation of Ore algebras and Ore polynomials. Main features for the most common algebras include basic arithmetic and actions; gcrd and lclm; D-finite closure properties; natural transformations between related algebras; guessing; desingularization; solvers for polynomials, rational functions and (generalized) power series. |

p_group_cohomology-1.0.1.spkg | SPKG.txt: Modular Cohomology Rings of Finite p-Groups The documentation of the package is provided at http://sage.math.washington.edu/home/SimonKing/Cohomology/ |

p_group_cohomology-1.2.p0.spkg | SPKG.txt: Modular Cohomology Rings of Finite p-Groups The documentation of the package is provided at http://sage.math.washington.edu/home/SimonKing/Cohomology/ |

p_group_cohomology-2.0.spkg | SPKG.txt: Modular Cohomology Rings of Finite Groups The documentation of the package is provided at http://sage.math.washington.edu/home/SimonKing/Cohomology/ |

p_group_cohomology-2.1.2.spkg | SPKG.txt: Modular Cohomology Rings of Finite Groups The documentation of the package is provided at http://sage.math.washington.edu/home/SimonKing/Cohomology/ |

p_group_cohomology-2.1.3.spkg | SPKG.txt: Modular Cohomology Rings of Finite Groups The documentation of the package is provided at http://sage.math.washington.edu/home/SimonKing/Cohomology/ |

p_group_cohomology-2.1.4.p1.spkg | SPKG.txt: |

p_group_cohomology-2.1.4.spkg | SPKG.txt: |

palp-2.1.p1.spkg | SPKG.txt: A Package for Analyzing Lattice Polytopes (PALP) is a set of C programs for calculations with lattice polytopes and applications to toric geometry. It contains routines for vertex and facet enumeration, computation of incidences and symmetries, as well as completion of the set of lattice points in the convex hull of a given set of points. In addition, there are procedures specialised to reflexive polytopes such as the enumeration of reflexive subpolytopes, and applications to toric geometry and string theory, like the computation of Hodge data and fibration structures for toric Calabi-Yau varieties. The package is well tested and optimised in speed as it was used for time consuming tasks such as the classification of reflexive polyhedra in 4 dimensions and the creation and manipulation of very large lists of 5-dimensional polyhedra. While originally intended for low-dimensional applications, the algorithms work in any dimension and our key routine for vertex and facet enumeration compares well with existing packages. |

pari-2.3.2.p3.spkg | SPKG.txt: Here is how to build a new version of the PARI SAGE spkg: 1) Get the latest stable source code from http://pari.math.u-bordeaux.fr/download.html (NOTE -- just like last time, at some point the devel version will be the way to go, since that's where all the bug fixes are. The PARI stable/devel model is complicated.) 2) Extract the above code and make it the directory src in the current directory. 3) Type ./spkg-dist in the above directory. 4) Extract the file galdata.tgz from http://pari.math.u-bordeaux.fr/download.html in the directory pari-*/src/ ----------------------------------- * 2007-09-09: (Michael Abshoff) add -fPIC to DCLFLAGS on Linux PPC in src/config/get_dlcflags * 2007-03-04: included Pablo De Napoli ([email protected])'s improvement so PARI will build on systems with runpath support. See sage/runpath.txt for details. * 2006-09-28: (William Stein and Justin Walker) Modified PARI build scripts so that they build the PARI *shared* library even under OS X, and on OS X intel they build the x86/gmp kernel. * I took the standard PARI tarball, but ran the script spkg-dist on it to create this directory. This script does various things to some of the PARI files to make them work better with SAGE, the most important being to replace calls to exit() with calls to abort(). * Also, I placed a directory "sage" in this directory with some files needed by spkg-install. * This changed removed -- 09/28/2006 #* I changed a line of config/Makefile.SH to # DLLDFLAGS |

pari-2.3.3.spkg | SPKG.txt: Here is how to build a new version of the PARI SAGE spkg: 1) Get the latest stable source code from http://pari.math.u-bordeaux.fr/download.html (NOTE -- just like last time, at some point the devel version will be the way to go, since that's where all the bug fixes are. The PARI stable/devel model is complicated.) 2) Extract the above code and make it the directory src in the current directory. 3) Type ./spkg-dist in the above directory. 4) Extract the file galdata.tgz from http://pari.math.u-bordeaux.fr/download.html in the directory pari-*/src/ ----------------------------------- * 2007-10-31: (Carl Witty) disable runpath altogether; we want Sage to be relocatable. install gphelp, and required documentation source files. * 2007-09-09: (Michael Abshoff) add -fPIC to DCLFLAGS on Linux PPC in src/config/get_dlcflags * 2007-03-04: included Pablo De Napoli ([email protected])'s improvement so PARI will build on systems with runpath support. See sage/runpath.txt for details. * 2006-09-28: (William Stein and Justin Walker) Modified PARI build scripts so that they build the PARI *shared* library even under OS X, and on OS X intel they build the x86/gmp kernel. * I took the standard PARI tarball, but ran the script spkg-dist on it to create this directory. This script does various things to some of the PARI files to make them work better with SAGE, the most important being to replace calls to exit() with calls to abort(). * Also, I placed a directory "sage" in this directory with some files needed by spkg-install. * This changed removed -- 09/28/2006 #* I changed a line of config/Makefile.SH to # DLLDFLAGS |

pari-2.4.0.alpha.spkg | SPKG.txt: |

pari-2.5.5.p1.spkg | SPKG.txt: PARI/GP is a widely used computer algebra system designed for fast computations in number theory (factorizations, algebraic number theory, elliptic curves...), but also contains a large number of other useful functions to compute with mathematical entities such as matrices, polynomials, power series, algebraic numbers etc., and a lot of transcendental functions. PARI is also available as a C library to allow for faster computations. Originally developed by Henri Cohen and his co-workers (Université Bordeaux I, France), PARI is now under the GPL and maintained by Karim Belabas with the help of many volunteer contributors. Website: http://pari.math.u-bordeaux.fr/ |

patch-2.5.9.p3.spkg | SPKG.txt: 'patch' takes a patch file containing a difference listing produced by the 'diff' program and applies those differences to one or more original files, producing patched versions. The version of 'patch' included is the GNU one. Some of the 'diff' files produced by GNU 'diff' are not acceptble to some versions of the 'patch' command, such as the 'patch' command that comes with Solaris. |

patchbot-1.0.spkg | SPKG.txt: Applies and run tests on open Sage tickets. |

patchbot-1.1.spkg | SPKG.txt: Applies and run tests on open Sage tickets. |

patchbot-1.2.5.spkg | SPKG.txt: Applies and run tests on open Sage tickets. |

patchbot-1.3.1.spkg | SPKG.txt: Applies and run tests on open Sage tickets. |

patchbot-1.3.spkg | SPKG.txt: Applies and run tests on open Sage tickets. |

patchbot-2.0.1.spkg | SPKG.txt: Applies and run tests on open Sage tickets. |

patchbot-2.0.spkg | SPKG.txt: Applies and run tests on open Sage tickets. |

patchbot-2.2.spkg | SPKG.txt: Applies and run tests on open Sage tickets. |

pexpect-2.0.p5.spkg | SPKG.txt: Pexpect is a pure Python module for spawning child applications; controlling them; and responding to expected patterns in their output. |

pexpect-2.1.spkg | SPKG.txt: |

phc-2.3.53.p0.spkg | SPKG.txt: PHCpack: a general-purpose solver for polynomial systems by homotopy continuation. Website: http://www2.math.uic.edu/~jan/PHCpack/phcpack.html |

phcpack-2.3.21.spkg | SPKG.txt: |

polybori-0.1-r4.spkg | SPKG.txt: |

polybori-0.8.3.spkg | SPKG.txt: The core of PolyBoRi is a C++ library, which provides high-level data types for Boolean polynomials and monomials, exponent vectors, as well as for the underlying polynomial rings and subsets of the powerset of the Boolean variables. As a unique approach, binary decision diagrams are used as internal storage type for polynomial structures. On top of this C++-library we provide a Python interface. This allows parsing of complex polynomial systems, as well as sophisticated and extendable strategies for Gröbner base computation. PolyBoRi features a powerful reference implementation for Gröbner basis computation. |

polymake-2.2.p2.spkg | SPKG.txt: |

polymake-2.2.p3.spkg | SPKG.txt: |

polymake-2.2.spkg | SPKG.txt: |

polytopes_db-20120220.spkg | SPKG.txt: This package includes lists of 2- and 3-dimensional reflexive polytopes. The list of polygons is quite easy to get and it has been known for a while. The list of 3-polytopes was originally obtained by Maximilian Kreuzer and Harald Skarke using their software PALP, which is included into the standard distribution of Sage. To work with lattice and reflexive polytopes from Sage you can use sage.geometry.lattice_polytope module, which relies on PALP for some of its functionality. To get access to the databases of this package, use ReflexivePolytope and ReflexivePolytopes commands. |

ppl-1.1pre9.p0.spkg | SPKG.txt: GPL v3+ |

pycrypto-2.1.0.spkg | SPKG.txt: The Python Cryptography Toolkit describes a package containing various cryptographic modules for the Python programming language. It is intended to provide a reliable and stable base for writing Python programs that require cryptographic functions. |

pycryptoplus-20100809-git.spkg | SPKG.txt: Extension for PyCrypto which provides more ciphers. For details see http://wiki.yobi.be/wiki/PyCryptoPlus |

pygments-1.3.1.p0.spkg | SPKG.txt: Pygments is a syntax highlighting package written in Python. It is a generic syntax highlighter for general use in all kinds of software such as forum systems, wikis or other applications that need to prettify source code. |

pynac-0.3.0.spkg | SPKG.txt: A modified version of GiNaC that replaces the dependency on CLN by Python. |

pysqlite-2.3.3.spkg | SPKG.txt: |

python-2.5.1-framework.spkg | SPKG.txt: |

python-2.5.1.p10.spkg | SPKG.txt: This is Python from http://www.python.org |

python-2.5.1.p6.spkg | SPKG.txt: This is Python from http://www.python.org |

python-unladen-2009Q2.spkg | SPKG.txt: Python is a dynamic object-oriented programming language that can be used for many kinds of software development. It offers strong support for integration with other languages and tools, comes with extensive standard libraries, and can be learned in a few days. Many Python programmers report substantial productivity gains and feel the language encourages the development of higher quality, more maintainable code. For more details see http://www.python.org |

pyzmq-2.1.11.p0.spkg | SPKG.txt: Python bindings for the zeromq networking library. |

pyzmq-2.1.11.p1.spkg | SPKG.txt: Python bindings for the zeromq networking library. |

r-2.6.1.p1.spkg | SPKG.txt: Updated the rpy package using trac #1427 |

r-2.6.1.p2.spkg | SPKG.txt: Updated the rpy package using trac #1427 |

r-2.6.1.p3.spkg | SPKG.txt: Updated the rpy package using trac #1427 |

r-2.6.1.p4.spkg | SPKG.txt: Updated the rpy package using trac #1427 |

r-2.6.1.p5.spkg | SPKG.txt: Updated the rpy package using trac #1427 |

r-2.6.1.p6.spkg | SPKG.txt: Updated the rpy package using trac #1427 |

r-2.6.1.spkg | SPKG.txt: Updated the rpy package using trac #1427 |

r-3.0.2.p0.spkg | SPKG.txt: R is a language and environment for statistical computing and graphics. It is a GNU project which is similar to the S language and environment which was developed at Bell Laboratories (formerly AT&T, now Lucent Technologies) by John Chambers and colleagues. R can be considered as a different implementation of S. There are some important differences, but much code written for S runs unaltered under R. (taken from http://www.r-project.org/) |

ratpoints-2.1.3.p3.spkg | SPKG.txt: Michael Stoll's program which searches for rational points on hyperelliptic curves. |

readline-6.2.p4.spkg | SPKG.txt: The GNU Readline library provides a set of functions for use by applications that allow users to edit command lines as they are typed in. Both Emacs and vi editing modes are available. The Readline library includes additional functions to maintain a list of previously-entered command lines, to recall and perhaps reedit those lines, and perform csh-like history expansion on previous commands. Website: http://tiswww.case.edu/php/chet/readline/rltop.html |

rpy2-2.0.8.p0.spkg | SPKG.txt: rpy2 is a redesign and rewrite of rpy. It is providing a low-level interface to R, a proposed high-level interface, including wrappers to graphical libraries, as well as R-like structures and functions. Website: http://rpy.sourceforge.net/rpy2.html |

rubiks-20070912.p18.spkg | SPKG.txt: There are several programs for working with Rubik's cubes, by three different people. Look inside the directories under /src to see specific info and licensing. In summary the three contributers are: Michael Reid (GPL) http://www.math.ucf.edu/~reid/Rubik/optimal_solver.html optimal - uses many pre-computed tables to find an optimal solution to the 3x3x3 Rubik's cube Dik T. Winter (MIT License) cube - uses Kociemba's algorithm to iteratively find a short solution to the 3x3x3 Rubik's cube size222 - solves a 2x2x2 Rubik's cube Eric Dietz (GPL) http://www.wrongway.org/?rubiksource cu2 - A fast, non-optimal 2x2x2 solver cubex - A fast, non-optimal 3x3x3 solver mcube - A fast, non-optimal 4x4x4 solver |

sage-mode-0.6.spkg | SPKG.txt: sage-mode provides Emacs Lisp that helps you use Sage in GNU Emacs. '''Warning!''' This is alpha code. This might fail horribly and is not (yet) easily customizable! |

sage-mode-0.7.spkg | SPKG.txt: sage-mode provides Emacs Lisp that helps you use Sage in GNU Emacs. |

sage_mode-0.10.spkg | SPKG.txt: sage-mode provides Emacs Lisp that helps you use Sage in GNU Emacs. Inspiration was provided by ipython.el originally. |

sage_mode-0.9.1.spkg | SPKG.txt: sage-mode provides Emacs Lisp that helps you use Sage in GNU Emacs. Inspiration was provided by ipython.el originally. |

sagenb-0.10.7.2.spkg | SPKG.txt: The Sage Notebook is a web-based graphical user interface for mathematical software. |

sagetex-2.1.1.spkg | SPKG.txt: The SageTeX package allows you to embed code, results of computations, and plots from Sage into LaTeX documents. |

sagetex-2.3.4.spkg | SPKG.txt: The SageTeX package allows you to embed code, results of computations, and plots from Sage into LaTeX documents. |

scipy-0.12.0.p1.spkg | SPKG.txt: SciPy (pronounced "Sigh Pie") is open-source software for mathematics, science, and engineering. The SciPy library depends on NumPy, which provides convenient and fast N-dimensional array manipulation. The SciPy library is built to work with NumPy arrays, and provides many user-friendly and efficient numerical routines such as routines for numerical integration and optimization. Together, they run on all popular operating systems, are quick to install, and are free of charge. NumPy and SciPy are easy to use, but powerful enough to be depended upon by some of the world's leading scientists and engineers. |

scipy-0.7.p3.spkg | SPKG.txt: * William Stein * Josh Kantor * Jason Grout |

scipy_sandbox-20071020.p4.spkg | SPKG.txt: * Josh Kantor * Michael Abshoff |

scons-1.2.0.spkg | SPKG.txt: SCons is an Open Source software construction tool—that is, a next-generation build tool. Think of SCons as an improved, cross-platform substitute for the classic Make utility with integrated functionality similar to autoconf/automake and compiler caches such as ccache. In short, SCons is an easier, more reliable and faster way to build software. Website: http://www.scons.org/ |

setuptools-0.6.16.p0.spkg | SPKG.txt: setuptools is a collection of enhancements to the Python distutils (for Python 2.3.5 and up on most platforms; 64-bit platforms require a minimum of Python 2.4) that allow you to more easily build and distribute Python packages, especially ones that have dependencies on other packages. Website: http://pypi.python.org/pypi/setuptools/ The present spkg is based on the fork of setuptools known as distribute. Website: http://pypi.python.org/pypi/distribute |

setuptools-0.6.spkg | SPKG.txt: setuptools is a collection of enhancements to the Python distutils (for Python 2.3.5 and up on most platforms; 64-bit platforms require a minimum of Python 2.4) that allow you to more easily build and distribute Python packages, especially ones that have dependencies on other packages. * http://pypi.python.org/pypi/setuptools/ |

singular-3-0-3-1-20071010.spkg | SPKG.txt: * 20070823 Juan M. Bello Rivas <[email protected]> + dropped dependencies on flex and bison * 20070802 Martin Albrecht <[email protected]> + new upstream release (3-0-3) + adapted new spkg structure (all changes in patches subdirectory) * 20070506 Martin Albrecht <[email protected]> + build script improvements + changes to libsingular.h * 20070326 Martin Albrecht <[email protected]> + rewrote spkg-install + added first alpha of libsingular.so + removed stand-alone libfactory * 20070105 William Stein + included Singular/Singular.rc.in which was missing for some reason and is needed by the cygwin build. * 20060825 Martin Albrecht <[email protected]> + removed hannes-sprueche.txt (not funny anyway) + removed ntl subdirectory (we ship NTL already) + removed modules subdirectory (not needed) + removed Tst subdirectory (not needed) + wrote (very simple) spkg-install from scratch * 20060831 William Stein and Justin Walker -- fine tuning for OS X. * 20060831 William Stein -- put a lot of the workarounds from the previous Singular spkg-install script in here, since they are in fact needed in order for Singular to work after you type, e.g., make clean, or if you move the install directory. * Martin Albrecht -- add fix to libcf: Yes, It's a (new?) bug in libcf I've fixed just yesterday but got no word from the Singular people yet. They free a char ptr they are not supposed to free if I understand the ostrstring docs correctly. I've attached the one-line-fixed int_poly.cc which belongs in the factory subdirectory of Singular. * Martin Albrecht -- 2006-09-17: This looks to me as if I didn't remove all references to boost: /usr/include/boost/dynamic_bitset/dynamic_bitset.hpp:1098: error: exception I've attached an updated configure.in and configure (created with autoconf 2.60) with Boost checks disabled which should fix the problem. These belong in the Singular subdirectory: singular-3-0-2-2006-09-09/Singular |

singular-3-0-4-1-20071202.spkg | SPKG.txt: deprecated, use 'hg log' instead * 20070823 Juan M. Bello Rivas <[email protected]> + dropped dependencies on flex and bison * 20070802 Martin Albrecht <[email protected]> + new upstream release (3-0-3) + adapted new spkg structure (all changes in patches subdirectory) * 20070506 Martin Albrecht <[email protected]> + build script improvements + changes to libsingular.h * 20070326 Martin Albrecht <[email protected]> + rewrote spkg-install + added first alpha of libsingular.so + removed stand-alone libfactory * 20070105 William Stein + included Singular/Singular.rc.in which was missing for some reason and is needed by the cygwin build. * 20060825 Martin Albrecht <[email protected]> + removed hannes-sprueche.txt (not funny anyway) + removed ntl subdirectory (we ship NTL already) + removed modules subdirectory (not needed) + removed Tst subdirectory (not needed) + wrote (very simple) spkg-install from scratch * 20060831 William Stein and Justin Walker -- fine tuning for OS X. * 20060831 William Stein -- put a lot of the workarounds from the previous Singular spkg-install script in here, since they are in fact needed in order for Singular to work after you type, e.g., make clean, or if you move the install directory. * Martin Albrecht -- add fix to libcf: Yes, It's a (new?) bug in libcf I've fixed just yesterday but got no word from the Singular people yet. They free a char ptr they are not supposed to free if I understand the ostrstring docs correctly. I've attached the one-line-fixed int_poly.cc which belongs in the factory subdirectory of Singular. * Martin Albrecht -- 2006-09-17: This looks to me as if I didn't remove all references to boost: /usr/include/boost/dynamic_bitset/dynamic_bitset.hpp:1098: error: exception I've attached an updated configure.in and configure (created with autoconf 2.60) with Boost checks disabled which should fix the problem. These belong in the Singular subdirectory: singular-3-0-2-2006-09-09/Singular |

singular-3-1-0-4-20100214.spkg | SPKG.txt: * assert.h: logic seems to be broken on some platforms * src.Singular.Makefile.in: adding SunOS for libSingular * kernel.rmodulon.cc: simple bugfix * mminit.cc: Work around problem with the wrong free being picked causing double frees |

singular-3-1-5.p9.spkg | SPKG.txt: Singular is a computer algebra system for polynomial computations, with special emphasis on commutative and non-commutative algebra, algebraic geometry, and singularity theory. |

sip-4.3.2.spkg | SPKG.txt: |

sphinx-1.1.2.p2.spkg | SPKG.txt: Sphinx is a tool that makes it easy to create intelligent and beautiful documentation for Python projects (or other documents consisting of multiple reStructuredText sources), written by Georg Brandl. It was originally created to translate the new Python documentation, but has now been cleaned up in the hope that it will be useful to many other projects. |

sqlite-3.7.17.p1.spkg | SPKG.txt: SQLite is a software library that implements a self-contained, serverless, zero-configuration, transactional SQL database engine. |

symmetrica-0.3.1.spkg | SPKG.txt: MAINTAINER: Mike Hansen SOURCE: http://www.mathe2.uni-bayreuth.de/axel/symneu_engl.html we include index.html, which is the above web site, which officially states that Symmetrica is PUBLIC DOMAIN. |

symmetrica-0.3.2.spkg | SPKG.txt: MAINTAINER: Mike Hansen SOURCE: http://www.mathe2.uni-bayreuth.de/axel/symneu_engl.html we include index.html, which is the above web site, which officially states that Symmetrica is PUBLIC DOMAIN. |

symmetrica-0.3.spkg | SPKG.txt: MAINTAINER: Mike Hansen SOURCE: http://www.mathe2.uni-bayreuth.de/axel/symneu_engl.html we include index.html, which is the above web site, which officially states that Symmetrica is PUBLIC DOMAIN. |

symmetrica-2.0.p9.spkg | SPKG.txt: Symmetrica is a program developed by Lehrstuhl Mathematik II of the University of Bayreuth. It has routines to handle the following topics * ordinary representation theory of the symmetric group and related groups (2/11/04) * ordinary representation theory of the classical groups * modular representation theory of the symmetric group * projective representation theory of the symmetric group * combinatorics of tableaux * symmetric functions and polynomials (7/22/04) * commutative and non commutative Schubert polynomials * operations of finite groups. * ordinary representation theory of Hecke algebras of type A_n For more details check http://www.symmetrica.de (currently redirects to http://www.algorithm.uni-bayreuth.de/en/research/SYMMETRICA) |

sympow-1.018.1.p11.spkg | SPKG.txt: SYMPOW is a package to compute special values of symmetric power elliptic curve L-functions. It can compute up to about 64 digits of precision. |

sympy-0.7.3.spkg | SPKG.txt: SymPy is a Python library for symbolic mathematics. It aims to become a full-featured computer algebra system (CAS) while keeping the code as simple as possible in order to be comprehensible and easily extensible. SymPy is written entirely in Python and does not require any external libraries, except optionally for plotting support. |

tachyon-0.98.9.p5.spkg | SPKG.txt: Tachyon is a raytracer developed by John E. Stone. Tachyon supports the typical ray tracer features, most of the common geometric primitives, shading and texturing modes, etc. It also supports less common features such as HDR image output, ambient occlusion lighting, and support for various triangle mesh and volumetric texture formats beneficial for molecular visualization (e.g. rendering VMD scenes). Currently not all of Tachyon's functionality is exported by the Sage interface. |

TOPCOM-0.16.2.p2.spkg | SPKG.txt: GPL v2 |

trac-20070112.spkg | SPKG.txt: |

valgrind-3.3.1.spkg | SPKG.txt: This is an optional spkg. It is Linux x86, x86-64, ppc and ppc64 only. Website: http://www.valgrind.org/ From the above website: Valgrind is an award-winning instrumentation framework for building dynamic analysis tools. There are Valgrind tools that can automatically detect many memory management and threading bugs, and profile your programs in detail. You can also use Valgrind to build new tools. The Valgrind distribution currently includes five production-quality tools: a memory error detector, a thread error detector, a cache and branch-prediction profiler, a call-graph generating cache profiler, and a heap profiler. It also includes two experimental tools: a data race detector, and an instant mem |

valgrind-3.5.0.p0.spkg | SPKG.txt: This is an optional spkg. It is Linux x86, x86-64, ppc and ppc64 only. Website: http://www.valgrind.org/ From the above website: Valgrind is an award-winning instrumentation framework for building dynamic analysis tools. There are Valgrind tools that can automatically detect many memory management and threading bugs, and profile your programs in detail. You can also use Valgrind to build new tools. The Valgrind distribution currently includes five production-quality tools: a memory error detector, a thread error detector, a cache and branch-prediction profiler, a call-graph generating cache profiler, and a heap profiler. It also includes two experimental tools: a data race detector, and an instant mem |

valgrind-3.7.0.spkg | SPKG.txt: This is an optional spkg. It supports Linux on x86, x86-64, ppc, ppc64 and ARM as well as Darwin (Mac OS X 10.5 and 10.6) on x86 and x86-64. Valgrind is an instrumentation framework for building dynamic analysis tools. There are Valgrind tools that can automatically detect many memory management and threading bugs, and profile your programs in detail. You can also use Valgrind to build new tools. The Valgrind distribution currently includes six production-quality tools: a memory error detector, two thread error detectors, a cache and branch-prediction profiler, a call-graph generating cache and branch-prediction profiler, and a heap profiler. It also includes three experimental tools: a heap/stack/global array overrun detector, a second heap profiler that examines how heap blocks are used, and a SimPoint basic block vector generator. It runs on the following platforms: X86/Linux, AMD64/Linux, ARM/Linux, PPC32/Linux, PPC64/Linux, S390X/Linux, ARM/Android (2.3.x), X86/Darwin and AMD64/Darwin (Mac OS X 10.6 and 10.7). |

valgrind-3.8.1.p0.spkg | SPKG.txt: This is an optional spkg. It supports Linux on x86, x86-64, ppc, ppc64 and ARM as well as Darwin (Mac OS X 10.5 and 10.6) on x86 and x86-64. Valgrind is an instrumentation framework for building dynamic analysis tools. There are Valgrind tools that can automatically detect many memory management and threading bugs, and profile your programs in detail. You can also use Valgrind to build new tools. The Valgrind distribution currently includes six production-quality tools: a memory error detector, two thread error detectors, a cache and branch-prediction profiler, a call-graph generating cache and branch-prediction profiler, and a heap profiler. It also includes three experimental tools: a heap/stack/global array overrun detector, a second heap profiler that examines how heap blocks are used, and a SimPoint basic block vector generator. It runs on the following platforms: X86/Linux, AMD64/Linux, ARM/Linux, PPC32/Linux, PPC64/Linux, S390X/Linux, ARM/Android (2.3.x), X86/Darwin and AMD64/Darwin (Mac OS X 10.6 and 10.7). |

valgrind_3.3.0.spkg | SPKG.txt: This is an optional spkg. It is Linux x86, x86-64, ppc and ppc64 only. Website: http://www.valgrind.org/ From the above website: Valgrind is an award-winning instrumentation framework for building dynamic analysis tools. There are Valgrind tools that can automatically detect many memory management and threading bugs, and profile your programs in detail. You can also use Valgrind to build new tools. The Valgrind distribution currently includes five production-quality tools: a memory error detector, a thread error detector, a cache and branch-prediction profiler, a call-graph generating cache profiler, and a heap profiler. It also includes two experimental tools: a data race detector, and an instant mem |

valgrind_3.3.0svn_omega-r7025.spkg | SPKG.txt: Maintainer: Michael Abshoff * 2007-10-08: update to 3.3.0svn-r6959 * Initial version: 3.3.0svn-r6814 |

vtk-5.0.2.spkg | SPKG.txt: |

vtk-5.0.3.p1.spkg | SPKG.txt: |

vtk-5.0.3.spkg | SPKG.txt: The Visualization ToolKit (VTK) is an open source, freely available software system for 3D computer graphics, image processing, and visualization used by thousands of researchers and developers around the world. VTK consists of a C++ class library, and several interpreted interface layers including Tcl/Tk, Java, and Python. * http://www.vtk.org/ * http://www.vtk.org/what-is-vtk.php |

vtk-5.0.4.p0.spkg | SPKG.txt: The Visualization ToolKit (VTK) is an open source, freely available software system for 3D computer graphics, image processing, and visualization used by thousands of researchers and developers around the world. VTK consists of a C++ class library, and several interpreted interface layers including Tcl/Tk, Java, and Python. * http://www.vtk.org/ * http://www.vtk.org/what-is-vtk.php |

vtk-5.2.1.spkg | SPKG.txt: The Visualization ToolKit (VTK) is an open source, freely available software system for 3D computer graphics, image processing, and visualization used by thousands of researchers and developers around the world. VTK consists of a C++ class library, and several interpreted interface layers including Tcl/Tk, Java, and Python. * http://www.vtk.org/ * http://www.vtk.org/what-is-vtk.php |

vtk-5.2.spkg | SPKG.txt: |

zeromq-2.2.0.p0.spkg | SPKG.txt: A modern networking library. Also known as 0mq or zmq. The same API is provided by http://www.crossroads.io, though we currently use the http://www.zeromq.org implementation. |

zeromq-3.2.0.p0.spkg | SPKG.txt: A modern networking library. Also known as 0mq or zmq. The same API is provided by http://www.crossroads.io, though we currently use the http://www.zeromq.org implementation. |

zlib-1.2.8.p0.spkg | SPKG.txt: Massively Spiffy Yet Delicately Unobtrusive Compression Library (Also Free, Not to Mention Unencumbered by Patents) |

zn_poly-0.9.p11.spkg | SPKG.txt: zn_poly is a C library for polynomial arithmetic in Z/nZ[x], where n is any modulus that fits into an unsigned long. Website: http://cims.nyu.edu/~harvey/zn_poly/ |

zodb3-3.7.0.p0.spkg | SPKG.txt: * bump spkg due to python now using ucs4 |