Ports Search

SNNS (Stuttgart Neural Network Simulator) is a software simulator for neural networks on Unix workstations developed at the Institute for Parallel and Distributed High Performance Systems (IPVR) at the University of Stuttgart. The goal of the SNNS project is to create an efficient and flexible simulation environment for research on and application of neural nets. The SNNS simulator consists of two main components: 1) simulator kernel written in C 2) graphical user interface under X The simulator kernel operates on the internal network data structures of the neural nets and performs all operations of learning and recall. It can also be used without the other parts as a C program embedded in custom applications. It supports arbitrary network topologies and the concept of sites. SNNS can be extended by the user with user defined activation functions, output functions, site functions and learning procedures, which are written as simple C programs and linked to the simulator kernel. The graphical user interface XGUI (X Graphical User Interface), built on top of the kernel, gives a 2D and a 3D graphical representation of the neural networks and controls the kernel during the simulation run. In addition, the 2D user interface has an integrated network editor which can be used to directly create, manipulate and visualize neural nets in various ways.

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.

Spar is a modular math parser that comes with a fully featured text frontend, something like an interactive calculator. It also provides a simple but complete API for C/C++ programmers. This API provide a complete interface to a top down parser that supports: variables, constants, functions, modules and a libc based math library. This math library overrides standard functions with a "custom" version (such as. deg, rad auto conversion, infinite symbol, function domain...). Spar, can be easily extended with modules. A module is a "user" extensions, written in C/C++, to the basic features of the Simple Parser. Here you can find the module definition: is a C structure that contains only few data member: - module name - module version - module description - a pointer to the module main function The modules are loaded at run-time by the module loader (that is a high level layer of the module manager): you can load your modules, simply, coping theirs paths into the .spar_modules (or any other file, with the -c option).

This is an ANSI C++ implementation of the complete ANSI C specification of Chapter 3 of the BLAS Technical Forum Standard. The distribution is quite small and it is meant as a starting point for developing an optimized and architecture-dependent version. (C++ was used, rather than C, as it has support for complex arithmetic and templates to facilitate to creation of various precision codes.) The library includes support for all four precision types (single, double precision, real, and complex) and Level 1, 2, and 3 operations.

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.

surf is a tool to visualize some real algebraic geometry: plane algebraic curves, algebraic surfaces and hyperplane sections of surfaces. surf is script driven and has (optionally) a nifty GUI using the Gtk widget set. The algorithms should be stable enough not to be confused by curve/surface singularities in codimension greater than one and the degree of the surface or curve. This has been achieved quite a bit. We have drawn curves of degree up to 30 and surfaces of degree up to 20 successfully. However, there are examples of curves/surfaces of lower degree where surf fails to produce perfect images. This happens especially if the equation of the curve/surface is not reduced. Best results are achieved using reduced equations. On the other hand, surf displays the Fermat-curves accurately for degree up to 98.

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.

TestU01 is a software library, implemented in the ANSI C language, and offering a collection of utilities for the empirical statistical testing of uniform random number generators. The library implements several types of random number generators in generic form, as well as many specific generators proposed in the literature or found in widely-used software. It provides general implementations of the classical statistical tests for random number generators, as well as several others proposed in the literature, and some original ones. These tests can be applied to the generators predefined in the library and to user-defined generators. Specific tests suites for either sequences of uniform random numbers in [0,1] or bit sequences are also available. Basic tools for plotting vectors of points produced by generators are provided as well. Additional software permits one to perform systematic studies of the interaction between a specific test and the structure of the point sets produced by a given family of random number generators. That is, for a given kind of test and a given class of random number generators, to determine how large should be the sample size of the test, as a function of the generator's period length, before the generator starts to fail the test systematically.

TetGen is a program for generating tetrahedral meshes for arbitrary 3D domains. The main purpose of TetGen is to create high-quality tetrahedral meshes for solving partial differential equations using finite element and finite volume methods. This program, based on Delaunay methods, currently generates meshes including exact constrained Delaunay tetrahedralizations and quality (conforming Delaunay) meshes. For a 3D point set, it generates its exact Delaunay tetrahedralization and convex hull as well. The program is written in ANSI C++. It is highly portable, it should be very easy to compile and run on all major computer systems. It can be also used as a library embedded into other applications.