Next: Sa-Sm Up: Linux Software Encyclopedia Previous: Ra-Rm Contents

Rn-Rz

Last checked or modified: Mar. 9, 1997

RNASA: A program for refining rough sequence alignments using a parallel simulated annealing algorithm which takes into account connected base pairs in RNA stem regions. Sum-of-pair alignments generally aren't complete in terms of stem structure but rather indicate possible stem regions. RNASA refines these rough alignments with a simulated annealing procedure which optimizes the score obtained by connecting base pairs and covariance matches. This obtains a proper RNA-sequence alignment from which stem regions can be specified.
A source code distribution of RNASA is available. It is written in KL1 and can be used on UNIX platforms on which KLIC has already been installed. This software is part of the ICOT project.
[http://www.icot.or.jp/AITEC/IFS/IFS-abst/095.html]
RNPL: The Rapid Numerical Prototyping Language is a tool to help scientists solve equations quickly by automatically taking care of everything except the innermost parts of the solution routines. This language for the facilitation of time-dependent finite-difference computations can be used for producing complete programs, producing skeleton programs, or for converting existing programs. The source code is available and installs on most generic UNIX systems, although it requires both Perl and HDF to be already installed. This is part of the University of Texas Computational Toolkit for Numerical Relativity, at which site you can also find RNPL documention in PostScript format.
[ftp://helmholtz.ph.utexas.edu/pub/rnpl]
Roadrunner: An operating system kernel based on the POSIX Pthreads standard. The design goals of this project include:

documentation via the literate programming techniques of noweb;

the implementation of only a fixed-priority scheduling algorithm;

implementation of only a subset of the Pthreads standard; and

extreme portability via use of C and the GNU programming tools.

A bootable floppy disk image and a source code distribution are available. A user's and reference manual is also available in PostScript format.
[http://www.cornfed.com/]
ROADS: Resource Organization And Discovery in Subject-based services is a software system along with a set of standards that can be used to set up subject-based information gateways, i.e. searchable and browsable indexes of resources based around a particular topic. The gateway can be either searched or browsers by users, and resources can be located throughout the gateway at various levels of topic and geography. A ROADS gateway allows resources to be fully described or abstracted and classified according to a recognized classification scheme, allowing resources to be located much more efficiently.
The ROADS software consists of a package of Perl modules which are installed on a Web server. It is a toolkit containing tools for the creation and maintenance of records in a database of resource descriptions, the automatic creation of a set of WWW pages using the information in the records, and the indexing, searching and retrieval of database records using simple keyword or Boolean searches. A source code distribution of ROADS is available. It is written in Perl and documented in several manuals as well as in a series of man pages.
[http://www.ilrt.bris.ac.uk/roads/]
ROBIN: A reasonably CORBA 2.0 compliant distributed object and remote procedure call system based on TCP/IP. In particular, it uses: the CORBA Interface Description Language (IDL) with one extension to improve procedure calls; the CORBA Dynamic Invocation Interface (DII); a low overhead (although proprietary) equivalent to the CORBA Dynamic Skeleton Interface (DSI); and a subset of the ORB Interface. The IDL compiler generates client stubs which use the DII and server skeletons which use the proprietary DSI. Services may be written in C while clients may be written in C, C++, or Java. The basic usefulness of ROBIN is that it allows you to build distributed software. It supports both object-oriented adn traditional programming by supporting both CORBA and RPC.
The ROBIN package consists of three basic pieces: an IDL compiler, a client library, and a server. The server ROBINserver supports host-based authentication and location independence and redundancy using IP multicasting. The IDL compiler ROBINidl supports IDL as specified in CORBA 2.0 with some omissions and restrictions. It can make use of the interface repository and requires it if inheritance is used. CORBA extensions offered by ROBIN include RPC support (via its own proprietary RPC mechanism) and C/C++ bindings.
The ROBIN distribution includes the source code for everything as well as binaries for several systems including Linux Intel platforms. The package is documented in several HTML files and a user's guide in PostScript format included in the distribution.
[ftp://www-b0.fnal.gov/pub]
ROBOOP: The ROBotics Object Oriented Package is an object-oriented C++ library for robotics synthesis and simulation. The ROBOOP programs are divided into several classes. The class of 3-D homogeneous transforms includes:

eulzxz, returns the homogeneous transform matrix of a vector;

ieulzxz, performs the inverse of eulzxz;

rotk, returns the matrix of a rotation of an given angle around a given vector;

irotk, performs the inverse of rotk;

rpy, returns the homogeneous transform matrix of a column vector;

irpy, performs the inverse of rpy;

rotd, returns the matrix of the rotation of an given angle around a oriented line segment;

rotx, roty, rotz, return the elementary rotation matrices; and

trans, returns the transform matrix of a column vector.

The robot class includes:

kine, computes a forward kinematic model using a recursion relation;

inv_kin, computes an inverse kinematic model using a Newton-Raphson technique;

dTdqi, computes partial derivatives;

acceleration, computes acceleration, i.e. solves the forward dynamics problem;

inertia, computes the robot inertia matrix;

torque, solves the inverse dynamics problem; and

torque_novelocity, solves the inverse dynamics problem with zero velocity and gravity.

There are also graphics and miscellaneous classes, with the latter containing routines for integrating ODEs using Runge-Kutta schemes. A source code distribution of ROBOOP is available. It is documented in a user's manual available in the usual formats.
[http://www.cours.polymtl.ca/roboop/]
Robot: An XView-based plotting and data analysis program. The features of Robot include:

graphic drawing in various styles, e.g. error bars, historams, symbols, lines, etc.;

data manipulation (e.g. arithmetic, functions, Fourier transforms, smoothing, etc.);

fitting data using built-in functions such as Gaussians, polynomials, Lorentzians, or user-defined functions;

the annotation of graphics with text in various styles;

simple drawing tools;

interaction via pull-down menus and a pseudo-command line type interface;

the automatic storage of commands in log files; and

multiple-color plots with output in PostScript format.

The source code for Robot, written in C and Fortran (the data manipulation programs), is available along with binaries for Linux, SUN, and DECstation platforms. Compilation also requires the XView library. Documentation is contained within a user's manual in PostScript format. There is also an original Robot FTP site.
[http://heasarc.gsfc.nasa.gov/docs/xte/SOF/robot.html]
[http://sunsite.unc.edu/pub/Linux/science/visualization/]
Robotics Toolbox: A Matlab toolbox which provides functions useful for robotics applications and addresses such areas as kinematics, dynamics, and trajectory generation. It is useful for simulation as well as for analyzing results from experiments with real robots. The Toolbox is based on a very general method of representing the kinematics and dynamics of serial-link manipulators by description matrices. These matrices provide a concise means of describing a robot model with one goal being to facilitate the sharing of robot models in the research community. The Toolbox also provides various functions for manipulating datatypes such as vectors, homogeneous transformations, and unit quaternions which are needed to represent 3-D position and orientation.
The Robotics Toolbox can be used with Matlab or with the freely available Octave package which can run most Matlab m-files. It is documented in a 70 page user's and reference manual in PostScript format.
[ftp://ftp.mathworks.com/pub/contrib/v4/misc/]
rocat: A fully-featured BBS for Linux.
[http://sunsite.unc.edu/pub/Linux/system/bbs/]
ROL: A deductive object-oriented database system that supports features such as object identity, complex objects, classes, class hierarchies, multiple inheritance with overriding and blocking, and schema definition. ROL also supports structured values such as functor objects and sets which provide powerful mechanisms for representing both partial and complete information about sets. It provides a uniform declarative language (also called ROL) for defining, manipulating and querying databases. The ROL system is implemented as a single-user database system, and has been used to teach advanced database courses at a number of universities.
The ROL language is an extension of the deductive database language Datalog and subsumes it as a special case, so the package can be used for both object-oriented and value-oriented deductive databases. Values, object identifiers, functor objects and sets are treated uniformly as objects so functional dependencies can be directly and more generally represented than in functional data models. Powerful set representation mechanisms combining LDL and F-logic are provided in which information can be represented partially or completely. A key element in ROL is a well-defined logical semantics that cleanly accounts for most of its object-oriented and value-oriented features.
Binary distributions of ROL are available for DEC Ultrix, Sun Solaris, SGI IRIX, and Linux Intel platforms. A user's manual and various technical reports are available in PostScript format.
[http://www.cs.uregina.ca/~mliu/ROL/]
ROMIO: A high performance, portable implementation of the I/O specification in MPI-2, i.e. MPI-IO. ROMIO is optimized for the noncontinguous access patterns commonly found in parallel applications. It features an optimized implementation of collective I/O and includes everything defined in MPI-2 I/O except file info, shared file pointer functions, split collective data access routines, support for file interoperability, I/O error handling, and I/O error classes. C, Fortran, and profiling interfaces are provided for all functions which have been implemented. Also implemented are the subarray and distributed array datatype constructors from the MPI-2 miscellaneous chapter (which facilitate I/O involving arrays. Supported file systems include IBM PIOFS, Intel PFS, NFS, and any UNIX file system.
A source code distribution of ROMIO is available. It is written in C and runs on a wide variety of parallel and serial machines including Linux Intel. ROMIO can be used with the MPICH implementation of MPI. A user's guide is available in PostScript format.
[http://www-unix.mcs.anl.gov/romio/]
ROOT: A comprehensive object-oriented framework which provides a foundation upon which large scale data analysis applications can be built. The ROOT system provides a set of object-oriented frameworks with all the functionality needed to handle and analyze large amounts of raw data in an efficient way. The data are defined as a set of objects and specialized storage methods are used to gain direct access to the separate attributes of the selected objects without having to deal with the bulk of the data. The available classes include those for creating histograms in 1-, 2-, and 3-D, curve fitting, function evaluation, minimization, and graphics and visualization. These classes allow an analysis system to be easily created that can query and process data either interactively or in batch mode.
The backbone of the ROOT architecture is a layered class hierarchy with over 250 classes grouped into 21 frameworks divided into 11 categories. This is organized in a mostly single-rooted class library wherein most of the classes inherit from a common base class. A built-in C++ interpreter allows the command language, the scripting (or macro) language, and the programming language to all be C++. The interpreter allows the fast prototyping of macros which can then be compiled using a C++ compiler if better performance is required.
The class categories include:

basic ROOT classes that contain the low-level building blocks which implement common behavior for all classes;

container classes which provide general purpose data structure classes like arrays, lists, sets, maps, etc.;

histogram and minimization classes which offer advanced statistical data analysis features;

tree and ntuple classes which contain the tree system;

2-D grpahics classes providing low-level graphics primitives as well as higher level constructs;

3-D graphics and detector geometry classes that provide basic 3-D graphics primitives as well as higher level geometrical shapes;

Motif graphical user interface classes;

interactive interface classes with a C++ interpreter;

an operating system interface class;

networking classes to construct client/server applications; and

documentation classes for the creation of hypertext documents.

The ROOT Development Kit (RDK), containing over 300,000 lines of C and C++ source code compilable with the GNU G++ package, is available for Linux, HP-UX, DEC Alpha, AIX, Sun Solaris, SGI and Windows NT platforms. The Motif run-time library is needed for all UNIX platforms, although the Linux version works fairly well with the most recent version of Lesstif. The documentation consists of a 50+ page overview, a 50+ page tutorial, and a 500+ page description of all the ROOT classes. These are available in either PostScript or HTML format.
[http://root.cern.ch/]
Rosegarden: A musical notation editing and sequencing system. The features of Rosegarden include:

a musical notation editor supporting multiple staffs with chords, manual and automatic beaming, dynamic markings, slurs, ties, textual marks, triplets, and various other conveniences;

a MIDI sequencer and editor with textual event and piano roll display;

tool integration allowing music in MIDI form to be viewed and edited as notation and notation to be sequenced;

the ability to produce Csound output files;

MusicTeX output for typesetting and printing;

comprehensive online hypertext help;

a clean and consistent interface built using

Xaw (which may be replaced by Lesstif);

portability to various UNIX platforms;

the ability to use another MIDI playing program on systems where the built-in playback is unavailable or inadequate; and

mostly POSIX-compliant C code.

Planned features (5/97) include a new sequencing engine, a scripting language, multi-level undo/redo in the notation editor, and other enhancements.
The source code for Rosegarden is available. It is written in ANSI C and is portable to many UNIX platforms. Compilations requires the Xaw library. Binary versions of Rosegarden are available for Linux Intel (ELF) and SGI IRIX platforms. There is a user's guide in PostScript format in addition to the extensive online help.
[http://www.bath.ac.uk/ masjpf/rose.html]
RosettaMan: This has been renamed PolyglotMan.
ROSTAT: A collection of simple and robust statistical estimators for univariate datasets which includes moments, trimmed means, median, and other location estimates with jackknife and bias-corrected bootstrap confidence intervals. It also contains subroutines for the Hartigan dip statistic, goodness-of-fit tests for normality and uniformity, gap and outlier detection, and nonparametric tests for symmetry.
ROSTAT is a single large Fortran program containing several subroutines including:

BIASAD, for finding the adjustment required to implement a bias-corrected percentile method;

BMED, for calculating the broadened median for a set of ordered statistics;

BOOTSTRAP, for creating a bootstrap array of a set of simulated values;

CONFIDENCE, for calculating the confidence intervals for a set of location parameters, i.e. the straight mean, the median, and the bi-weight estimator;

DIPTST, for providing an estimator which gauges the probability a given data set is drawn from a parent population having a single mode;

EDFGOF, for testing a sample for uniformity, normality, or exponentiality using goodness-of-fit statistics based on the empirical distribution function;

GAPPER, for finding a list of gaps in a data set weighted by their location with respect to the middle of the data;

JACKNIFE, for calculating the expected error in the estimate of a supplied function via the statistical jacknife, i.e. obtaining the spread in the parameter when calculated by dropping one data point at a time;

KSREJ, for performing K-S clipping of a data set to delete outliers;

KURTSKEW, for finding kurtosis and skewness statistics;

LETTERS, for finding selected quantiles known as the letter values;

MCCON, for obtaining the BOOTSTRAP ocnfidence intervals for a parameter;

MOMENT, for finding the mean, average deviation, standard deviation, variance, skewness and kurtosis of a data set;

MONTE, for setting up Monte Carlo confidence intervals;

NORMALITY, for obtaining the tests for non-normality of a data sample;

NSCOR2, for finding an approximation to rankits;

SIGMA, which performs a 3-sigma clipping of a data set;

STATS, for computing various goodness-of-fit statistics;

SYMMETRY, which compares the gaps in an ordered data set from the right side to the left side of the median as a test of symmetry;

TAIL, which provides a robust estimate of the weight of the tails of a symmetric distribution;

TRANS, which calculates the power of a data set to make a more symmetric distribution;

TRIM, which finds the trimmed mean of a data set;

TRIMEAN, for finding the trimean of a data set;

XAD, which calculates the mean absolute deviation from the sample median;

XBIWT, which provides an estimator of the location and scale of a data set;

XMAD, which calculates the median absolute deviation from the sampled median;

XMIDMEAN, for calculating the midmean;

WEXT, for calculating the Shapiro and Wilk W statistic and its significance level;

and several other auxiliary functions.
The program is written in Fortran 77 and can be compiled using g77 0.5.19 after a few modifications. I've made those modifications and a compilable version is available as rostat-g77.f. There is very little documentation for this other than in the program itself. Sample input and output files for the program are available in the same directory.
[ftp://kula.phsx.ukans.edu/pub/kmm/]
rotfl: A simple text formatting language based on a small set of markup tags. Files containing one or more records are processed to create formatted text. Lines of text with tags are processed while lines without tags are formatted as-is. Current (7/99) features include indentation, right and center justification, multiple records per file, multiple page records, and nested lists. More features are said to be on the way. A source code distribution of this Perl program is available.
[http://www.bangmoney.org/projects/rotfl/]
route: See NetTools.
Rover: A network management package based on the fact that network operators generally only want to know when something breaks. The Internet Rover package consists of a set of daemons, configuration files and an alert display application. These combine to perform a set of tests across a set of nodes and create a report only if something is broken. The executable programs in Rover are:

InetRoverd, a daemon that performs all tests (except for ping) specified in a file called the hostfile and writes the results of failed tests to a file called PROBLEM.FILE;

pingd, a ping daemon that tests all nodes specified in the hostfile and also writes failed tests to PROBLEM.FILE; and

Display, a program that displays the contents of PROBLEM.FILE in full-screen format.

A source code distribution of Rover is available. It is configured to compile on Sun platforms but can be tweaked for other UNIX flavors.
[http://www.merit.edu/internet.tools/rover/]
ROWMAP: A ROW code using Krylov techniques to solve large, stiff ODEs. ROWMAP solves the initial value problem for stiff systems of first-order ODEs. It is based on ROW methods of order 4 and uses Krylov techniques for the solution of linear systems. A special multiple Arnoldi process is used to preserve the order of the basic method with small Krylov dimensions. Step size control is done by embedding with a method of order 3. A source code distribution of this Fortran code is available. See Schmitt and Weiner (1995) and Weiner et al. (1996).
[http://www.mathematik.uni-halle.de/institute/numerik/software/]
Roxen: A modularized, object-oriented World Wide Web HTTP/1.0 and HTTP/0.9 compliant server. It is non-forking, which reduces the system load and makes connections and delivers documents faster; it is modular, so it can be easily extended and customized; it is easy to configure adn use with a WWW-based configuration interface; it is built upon virtual servers; and it uses advanced HTML pre-parsing. The source code is available as well as binary files for several platforms, including Linux. This used to be called Spinner. The main part is still freely available under the GPL although some additional modules are available commercially.
[http://www.roxen.com/]
RPC: Remote Procedure Calling is the ability to distribute the execution of functions on remote computers. RPC manages the exchange of data between computers to make remote execution transparent to the user, and applications based on it can use distributed network resources to significantly increase the computing power that can be applied to complex problems. RPC is a fundamental element in a distributed computing environment (DCE). The DCE-RPC project is aimed at providing such a capability for the Linux environment. The October 1997 issue of the Linux Journal contains an article about RPCs. See Bloomer (1992).
[http://www.faqs.org/rfcs/rfc1050.html]
[http://www.faqs.org/rfcs/rfc1057.html] [http://rfc.fh-koeln.de/rfc/html/rfc1831]
RPGBoard: A message board script with many features including:

support for multiple forums;

a file format with a function for autoarchiving, compression and deletion as well as file locking;

a message/previewer editor with a spell checker;

a web-based configurator;

selectable backgrounds;

configurable message tags;

default options and biographies for regulars;

a message search engine;

name/password detection via cookies;

interactive date/time stamps with timezone capability and color coding for recent messages;

deletion and undeletion of messages;

partial message saving;

a complete state utility;

a hidden spoiler message box;

an option for emailing of replies;

an option for banning IP addresses;

an optional word filter;

IP address/number lookups with proxy detection; and

detection of browsers and OS.

A source code distribution is available.
[http://www.resonatorsoft.com/software/rpgboard/]
RPilot: An interpreter for the IEEE standard programming language PILOT (i.e. the Programmed Inquiry, Learning, Or Teaching language). The language was originally designed to be used by teachers as an instruction aid. This interpreter doesn't completely implement the standard, but adds some extensions such as rudimentary debugging and the ability to call other programs. It is written in ANSI C.
[http://rpilot.sourceforge.net/]
RPlay: A flexible network audio system that allows sounds to be played to and from local and remote UNIX systems. The RPlay server supports several UNIX platforms including Linux, and the clients and client library should work on any system that supports Berkeley sockets. RPlay supports two network protocols. RPLAY is the Remote Play protocol which is connectionless and based on UDP. It uses one-way communication with the server via single UDP packets and is good for low bandwidth applications. RPTP is the Remote Play Transfer Protocol which is connection oriented and based on TCP. It uses two-way communication with the server via an interactive command language. It is intended for large bandwidth applications. The distribution contains:

rplayd, the audio server;

rplay, a sample RPLAY and RPTP client;

rptp, a sample RPTP client;

xrplay, an X11/XForms audio control panel; and

librplay, a library used by clients to speak with servers.

A source code distribution of RPlay is available. It is written in C and requires both X11 and XForms for compilation on most UNIX systems. Documentation is available in Texinfo format.
[http://sunsite.unc.edu/pub/Linux/apps/sound/servers/]
[http://rplay.doit.org/]
RPM: The Red Hat Package Manager is an open packaging system. It allows users to take source code for new software and package it into source and binary form such that binaries can be easily installed and tracked and source and be easily rebuilt. It also maintains a database of all packages and their files that can be used for verifying packages and querying for information about files and/or packages. It was originally developed and used for the Red Hat Linux Distribution but is available for anyone to use under the GPL license.
The RPM was designed to allow the use of pristine original sources for programs, i.e. a typical package contains the original source distribution plus a patch which is used to compile those sources. This makes it easier to keep up with new source code releases. RPM features powerful querying options which allow searches through the database for packages or even individual files and information such as what package a file belongs to and where it came from. It also has the ability to verify packages.
The RPM distribution can be built with or without an already installed RPM, which allows a new user who didn't install on entire RPM Linux Distribution to slowly spin up on using it. Installation requires Perl 5 (since it is written in that language) and working copies of both cpio and gunzip. Documentation is contained within a man page.
Software related to RPM includes:

Alien, a program that converts among RPM, DPKG, Stampede SLP and Slackware TGZ formats;

AutoRPM, which can mirror RPMs and some other tasks; and

RpmLevel, a program that extends the querying capabilities of RPM.

[http://www.rpm.org/]

Purp

Pugo-RPM is a tool for managing RPM pacakges. It is a text-based utility that uses the Ncurses library.
[http://www.lysator.liu.se/purp/]

RPM.CGI

A CGI script written in Perl that serves as a front-end to the RPM utility. It allows the browsing of the RPMs installed on a system and provides different pages for the information stored in the RPM database.
[http://eesa.webstar.co.uk/rpm_cgi/]

RpmLevel

A program that extends the querying capabilities of RPM. This can be used to keep track of the system patchlevels with respect to the original distribution CD. It allows quick overviews of packages not installed, upgraded packages, downgraded packages and third-party packages. It also gives an overview of the differences between releases of the same distribution.
[http://www.coralys.com/products/rpmlevel.shtml]

rpmlint

Checks for common errors in RPM packages.
[http://www.lepied.com/rpmlint/src/]

rpm2html

A program that automatically generates Web pages describing a set of RPM packages. It also identifies the dependencies between various packages and finds the packages needed to install a given package.
[http://rufus.w3.org/linux/rpm2html/]
RPQR79: A routine to compute the roots of a polynomial. See CPQR79.
RPRESS: The Reflectivity PRESSure package is for the computation of seismo-acoustic wavefields in range-independent fluid-solid media. The fluid-solid media handled consists of a fluid region interspaced between two (possibly vanishing) solid regions. The lower and upper boundaries may independently be either free, rigid or of homogeneous half-space type. This allows the programs to be used for applications in underwater acoustics as well as in plate acoustics and seismology. The package consists of five main programs:

repress, for computing the pressure field in a fluid region in a fluid-solid medium primarily by wavenumber integration;

rpressfw, for computing the full wavefield in a fluid-solid medium primarily by wavenumber integration;

rmodfaut, for computing the modal wavenumbers and group velocities using a winding-number integral method;

rmodpfw, for computing the mode shapes as functions of depth including appropriate normalization or excitation factors; and

rmodfgr, for computing a dispersion curve by tracking the modal wavenumber of a particular mode as a function of frequency.

[ftp://oalib.njit.edu/pub/rpress/rpress/]
RPSstuff: A collection of Matlab programs (m-files) for performing various time series manipulations and analyses. The programs include:

eof, for calculating empirical orthogonal functions;

comcor, for finding the complex correlation between two vector time series;

fourfilt, a Fourier low, high, or bandpass filter;

plfilt, which low-pass filters hourly data; and

princax, which finds the principal axis, rotation angle, and principal ellipse.

RPSstuff can be used with Matlab or with the freely available Octave package which can run most Matlab m-files.
[http://crusty.er.usgs.gov/sea-mat/RPSstuff-html/index.html]
RRDTOOL: The Round Robin Database TOOL is a system for storing and displaying time series data on the Web. It was created to address the performance and flexibility shortcomings of MRTG. It stores data in a compact way that doesn't expand over time, and presents useful graphs by processing the data to enforce a specified data density. It can be used either via wrapper scripts or frontends that poll network devices and supply a friendly user interface (e.g. ORCA and Cricket).
[http://ee-staff.ethz.ch/~oetiker/webtools/rrdtool/]
RSAEuro: A cryptographic toolkit providing various functions for the use of digital signatures, data encryption and supporting areas. This is call-compatible with the standard RSA reference toolkit, and allows users not in the US to use cryptographic software previously only legally available in the US. Note: It is illegal to use this toolkit in the US. The functionality and features of RSAEuro includes:

RSA encryption, decryption and key generation compatible with the Public-Key Cryptography Standard (PKCS) 1;

generation and verification of message digests using MD2, MD4, MD5, and SHS;

DES encryption and decryption using CBC and DESX;

message authentication using HMAC as well as MD5, SHA-1, RIPEMD-160 and RIPEMD-129 message digests;

Diffie-Hellman key agreement as defined in PKCS 3;

PEM support for RFC 1421 encoded ASCII data with all main functions; and

key routines implemented in assembly language for speed.

Free and commercial versions are available, with the latter including quite a bit of extra functionality not described here.
[http://www.reapertech.com/RSAEuro/rsaann.shtml]
RSBAC: The Rule Set Based Access Control package for Linux is an open source security extension for current (3/00) kernels. It is based on the Generalized Framework for Access Control (GFAC) and provides a flexible system of access control based on several modules. RSBAC extends all security-relevant system calls with security enforcement code, which calls a central decision component which in turn calls all active decision modules and generates a combined decision. This decision is enforced by the system call extensions. Many different security policies can be implemented as decision modules, with the package including the following:

MAC, Bell-LaPadula Mandatory Access Ctonrol;

FC, functional control, i.e. a simple role-based model restricting access to security and adminstration to, respectively, security officers and administrators;

SIM, security information modification wherein only security administrators are allowed to modify security information;

PM, the Simone Fischer-Hubner privacy module;

MS, a malware scan that scans all files for malware on execution (or optionally on all file read accesses or on all TCP/UDP read accesses) and denies access if an infection is detected;

FF, file flags that provide and use flags for directories and files;

RC, role compatibility which defines 64 roles and 64 types for each traget type;

AUTH, authorization enforcement which controls all chown requests for process targets; and

ACL, access control lists wherein for every object there is an ACL defining which subjects may access and with which request tyupes.

A source code distribution is available under the GPL. The distributions consist of a kernel patch plus a set of administration tools.
[http://www.rsbac.de/rsbac/]
RScheme: A well-structured implementation of the Scheme language with various extensions, including an object system and threads. RScheme compiles either to bytecodes (which are interpreted by a runtime virtual machine) or to C which is then compiled by the native machine compiler. It is designed to be not only a good system for doing language research but for doing regular work as well.
The features of RScheme include:

modules with name-space control;

an object system which is ``objects all the way down'';

safe macros and a portable user-level threads system;

a system call interface to access raw OS files,

sockets and and other useful system calls;

the capability of separately compiling and linking modules;

real-time garbage collection;

persistent object storage;

compilation to C; and

and a simple mechanism for interfacing to C code for parts of applications that require high performance.

RScheme is designed to be ``extraordinarily portable'' and as such the available source code should compile on almost any generic UNIX platform. The documentation is contained within a user's manual in PostScript format.
[http://www.rosette.com/~donovan/rs/rscheme.html]
RSd: The Route Server Daemon is routing software that can simplify the administration of routing information between Internet Service Providers (ISPs) at Internet Exchanges (IXs). RSd centralizes and simplifies the configuration of ISP peerings at IXs, with each ISP only needing to establish a peering session with the route server. All ISP routing policies are configured in the route server, which computes the routing tables on behalf of its client ISP routers. Modifying the peering configuration at IXs requires only reconfiguring the route server. A source code distribution of RSd is available. It can be compiled and used on most generic UNIX platforms.
[http://www.isi.edu/ra/]
RSL: The Runtime System Library is a parallel run-time system library for implementing regular grid models with nesting on distributed memory parallel computers. RSL facilitates the parallel implementation of such models by providing support for domain decomposition, stencil communications, interdomain communication, local iteration, index translation, distributed I/O and dynamic load balancing.
The specific features of RSL include:

handling rectangular or irregularly shaped domains;

multiple, two-way interacting nested domains are independently composed over the available processors;

pointwise processor decomposition for allowing non-rectangular subdomains to be more precisely balanced among processors;

automatic run-time decomposition and re-decomposition of domains using built-in or user-supplied mapping functions;

run-time migration of state data between processors for dynamic load balancing;

automatic run-time calculation of array size requirements on each processor;

stencil exchanges for updating ghost regions;

automatic first-use compilation of stencial communication schedules;

message aggregation semantics that allow many fields to be communicated via a single stencil exchange;

broadcast-merges to exchange forcing and feedback between nested domains;

run-time support for local iteration over decomposed dimensions on each processor;

run-time support for global-local index translation on each processor;

macro support for expressing parallel loops and indices;

single-reader/single-writer distributed I/O in which the monitor processor reads and writes the file system and communicates with the other processors to distribute or collect the data; and

reading and writing ordinary Fortran record-blocked serial data sets to allow the parallel code to use native data sets.

A source code distribution of RSL is available, with the interface supporting both Fortran 77 and 90. The library is written in C and Fortran, with makefiles available for several platforms including Linux (using the pgf77 Fortran compiler). Documentation includes a reference manual and some technical reports in PostScript format.
It provides support for automatically decomposing multiple model domains and for redistributing work between processors at run time for dynamic load balancing. Grid points are independently allocated to processors which allows better balanced allocation of work to processors than with rectangular grid domains. RSL provides an efficient high-level stencil exchange operation for updating subdomain ghost areas and interdomain communcation to support two-way interaction between nesting levels. It also provides run-time support for local iteration over subdomains, global-local index translation, and distributed I/O from ordinary Fortran record-blocked data sets. A source code distribution is available.
[http://www-unix.mcs.anl.gov/~michalak/rsl/]
RSPF: The Radio Shortest Path First is a specialized routing protocol used by amateur radio operators to move packets around complicated networks. It was designed principally for personal computer implementation within the Amateur Radio Service. It was developed because TCP/IP does not currently work well in packet radio environments. RSPF occupies the traditional role of an Interior Gateway (i.e. router) Protocol (IGP) in TCP/IP networks, an is intended to be implemented on nodes serving as routers. The four major functions of RSPF are:

acquisition of router-router adjacencies;

acquisition of end node adjacencies;

link state propagation; and

spanning tree route decision making.

The net result is the automatic maintenance of a least-cost routing table for use by IP routing.
[http://www.eye-net.com.au/hamradio/rspf/]

RSPFd

An implementation of RSPF v2.2 as a daemon on Linux.
[http://www.eye-net.com.au/hamradio/rspf/]
RSVP: The ReSerVation Protocol is part of a larger effort to enhance the current Internet architecture with support for quality of service flows. It is used by a host to request specific qualities of service for particular application data streams or flows, and is used by routines to deliver quality of service (QoS) requests to all nodes along the flow path(s) to establish and maintain state. RSVP is detailed in several RFCs including 2205, 2206, 2207, 2208, 2209 and 2210. There are several publicly available versions of RSVP daemon code available, including one for Linux systems, the details for obtaining can be found at the site.
[http://www.isi.edu/div7/rsvp/rsvp.html]
[http://www.cs.columbia.edu/~yhwang/cworks.htm]
[http://www.faqs.org/rfcs/rfc2205.html]
RSVP: The Rapid Sequence Visualization in PostScript package is a suite of visually-oriented sequence analysis routines implemented entirely in the page description language PostScript. It is intended to provide a quick look at DNA up to about the length of a sequencing run by using form and color to point out patterns prior to more sophisticated sequence analyses. A source code distribution is available.
[http://www.cbil.upenn.edu/~dsearls/RSVP/RSVP_home.html]
rt: A C++ library for N-dimensional ray tracing. The functionality includes N-dimensional spheres and planes, CSG objects, cylinders, quadratic surfaces, reflection, refraction, Phong-shading, fish-eye effects, functional textures, and portals into other universes. The library is documented in a 266 page manual in PDF format.
[http://www.nklein.com/products/rt/]
RTAI: The Real Time Application Interface is a Linux kernel modification to make it fully pre-emptable. RTAI changes the interrupt handling and scheduling policies in the kernel to allow real time support within a full non-real time Linux environment. All of the usual services of the Linux kernel are available in an RTAI-enabled system, with RTAI considering Linux as a background tasks running when no real time activity is occurring.
The use of RTAI requires loading the modules that implement the RTAI capabilities needed. These modules are:

rtai, the core or base module that initializes all of its control variables and structures and initializes the interrupts chip management functions;

rtai_sched, a scheduler module in charge of distributing the CPU to different tasks;

rtai_fifos, implements the FIFO services;

rtai_shm, allows simultaneou sharing of memory among different real time tasks and Linux processes;

lxrt, implements services to make available any of the RTAI scheduler functions to Linux processes;

rtai_pthread, provides hard real time threads where each is a RTAI task; and

rtai_pqueue, provides kernel-safe message queues.

[http://www.aero.polimi.it/projects/rtai/]
RTELIB: The Radiative Transfer Equation LIBrary is a collection of mostly Fortran codes for solving the radiative transfer equation. The available codes include:

DISORT, a discrete ordinates package for a multi-layered plane-parallel medium;

DOM, a 3-D discrete ordinates method solver;

mc-layer, a Monte Carlo code for multiple scattering in vertically inhomogeneous atmospheres;

MCML, a Monte Carlo code for multi-layer turbid media;

MWMOD, an RTE code for microwave frequencies;

PolRadTran, a plane-parallel, fully-polarized atmospheric radiative transfer model;

SHDOM, which uses the discrete ordinate method; and

Streamer, a two-stream transfer model.

[http://atol.ucsd.edu/~pflatau/rtelib/index.html]
RTEMS: The Real-Time Executive for Multiprocessor Systems is a real-time operating system (OS) for embedded computers whose features include:

multitasking;

support for homogeneous and heterogeneous systems;

event-driven, priority-based, preemptive scheduling;

optional rate monotonic scheduling;

intertask communication and synchronization;

priority inheritance;

responsive interrupt management;

dynamic memory allocation; and

high level of user configurability.

There are implementations of RTEMS written in Ada and C. They will run on several architectures including the x86 chip family. Extensive documentation is available at the site.
[http://www.rtems.com/]
RTF: Rich Text Format is an embedded document formatting system invented by the folks at Microshaft. RTF files consist of a stream of text, control words and groups, where the latter are nested data enclosed in curly braces. This is generally much more messy and less elegant than better systems such as TeX, although several packages for translating from RTF to something more worthwhile are available.
The RTF-related packages in this compilation include:

astkit, contains a utility called html2rtf for doing the obvious

AUIS, can dump output to RTF format

Maxwell, a word processor than can pinch off RTF output

PolyglotMan, converts man into several formats including RTF

RATFINK

rtflatex

RTFtoHTML

RTF Tools

sdc, translates SGML into several useful formats as well as RTF

SDF, a document preparation system that can regurgitate RTF

SGML-Tools, a documentation system that can ejaculate RTF

Ted, a word processor that can emit RTF

TEItools, another package for converting SGML into various things including RTF

Tex2RTF

troffcvt, translates good old troff into such things as RTF

UDO, a document preparation system that can belch forth RTF

UMT, a mail reader with an RTF editor and viewer
rtflatex: An RTF to LaTeX converter which can convert most accented letters, most Word formulas into approximate LaTeX code, make font changes (type and size), replicate line spacing, and replicate footnotes. It does not convert figures, equation editor output, and other features whose semantic is not clear in Microshaft's godawful RTF specifications.
[http://tug2.cs.umb.edu/ctan/tex-archive/support/rtflatex/index.html]
RTFtoHTML: A program that converts word processor documents in RTF format into HTML format. The features include:

adding standard banners and navigation buttons;

selecting different overall looks without changing document content;

splitting large documents into a series of smaller linked pages;

complete customizability via modification of the HTML markup and translation tables;

support for frames, tables, standard HTML (4.0 and earlier), and several popular extensions;

support for Unicode and language-dependent titles;

recognition of MS Werd 97 and 98 hyperlinks, references and bookmarks; and

preservation of paragraph and character styles through the translation, i.e. allowing HTML to be generated with CSS and XML markup.

[http://www.sunpack.com/RTF/]
rtf2latex2e: A utility for converting RTF files to LaTeX format. The uses the parser in the RTF Tools package and generates an appropriate LaTeX file. The features include:

detection of text style, e.g. bold, italic, color, big, small;

detection of embedded figures;

reading tables;

translating Equation Editor equations as pictures;

conversion of most Greek and math symbols; and

handling footnotes.

[http://members.home.net/setlur/rtf2latex2e/]
RTF Tools: An RTF translation package that includes several tools for translating RTF into other formats. The utilities in the package include:

rtf2text, from RTF to plain text;

rtf2troff, from RTF to troff;

rtfwc, translates RTF into character, word and paragraph count;

rtfdiag, a diagnostic program used to test the RTF reader;

rtfskel, a translator skeleton used for building new translators; and

trfindent, for reading an RTF file and translating it into more readable form.

The package is documented via man pages.
[http://www.primate.wisc.edu/software/RTF/]
RTiC-Lab: A hard real time controller implementation and simulation environment for Linux. RTiC-Lab runs on top of Linux and Real-Time Linux to give a controls engineer real time access to plant states and I/O, controller states and parameters, and a hard real time environment for plant modeling. Drivers are available for:

Computer Boards DAS 1401/12 A/D cards;

Computer Boards CIO-DDA06 D/A cards;

Computer Boards PCI-DDA08/12 D/A cards; and

all COMEDI devices via a general interface.

[http://rtic-lab.sourceforge.net/]
RTP: The Real Time Protocol is for the transport of real-time data including audio and video. It can be used for media-on-demand as well as interactive services such as telephony. It consists of a data and a control part with the latter called RTCP. Related packages include:

JRTPLIB, an RTP library written in C++

LRMPlib

MultiMON

mWeb

Rendez-Vous

rtp

WebCanal

[http://www.cs.columbia.edu/~hgs/rtp/]

rtp

An implementation of the RTP/RTCP protocol stacks for Linux platforms.
[http://www.vovida.com/sub_rtp.html]

rtptools

A suite of applications for processing RTP data including:

rtpplay, for playing back RTP sessions recorded by rtpdump;

rtpsend, for generating RTP packets from a textual description generated by hand or by rtpdump;

rtpdump, for parsing and printing RTP packets and generating input files suitable for rtpplay and rtpsend; and

rtptrans, an RTP translator between unicast and multicast networks.

A source code distribution is available which should compile on any POSIX-compliant platform.
[ftp://ftp.cs.columbia.edu/pub/schulzrinne/rtptools/]
RT++: A package which provides higher-order threads in C++. The goal of RT++ is to provide a programming interface which is considerably higher-level than that of comparable packages. It considers threads as an abstract datatype with a functional interface, i.e. threads communicate only via arguments which are provided when a thread is defined, and by results which are delivered when the thread has terminated. Thus threads can be used like objects of any other type, i.e. they can be stored in data structures, passed as thread arguments, and returned as thread results.
RT++ provides a thread/memoery management system which frees the programmer from low-level issues such as the allocation and freeing of thread resources. Thread resources are implicitly allocated as late as possible and implicitly freed as early as possible regardless of whether or how often the thread result is retrieved, and only destroyed when subject to the same garbage collection procedures as the rest of the program. Also provided are type constructors for arrays, lists, and general pointer structures as well as a high-level notion of non-determinism via thread bags which retrieve their result in the order in which they become available which allows the writing of more abstract parallel programs.
The RT++ package is available as source code. It is written in C++ and has been successfully compiled using g++ (2.6.3 and 2.7.2). It has been ported and tested on Linux Intel, Sequent Symmetry, SGI IRIX, Sun SunOS and Solaris, Meiko CS-2, HP-UX, and Convex SPP platforms. It is documented in a tutorial and reference manual available in PostScript format.
[http://www.risc.uni-linz.ac.at/software/rt++/]
RTrace: A package for performing ray tracking. RTrace supports several types of objects, CSG and list operations, different light yptes, reasonable surface definitions. A source code distribution is available.
[ftp://wuarchive.wustl.edu/graphics/graphics/ray/RTrace/]
[ftp://asterix.inescn.pt/pub/RTrace/]
Ruboard: A simple, configurable Web bulletin board whose features include:

file locking to prevent article and index destruction;

compatibility with WWWBoard forums;

user registration and password options;

control of ability to post messages, images and URLs via passwords;

blocking IP addresses;

multiple language support;

multiple bulletin boards from one program;

configuration options for most visual aspects;

separation of posting and page modes so posters don't have to scroll to the bottom of a long page; and

capability of adding ads to every generated page.

This is written in Perl and should work with version 4 or 5.
[http://www.amsoft.ru/ruboard/]
Ruby: An object-oriented, extensible scripting language with many features for processing text files and performing system management tasks. The author created this to have an OO scripting language that isn't as ``ugly'' as Perl and that sort of resembles Lisp without all the parentheses. The features of Ruby include:

interpreted rather than compiled;

dynamic typing wherein variables can contain data of any type;

use of variables without declarations with the variable name denoting its scope;

simple syntax with some Eiffel influence;

automatic memory management, i.e. garbage collection;

a pure object-oriented language in which even basic data like integers are treated uniformly as objects;

standard OO features like classes, inheritance and methods;

singleton methods wherein methods can be defined for specific objects, e.g. defining a press-button action for a GUI button by defining a singleton method for the button;

modules for sharing implementations across inheritance trees;

iterators for loop abstraction;

closures wherein you can objectify the procedure;

many text processing and regular expression features;

built-in bignums;

exception handling;

direct access to most UNIX system calls; and

dynamic loading of object files into the interpreter.

A source code distribution of Ruby is available which can be compiled on most UNIX flavors. The documentation includes a FAQ, a reference manual, and a user's guide, most but not all of which has been (11/98) translated from the Japanese.
[http://www.ruby-lang.org/en/]
rumba: An SMB client derived from the smbfs package which runs as a user level program rather than in the kernel like the latter. Rumba allows you to mount drives exported by Windows, Lan Manager, OS/2 and other compatible systems.
[http://sunsite.unc.edu/pub/Linux/system/filesystems/smbfs/]
runas: A program that allows an administrator to run a process as any user on a UNIX system, including as the superuser in a non-interactive manner without having to login as that user. It also provides a secure way to allow usually unprivileged lusers to execute selected programs as a superuser. A log feature sends every command executed using runas to syslogd along with the command arguments, date, time, host, tty, and the user and group names the command was run as. A source code distribution is available. See also the related sudo.
[http://www.mindspring.com/~carpinello/runas/index.html]
rungetty: A getty for use on virtual consoles which can run programs other than login. This is based on rungetty and, like that program, is not suitable for serial use. It can be used for keeping programs such as telnet running at all times. When not running login it is executed as the user nobody or another specified username. A source code distribution is available.
[http://www.nodomainname.net/software/rungetty/]
Runlevel.app: A program that allows sysadmins to add, delete, edit and execute services in the different runlevels of a Linux system. The features of Runlevel.app include:

a runlevel editor for SYSV init-based machines;

transient/fixed size NeXT-like dialogs and panels;

an easy-to-use and simple NeXT-like GUI;

adding, removing and editing scripts with a few clicks; and

starting and stopping init scripts with a click.

A source code distribution of Runlevel.app is available. This requires Tcl/Tk.
[http://windowmaker.mezaway.org/runlevelapp.html]
RV: A package of random number generators written in Fortran 77. RV consists of two programs: UNI, which generates uniform numbers on [0,1]; and RNOR, which generates normal numbers with zero mean and a standard deviation of one. The latter routine is also a fast random number generator. A source code distribution of RV is available. The routines are documented via comment statements contained within each source code file. This is part of CMLIB.
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
RVM: The Recursive Virtual Machine is a VM for a Scheme-like language in which primitives and instructions can be specified recursively in terms of the intrinsic instructions. Demonstration user-level implementations of lightweight processes, synchronization facilities, full upward continuations, user-defined syntax, OO extensions and more are included in the distribution. Documentation is more than a little sparse.
[http://www-sor.inria.fr/projects/vvm/]
Rx: A GNU implementation of the standard regular expression matching functions specified by POSIX.2 as well as some extra features.
[http://www.gnu.ai.mit.edu/order/ftp.html]
RxSock: A REXX interface to SOCKS with support for the Regina interpreter.
[http://home.HiWAAY.net/~abbott/rexx/]
rxvt: A color VT102 terminal emulator intended as an xterm replacement for those who do not require features such as Tektronix 4014 emulation and toolkit-style configurability. This allows rxvt to use much less swap space than xterm and other emulators.
[http://babayaga.math.fu-berlin.de/~rxvt/]

[ home / linux ]

Next: Sa-Sm Up: Linux Software Encyclopedia Previous: Ra-Rm Contents

Manbreaker Crag 2001-03-08