Ports Search

sfft is a library to compute discrete Fourier transforms of signals with a sparse frequency domain, using an algorithm that is more efficient than other known FFT algorithms. It was developed by Haitham Hassanieh, Piotr Indyk, Dina Katabi, and Eric Price at the Computer Science and Artifical Intelligence Lab at MIT. Performance optimizations were developed by J. Schumacher at the Computer Science Department of ETH Zurich in 2013.

Solitaire is an encryption system based on a deck of cards by Bruce Schneier. Although it is designed to be worked out by a human, it can work on computers. This is the reference implementation programmed in Perl. The program itself is installed as 'solitaire', and the source code and test vectors are installed in share/doc/solitaire. Please read the web site below before relying on this for real security.

This program demonstrates the working principles of some 20 sorting algorithms and is very easy to use. Select the algorithm, the speed of the visualisation and whether you want to get sound output (that reflects the values being moved and is characteristic for each kind of algorithm).

SuperLU is a general purpose library for the direct solution of large, sparse, nonsymmetric systems of linear equations on high performance machines. The library is written in C and is callable from either C or Fortran. The library routines will perform an LU decomposition with partial pivoting and triangular system solves through forward and back substitution. The LU factorization routines can handle non-square matrices but the triangular solves are performed only for square matrices. The matrix columns may be preordered (before factorization) either through library or user supplied routines. This preordering for sparsity is completely separate from the factorization. Working precision iterative refinement subroutines are provided for improved backward stability. Routines are also provided to equilibrate the system, estimate the condition number, calculate the relative backward error, and estimate error bounds for the refined solutions.

SuperLU_MT (version 2.0) ======================== SuperLU_MT contains a set of subroutines to solve a sparse linear system A*X=B. It uses Gaussian elimination with partial pivoting (GEPP). The columns of A may be preordered before factorization; the preordering for sparsity is completely separate from the factorization. SuperLU_MT is a parallel extension to the serial SuperLU library. SuperLU_MT is implemented in ANSI C, with multithreading extension, for example, using POSIX threads. Currently, only the LU factorization routine, which is the most time-consuming part of the solution process, is parallelized on machines with a shared address space. The other routines, such as column preordering and the forward and back substitutions are performed sequentially. This "alpha" release contains only double-precision real data type. Xiaoye S. Li, Lawrence Berkeley National Lab, xiaoye@nersc.gov James Demmel, Univ. of California Berkeley, demmel@cs.berkeley.edu John R. Gilbert, Xerox Palo Alto Research Center, gilbert@parc.xerox.com NOTE: This library has to be linked with BLAS or a thread safe replacement.

The current version of the library includes the following functionality: * Multifrontal Supernodal Cholesky Factorization. * Left-Looking Supernodal Cholesky Factorization. * Drop-Tolerance Incomplete-Cholesky Factorization. * LDL^T Factorization. * Out-of-Core, Left-Looking Supernodal Sparse Cholesky Factorization. * Out-of-Core Sparse LU with Partial Pivoting Factor and Solve. * Ordering Codes and Interfaces to Existing Ordering Codes. * Matrix Operations. * Matrix Input/Output. * Matrix Generators. * Iterative Solvers. * Vaidya's Preconditioners. * Recursive Vaidya's Preconditioners. * Multilevel-Support-Graph Preconditioners. * Utility Routines. Copyright (c) 2001 by Sivan Toledo, Tel-Aviv University, stoledo@tau.ac.il. All Rights Reserved.

This portable, modular Fortran 90 software package implements the thick-restart Lanczos method, for use with real symmetric or complex Hermitian eigenvalue problems where a small number of eigevalues and eigenvectors are needed, and the matrices involved may be too large to store in computer memory. Most of the arithmetic computations in the software are done through calls to BLAS and LAPACK. The software can be instructed to write checkpoint files so that it can be restarted is a later time.

ump is a graphical, easy to use math program, which works with complex numbers, matrices, functions and much more.

The Free Software Foundation's "units" unit conversion and calculation utility. GNU units converts quantities expressed in various scales to their equivalents in other scales. Units can only handle multiplicative scale changes. For example, it cannot convert Celsius to Fahrenheit but it can convert temperature differences between those temperature scales. The units are defined externally in an extensive, well annotated data file that defines over 2000 units. You can also provide your own data file. Note that this port will install the utility with a 'g' prefix, e.g. gunits, but the texinfo documentation will refer to it without the 'g' prefix.

UNU.RAN (Universal Non-Uniform RAndom Number generator) is a collection of algorithms for generating non-uniform pseudorandom variates as a library of C functions designed and implemented by the ARVAG (Automatic Random VAriate Generation) project group in Vienna, and released under the GNU Public License (GPL). It is especially designed for situations where: - a non-standard distribution or a truncated distribution is needed; - experiments with different types of distributions are made; - random variates for variance reduction techniques are used; or - fast generators of predictable quality are necessary. UNU.RAN provides generators that are superior in many aspects to those found in quite a number of other libraries; however, due to its more sophisticated programming interface, it might not be as easy to use. It uses an object-oriented interface in which distributions and generators are treated as independent objects, so that different methods for generating non-uniform random variates may be chosen according to various criteria, such as speed, quality, and variance reduction. It is flexible enough to permit sampling from non-standard distributions, such as distributions that arise in a model and can only be computed in complicated subroutines.