=Ver: 2.0
##----------------------------------------
=Pkg: perl-Authen-Krb4 1.1 2.0.sles10.lc i386
=Sum: Authen-Krb4 - Perl extension for Kerberos 4
+Des:
Authen::Krb4 is an object oriented extension to Perl 5 which implements
several user-level Kerberos 4 functions. With this module, you can create
Kerberized clients and servers written in Perl. It is compatible with
both AFS and MIT Kerberos.
-Des:
##----------------------------------------
=Pkg: perl-Authen-Krb5 1.6 1.0.sles10.lc i386
=Sum: Authen-Krb5 - Perl extension for Kerberos 5
+Des:
Authen::Krb5 is an object oriented interface to the Kerberos 5 API. Both the
implementation and documentation are nowhere near complete, and may require
previous experience with Kerberos 5 programming. Most of the functions here
are documented in detail in the Kerberos 5 API documentation.
-Des:
##----------------------------------------
=Pkg: perl-Authen-PAM 0.16 1.0.sles10.lc i386
=Sum: Authen-PAM - Perl interface to PAM library
+Des:
The *Authen::PAM* module provides a Perl interface to the *PAM*
library. The only difference with the standard PAM interface is that
instead of passing a pam_conv struct which has an additional context
parameter appdata_ptr, you must only give an address to a conversation
function written in Perl (see below).
If you want to pass a NULL pointer as a value of the $user in
pam_start use undef or the two-argument version. Both in the two and
the three-argument versions of pam_start a default conversation
function is used (Authen::PAM::pam_default_conv).
The $flags argument is optional for all functions which use it
except for pam_setcred. The $pam_status argument is also optional for
pam_end function. Both of these arguments will be set to 0 if not given.
The names of some constants from the PAM library have changed over the
time. You can use any of the known names for a given constant although
it is advisable to use the latest one.
When this module supports some of the additional features of the PAM
library (e.g. pam_fail_delay) then the corresponding HAVE_PAM_XXX
constant will have a value 1 otherwise it will return 0.
For compatibility with older PAM libraries I have added the constant
HAVE_PAM_ENV_FUNCTIONS which is true if your PAM library has the
functions for handling environment variables (pam_putenv, pam_getenv,
pam_getenvlist).
-Des:
##----------------------------------------
=Pkg: perl-Class-MOP 0.76 1.0.sles10.lc i386
=Sum: Class-MOP - A Meta Object Protocol for Perl 5
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Crypt-IDEA 1.08 1.0.sles10.lc i386
=Sum: Crypt-IDEA - Perl module
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Crypt-SSLeay 0.51 2.0.sles10.lc i386
=Sum: Crypt-SSLeay - OpenSSL glue that provides LWP https support
+Des:
This perl module provides support for the https
protocol under LWP, so that a LWP::UserAgent can
make https GET & HEAD & POST requests. Please see
perldoc LWP for more information on POST requests.
The Crypt::SSLeay package contains Net::SSL,
which is automatically loaded by LWP::Protocol::https
on https requests, and provides the necessary SSL glue
for that module to work via these deprecated modules:
Crypt::SSLeay::CTX
Crypt::SSLeay::Conn
Crypt::SSLeay::X509
Work on Crypt::SSLeay has been continued only to
provide https support for the LWP - libwww perl
libraries. If you want access to the OpenSSL
API via perl, check out Sampo's Net::SSLeay.
-Des:
##----------------------------------------
=Pkg: perl-Event 1.06 1.0.sles10.lc i386
=Sum: Event - Perl module
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-GD 2.35 1.0.sles10.lc i386
=Sum: GD - Interface to Gd Graphics Library
+Des:
GD.pm is a Perl interface to Thomas Boutell's gd graphics library
(version 2.01 or higher; see below). GD allows you to create color
drawings using a large number of graphics primitives, and emit the
drawings as PNG files.
GD defines the following four classes:
=over 5
=item "GD::Image"
An image class, which holds the image data and accepts graphic
primitive method calls.
=item "GD::Font"
A font class, which holds static font information and used for text
rendering.
=item "GD::Polygon"
A simple polygon object, used for storing lists of vertices prior to
rendering a polygon into an image.
=item "GD::Simple"
A "simple" class that simplifies the GD::Image API and then adds a set
of object-oriented drawing methods using turtle graphics, simplified
font handling, ability to work in polar coordinates, HSV color spaces,
and human-readable color names like "lightblue". Please see
GD::Simple for a description of these methods.
=back
A Simple Example:
use GD;
$im = new GD::Image(100,100);
$white = $im->colorAllocate(255,255,255);
$black = $im->colorAllocate(0,0,0);
$red = $im->colorAllocate(255,0,0);
$blue = $im->colorAllocate(0,0,255);
$im->transparent($white);
$im->interlaced('true');
$im->rectangle(0,0,99,99,$black);
$im->arc(50,50,95,75,0,360,$blue);
$im->fill(50,50,$red);
binmode STDOUT;
print $im->png;
Notes:
=over 5
=item 1.
To create a new, empty image, send a new() message to GD::Image, passing
it the width and height of the image you want to create. An image
object will be returned. Other class methods allow you to initialize
an image from a preexisting JPG, PNG, GD, GD2 or XBM file.
=item 2.
Next you will ordinarily add colors to the image's color table.
colors are added using a colorAllocate() method call. The three
parameters in each call are the red, green and blue (rgb) triples for
the desired color. The method returns the index of that color in the
image's color table. You should store these indexes for later use.
=item 3.
Now you can do some drawing! The various graphics primitives are
described below. In this example, we do some text drawing, create an
oval, and create and draw a polygon.
=item 4.
Polygons are created with a new() message to GD::Polygon. You can add
points to the returned polygon one at a time using the addPt() method.
The polygon can then be passed to an image for rendering.
=item 5.
When you're done drawing, you can convert the image into PNG format by
sending it a png() message. It will return a (potentially large)
scalar value containing the binary data for the image. Ordinarily you
will print it out at this point or write it to a file. To ensure
portability to platforms that differentiate between text and binary
files, be sure to call "binmode()" on the file you are writing
the image to.
=back
-Des:
##----------------------------------------
=Pkg: perl-HTML-Parser_loncapa 3.55 1.0.sles10.lc i386
=Sum: HTML-Parser - HTML parser class
+Des:
Objects of the "HTML::Parser" class will recognize markup and
separate it from plain text (alias data content) in HTML
documents. As different kinds of markup and text are recognized, the
corresponding event handlers are invoked.
"HTML::Parser" is not a generic SGML parser. We have tried to
make it able to deal with the HTML that is actually "out there", and
it normally parses as closely as possible to the way the popular web
browsers do it instead of strictly following one of the many HTML
specifications from W3C. Where there is disagreement, there is often
an option that you can enable to get the official behaviour.
The document to be parsed may be supplied in arbitrary chunks. This
makes on-the-fly parsing as documents are received from the network
possible.
If event driven parsing does not feel right for your application, you
might want to use "HTML::PullParser". This is an "HTML::Parser"
subclass that allows a more conventional program structure.
-Des:
##----------------------------------------
=Pkg: perl-IO-Tty 1.07 1.0.sles10.lc i386
=Sum: IO-Tty - Pseudo ttys and constants
+Des:
"IO::Tty" is used internally by "IO::Pty" to create a pseudo-tty.
You wouldn't want to use it directly except to import constants, use
"IO::Pty". For a list of importable constants, see
IO::Tty::Constant.
Windows is now supported, but ONLY under the Cygwin
environment, see .
Please note that pty creation is very system-dependend. From my
experience, any modern POSIX system should be fine. Find below a list
of systems that "IO::Tty" should work on. A more detailed table
(which is slowly getting out-of-date) is available from the project
pages document manager at SourceForge
.
If you have problems on your system and your system is listed in the
"verified" list, you probably have some non-standard setup, e.g. you
compiled your Linux-kernel yourself and disabled ptys (bummer!).
Please ask your friendly sysadmin for help.
If your system is not listed, unpack the latest version of "IO::Tty",
do a 'perl Makefile.PL; make; make test; uname -a' and send me
(RGiersig@cpan.org) the results and I'll see what I can deduce from
that. There are chances that it will work right out-of-the-box...
If it's working on your system, please send me a short note with
details (version number, distribution, etc. 'uname -a' and 'perl -V'
is a good start; also, the output from "perl Makefile.PL" contains a
lot of interesting info, so please include that as well) so I can get
an overview. Thanks!
-Des:
##----------------------------------------
=Pkg: perl-List-MoreUtils 0.22 1.0.sles10.lc i386
=Sum: List-MoreUtils - Provide the stuff missing in List::Util
+Des:
"List::MoreUtils" provides some trivial but commonly needed functionality on lists
which is not going to go into "List::Util".
All of the below functions are implementable in only a couple of lines of Perl
code. Using the functions from this module however should give slightly better
performance as everything is implemented in C. The pure-Perl implementation of
these functions only serves as a fallback in case the C portions of this module
couldn't be compiled on this machine.
=over 4
=item any BLOCK LIST
Returns a true value if any item in LIST meets the criterion given through
BLOCK. Sets $_ for each item in LIST in turn:
print "At least one value undefined"
if any { !defined($_) } @list;
Returns false otherwise, or "undef" if LIST is empty.
=item all BLOCK LIST
Returns a true value if all items in LIST meet the criterion given through
BLOCK. Sets $_ for each item in LIST in turn:
print "All items defined"
if all { defined($_) } @list;
Returns false otherwise, or "undef" if LIST is empty.
=item none BLOCK LIST
Logically the negation of "any". Returns a true value if no item in LIST meets the
criterion given through BLOCK. Sets $_ for each item in LIST in turn:
print "No value defined"
if none { defined($_) } @list;
Returns false otherwise, or "undef" if LIST is empty.
=item notall BLOCK LIST
Logically the negation of "all". Returns a true value if not all items in LIST meet
the criterion given through BLOCK. Sets $_ for each item in LIST in turn:
print "Not all values defined"
if notall { defined($_) } @list;
Returns false otherwise, or "undef" if LIST is empty.
=item true BLOCK LIST
Counts the number of elements in LIST for which the criterion in BLOCK is true. Sets $_ for
each item in LIST in turn:
printf "%i item(s) are defined", true { defined($_) } @list;
=item false BLOCK LIST
Counts the number of elements in LIST for which the criterion in BLOCK is false. Sets $_ for
each item in LIST in turn:
printf "%i item(s) are not defined", false { defined($_) } @list;
=item firstidx BLOCK LIST
=item first_index BLOCK LIST
Returns the index of the first element in LIST for which the criterion in BLOCK is true. Sets $_
for each item in LIST in turn:
my @list = (1, 4, 3, 2, 4, 6);
printf "item with index %i in list is 4", firstidx { $_ == 4 } @list;
__END__
item with index 1 in list is 4
Returns -1 if no such item could be found.
"first_index" is an alias for "firstidx".
=item lastidx BLOCK LIST
=item last_index BLOCK LIST
Returns the index of the last element in LIST for which the criterion in BLOCK is true. Sets $_
for each item in LIST in turn:
my @list = (1, 4, 3, 2, 4, 6);
printf "item with index %i in list is 4", lastidx { $_ == 4 } @list;
__END__
item with index 4 in list is 4
Returns -1 if no such item could be found.
"last_index" is an alias for "lastidx".
=item insert_after BLOCK VALUE LIST
Inserts VALUE after the first item in LIST for which the criterion in BLOCK is true. Sets $_ for
each item in LIST in turn.
my @list = qw/This is a list/;
insert_after { $_ eq "a" } "longer" => @list;
print "@list";
__END__
This is a longer list
=item insert_after_string STRING VALUE LIST
Inserts VALUE after the first item in LIST which is equal to STRING.
my @list = qw/This is a list/;
insert_after_string "a", "longer" => @list;
print "@list";
__END__
This is a longer list
=item apply BLOCK LIST
Applies BLOCK to each item in LIST and returns a list of the values after BLOCK
has been applied. In scalar context, the last element is returned. This
function is similar to "map" but will not modify the elements of the input
list:
my @list = (1 .. 4);
my @mult = apply { $_ *= 2 } @list;
print "\@list = @list\n";
print "\@mult = @mult\n";
__END__
@list = 1 2 3 4
@mult = 2 4 6 8
Think of it as syntactic sugar for
for (my @mult = @list) { $_ *= 2 }
=item after BLOCK LIST
Returns a list of the values of LIST after (and not including) the point
where BLOCK returns a true value. Sets $_ for each element in LIST in turn.
@x = after { $_ % 5 == 0 } (1..9); # returns 6, 7, 8, 9
=item after_incl BLOCK LIST
Same as "after" but also inclues the element for which BLOCK is true.
=item before BLOCK LIST
Returns a list of values of LIST upto (and not including) the point where BLOCK
returns a true value. Sets $_ for each element in LIST in turn.
=item before_incl BLOCK LIST
Same as "before" but also includes the element for which BLOCK is true.
=item indexes BLOCK LIST
Evaluates BLOCK for each element in LIST (assigned to $_) and returns a list
of the indices of those elements for which BLOCK returned a true value. This is
just like "grep" only that it returns indices instead of values:
@x = indexes { $_ % 2 == 0 } (1..10); # returns 1, 3, 5, 7, 9
=item firstval BLOCK LIST
=item first_value BLOCK LIST
Returns the first element in LIST for which BLOCK evaluates to true. Each
element of LIST is set to $_ in turn. Returns "undef" if no such element
has been found.
"first_val" is an alias for "firstval".
=item lastval BLOCK LIST
=item last_value BLOCK LIST
Returns the last value in LIST for which BLOCK evaluates to true. Each element
of LIST is set to $_ in turn. Returns "undef" if no such element has been
found.
"last_val" is an alias for "lastval".
=item pairwise BLOCK ARRAY1 ARRAY2
Evaluates BLOCK for each pair of elements in ARRAY1 and ARRAY2 and returns a
new list consisting of BLOCK's return values. The two elements are set to $a
and $b. Note that those two are aliases to the original value so changing
them will modify the input arrays.
@a = (1 .. 5);
@b = (11 .. 15);
@x = pairwise { $a + $b } @a, @b; # returns 12, 14, 16, 18, 20
@a = qw/a b c/;
@b = qw/1 2 3/;
@x = pairwise { ($a, $b) } @a, @b; # returns a, 1, b, 2, c, 3
=item each_array ARRAY1 ARRAY2 ...
Creates an array iterator to return the elements of the list of arrays ARRAY1,
ARRAY2 throughout ARRAYn in turn. That is, the first time it is called, it
returns the first element of each array. The next time, it returns the second
elements. And so on, until all elements are exhausted.
This is useful for looping over more than one array at once:
my $ea = each_array(@a, @b, @c);
while ( my ($a, $b, $c) = $ea->() ) { .... }
The iterator returns the empty list when it reached the end of all arrays.
If the iterator is passed an argument of '"index"', then it retuns
the index of the last fetched set of values, as a scalar.
=item each_arrayref LIST
Like each_array, but the arguments are references to arrays, not the
plain arrays.
=item natatime BLOCK LIST
Creates an array iterator, for looping over an array in chunks of
$n items at a time. (n at a time, get it?). An example is
probably a better explanation than I could give in words.
Example:
my @x = ('a' .. 'g');
my $it = natatime 3, @x;
while (my @vals = $it->())
{
print "@vals\n";
}
This prints
a b c
d e f
g
=item mesh ARRAY1 ARRAY2 [ ARRAY3 ... ]
=item zip ARRAY1 ARRAY2 [ ARRAY3 ... ]
Returns a list consisting of the first elements of each array, then
the second, then the third, etc, until all arrays are exhausted.
Examples:
@x = qw/a b c d/;
@y = qw/1 2 3 4/;
@z = mesh @x, @y; # returns a, 1, b, 2, c, 3, d, 4
@a = ('x');
@b = ('1', '2');
@c = qw/zip zap zot/;
@d = mesh @a, @b, @c; # x, 1, zip, undef, 2, zap, undef, undef, zot
"zip" is an alias for "mesh".
=item uniq LIST
Returns a new list by stripping duplicate values in LIST. The order of
elements in the returned list is the same as in LIST. In scalar context,
returns the number of unique elements in LIST.
my @x = uniq 1, 1, 2, 2, 3, 5, 3, 4; # returns 1 2 3 5 4
my $x = uniq 1, 1, 2, 2, 3, 5, 3, 4; # returns 5
=item minmax LIST
Calculates the minimum and maximum of LIST and returns a two element list with
the first element being the minimum and the second the maximum. Returns the empty
list if LIST was empty.
The minmax algorithm differs from a naive iteration over the list where each element
is compared to two values being the so far calculated min and max value in that it
only requires 3n/2 - 2 comparisons. Thus it is the most efficient possible algorithm.
However, the Perl implementation of it has some overhead simply due to the fact
that there are more lines of Perl code involved. Therefore, LIST needs to be
fairly big in order for minmax to win over a naive implementation. This
limitation does not apply to the XS version.
=item part BLOCK LIST
Partitions LIST based on the return value of BLOCK which denotes into which partition
the current value is put.
Returns a list of the partitions thusly created. Each partition created is a
reference to an array.
my $i = 0;
my @part = part { $i++ % 2 } 1 .. 8; # returns [1, 3, 5, 7], [2, 4, 6, 8]
You can have a sparse list of partitions as well where non-set partitions will
be undef:
my @part = part { 2 } 1 .. 10; # returns undef, undef, [ 1 .. 10 ]
Be careful with negative values, though:
my @part = part { -1 } 1 .. 10;
__END__
Modification of non-creatable array value attempted, subscript -1 ...
Negative values are only ok when they refer to a partition previously created:
my @idx = (0, 1, -1);
my $i = 0;
my @part = part { $idx[$++ % 3] } 1 .. 8; # [1, 4, 7], [2, 3, 5, 6, 8]
=back
-Des:
##----------------------------------------
=Pkg: perl-Math-Cephes 0.43 1.0.sles10.lc i386
=Sum: Math-Cephes - Perl interface to the math cephes library
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Math-FFT 1.28 1.0.sles10.lc i386
=Sum: Math-FFT - Perl extension for Fast Fourier Transforms
+Des:
This module implements some algorithms for calculating
Fast Fourier Transforms for one-dimensional data sets of size 2^n.
The data, assumed to arise from a constant sampling rate, is
represented by an array reference $data (as described in the
methods below), which is then used to create a "Math::FFT" object as
my $fft = new Math::FFT($data);
The methods available include the following.
-Des:
##----------------------------------------
=Pkg: perl-Math-Random 0.69 1.0.sles10.lc i386
=Sum: Math-Random - Random Number Generators
+Des:
Math::Random is a Perl port of the C version of randlib,
which is a suite of routines for generating random deviates. See
"RANDLIB" for more information.
This port supports all of the distributions from which the Fortran
and C versions generate deviates. The major functionalities that
are excluded are the multiple generators/splitting facility and
antithetic random number generation. These facilities, along with
some of the distributions which *are* included, are probably not of
interest except to the very sophisticated user. If there is
sufficient interest, the excluded facilities will be included in a
future release. The code to perform the excluded facilities is
available as randlib in Fortran and C source.
-Des:
##----------------------------------------
=Pkg: perl-Params-Util 0.35 1.0.sles10.lc i386
=Sum: Params-Util - Simple, compact and correct param-checking functions
+Des:
"Params::Util" provides a basic set of importable functions that makes
checking parameters a hell of a lot easier
While they can be (and are) used in other contexts, the main point
behind this module is that the functions both Do What You Mean,
and Do The Right Thing, so they are most useful when you are getting
params passed into your code from someone and/or somewhere else
and you can't really trust the quality.
Thus, "Params::Util" is of most use at the edges of your API, where
params and data are coming in from outside your code.
The functions provided by "Params::Util" check in the most strictly
correct manner known, are documented as thoroughly as possible so their
exact behaviour is clear, and heavily tested so make sure they are not
fooled by weird data and Really Bad Things.
To use, simply load the module providing the functions you want to use
as arguments (as shown in the SYNOPSIS).
To aid in maintainability, "Params::Util" will never export by
default.
You must explicitly name the functions you want to export, or use the
":ALL" param to just have it export everything (although this is not
recommended if you have any _FOO functions yourself with which future
additions to "Params::Util" may clash)
-Des:
##----------------------------------------
=Pkg: perl-Safe-Hole 0.10 1.0.sles10.lc i386
=Sum: Safe-Hole - make a hole to the original main compartment in the Safe compartment
+Des:
We can call outside defined subroutines from the Safe compartment
using share(), or can call methods through the object that is copied
into the Safe compartment using varglob(). But that subroutines or
methods are executed in the Safe compartment too, so they cannot call
another subroutines that are dinamically qualified with the package
name such as class methods nor can they compile code that uses opcodes
that are forbidden within the compartment.
Through Safe::Hole, we can execute outside defined subroutines in the
original main compartment from the Safe compartment.
Note that if a subroutine called through Safe::Hole::call does a
Carp::croak() it will report the error as having occured within
Safe::Hole. This can be avoided by including Safe::Hole::User in the
@ISA for the package containing the subroutine.
-Des:
##----------------------------------------
=Pkg: perl-String-CRC32 1.4 1.0.sles10.lc i386
=Sum: String-CRC32 - Perl module
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-String-Similarity 1.02 1.0.sles10.lc i386
=Sum: String-Similarity - calculate the similarity of two strings
+Des:
=over 4
-Des:
##----------------------------------------
=Pkg: perl-Template-Toolkit 2.20 1.0.sles10.lc i386
=Sum: Template-Toolkit - comprehensive template processing system
+Des:
This documentation describes the Template module which is the direct
Perl interface into the Template Toolkit. It covers the use of the
module and gives a brief summary of configuration options and template
directives. Please see Template::Manual for the complete reference
manual which goes into much greater depth about the features and use
of the Template Toolkit. The Template::Tutorial is also available
as an introductory guide to using the Template Toolkit.
-Des:
##----------------------------------------
=Pkg: perl-Text-Aspell 0.06 1.0.sles10.lc i386
=Sum: Text-Aspell - Perl interface to the GNU Aspell library
+Des:
This module provides a Perl interface to the GNU Aspell library. This module
is to meet the need of looking up many words, one at a time, in a single
session, such as spell-checking a document in memory.
The GNU C interface is described at:
http://aspell.net/man-html/Through-the-C-API.html#Through-the-C-API
It's worth looking over the way config and speller (manager) objects are
created when using the Aspell C API as some of that is hidden in the
Text::Aspell module.
For example, with Text::Aspell you do not have to explicitly create a speller
object. The speller (manager) object is created automatically the first time
you call suggest() or check().
Note also that once the speller object is created some (all?) config options
cannot be changed. For example, setting configuration options such as "lang"
are what determine what dictionary Aspell will use. Once the speller object is
created that dictionary will be used. I.e. setting "lang" after the speller
object is created will have no effect.
-Des:
##----------------------------------------
=Pkg: perl-Text-CSV_XS 0.59 1.0.sles10.lc i386
=Sum: Text-CSV_XS - Comma-Separated Values manipulation routines
+Des:
Text::CSV_XS provides facilities for the composition and decomposition of
comma-separated values. An instance of the Text::CSV_XS class can combine
fields into a CSV string and parse a CSV string into fields.
The module accepts either strings or files as input and can utilize any
user-specified characters as delimiters, separators, and escapes so it is
perhaps better called ASV (anything separated values) rather than just CSV.
-Des:
##----------------------------------------
=Pkg: perl-Time-HiRes 1.90 1.0.sles10.lc i386
=Sum: Time-HiRes - High resolution alarm, sleep, gettimeofday, interval timers
+Des:
The "Time::HiRes" module implements a Perl interface to the
"usleep", "nanosleep", "ualarm", "gettimeofday", and
"setitimer"/"getitimer" system calls, in other words, high
resolution time and timers. See the "EXAMPLES" section below and the
test scripts for usage; see your system documentation for the
description of the underlying "nanosleep" or "usleep", "ualarm",
"gettimeofday", and "setitimer"/"getitimer" calls.
If your system lacks "gettimeofday()" or an emulation of it you don't
get "gettimeofday()" or the one-argument form of "tv_interval()".
If your system lacks all of "nanosleep()", "usleep()",
"select()", and "poll", you don't get "Time::HiRes::usleep()",
"Time::HiRes::nanosleep()", or "Time::HiRes::sleep()".
If your system lacks both "ualarm()" and "setitimer()" you don't get
"Time::HiRes::ualarm()" or "Time::HiRes::alarm()".
If you try to import an unimplemented function in the "use" statement
it will fail at compile time.
If your subsecond sleeping is implemented with "nanosleep()" instead
of "usleep()", you can mix subsecond sleeping with signals since
"nanosleep()" does not use signals. This, however, is not portable,
and you should first check for the truth value of
&Time::HiRes::d_nanosleep to see whether you have nanosleep, and
then carefully read your "nanosleep()" C API documentation for any
peculiarities.
If you are using "nanosleep" for something else than mixing sleeping
with signals, give some thought to whether Perl is the tool you should
be using for work requiring nanosecond accuracies.
The following functions can be imported from this module.
No functions are exported by default.
=over 4
=item gettimeofday ()
In array context returns a two-element array with the seconds and
microseconds since the epoch. In scalar context returns floating
seconds like "Time::HiRes::time()" (see below).
=item usleep ( $useconds )
Sleeps for the number of microseconds (millionths of a second)
specified. Returns the number of microseconds actually slept. Can
sleep for more than one second, unlike the "usleep" system call. Can
also sleep for zero seconds, which often works like a *thread yield*.
See also "Time::HiRes::usleep()", "Time::HiRes::sleep()", and
"Time::HiRes::clock_nanosleep()".
Do not expect usleep() to be exact down to one microsecond.
=item nanosleep ( $nanoseconds )
Sleeps for the number of nanoseconds (1e9ths of a second) specified.
Returns the number of nanoseconds actually slept (accurate only to
microseconds, the nearest thousand of them). Can sleep for more than
one second. Can also sleep for zero seconds, which often works like a
*thread yield*. See also "Time::HiRes::sleep()",
"Time::HiRes::usleep()", and "Time::HiRes::clock_nanosleep()".
Do not expect nanosleep() to be exact down to one nanosecond.
Getting even accuracy of one thousand nanoseconds is good.
=item ualarm ( $useconds [, $interval_useconds ] )
Issues a "ualarm" call; the $interval_useconds is optional and
will be zero if unspecified, resulting in "alarm"-like behaviour.
Note that the interaction between alarms and sleeps is unspecified.
=item tv_interval
tv_interval ( $ref_to_gettimeofday [, $ref_to_later_gettimeofday] )
Returns the floating seconds between the two times, which should have
been returned by "gettimeofday()". If the second argument is omitted,
then the current time is used.
=item time ()
Returns a floating seconds since the epoch. This function can be
imported, resulting in a nice drop-in replacement for the "time"
provided with core Perl; see the "EXAMPLES" below.
NOTE 1: This higher resolution timer can return values either less
or more than the core "time()", depending on whether your platform
rounds the higher resolution timer values up, down, or to the nearest second
to get the core "time()", but naturally the difference should be never
more than half a second. See also "clock_getres", if available
in your system.
NOTE 2: Since Sunday, September 9th, 2001 at 01:46:40 AM GMT, when
the "time()" seconds since epoch rolled over to 1_000_000_000, the
default floating point format of Perl and the seconds since epoch have
conspired to produce an apparent bug: if you print the value of
"Time::HiRes::time()" you seem to be getting only five decimals, not
six as promised (microseconds). Not to worry, the microseconds are
there (assuming your platform supports such granularity in the first
place). What is going on is that the default floating point format of
Perl only outputs 15 digits. In this case that means ten digits
before the decimal separator and five after. To see the microseconds
you can use either "printf"/"sprintf" with "%.6f", or the
"gettimeofday()" function in list context, which will give you the
seconds and microseconds as two separate values.
=item sleep ( $floating_seconds )
Sleeps for the specified amount of seconds. Returns the number of
seconds actually slept (a floating point value). This function can
be imported, resulting in a nice drop-in replacement for the "sleep"
provided with perl, see the "EXAMPLES" below.
Note that the interaction between alarms and sleeps is unspecified.
=item alarm ( $floating_seconds [, $interval_floating_seconds ] )
The "SIGALRM" signal is sent after the specified number of seconds.
Implemented using "ualarm()". The $interval_floating_seconds argument
is optional and will be zero if unspecified, resulting in "alarm()"-like
behaviour. This function can be imported, resulting in a nice drop-in
replacement for the "alarm" provided with perl, see the "EXAMPLES" below.
NOTE 1: With some combinations of operating systems and Perl
releases "SIGALRM" restarts "select()", instead of interrupting it.
This means that an "alarm()" followed by a "select()" may together
take the sum of the times specified for the the "alarm()" and the
"select()", not just the time of the "alarm()".
Note that the interaction between alarms and sleeps is unspecified.
=item setitimer ( $which, $floating_seconds [, $interval_floating_seconds ] )
Start up an interval timer: after a certain time, a signal arrives,
and more signals may keep arriving at certain intervals. To disable
an "itimer", use $floating_seconds of zero. If the
$interval_floating_seconds is set to zero (or unspecified), the
timer is disabled after the next delivered signal.
Use of interval timers may interfere with "alarm()", "sleep()",
and "usleep()". In standard-speak the "interaction is unspecified",
which means that *anything* may happen: it may work, it may not.
In scalar context, the remaining time in the timer is returned.
In list context, both the remaining time and the interval are returned.
There are usually three or four interval timers available: the
$which can be "ITIMER_REAL", "ITIMER_VIRTUAL", "ITIMER_PROF", or
"ITIMER_REALPROF". Note that which ones are available depends: true
UNIX platforms usually have the first three, but (for example) Win32
and Cygwin have only "ITIMER_REAL", and only Solaris seems to have
"ITIMER_REALPROF" (which is used to profile multithreaded programs).
"ITIMER_REAL" results in "alarm()"-like behaviour. Time is counted in
*real time*; that is, wallclock time. "SIGALRM" is delivered when
the timer expires.
"ITIMER_VIRTUAL" counts time in (process) *virtual time*; that is,
only when the process is running. In multiprocessor/user/CPU systems
this may be more or less than real or wallclock time. (This time is
also known as the *user time*.) "SIGVTALRM" is delivered when the
timer expires.
"ITIMER_PROF" counts time when either the process virtual time or when
the operating system is running on behalf of the process (such as I/O).
(This time is also known as the *system time*.) (The sum of user
time and system time is known as the *CPU time*.) "SIGPROF" is
delivered when the timer expires. "SIGPROF" can interrupt system calls.
The semantics of interval timers for multithreaded programs are
system-specific, and some systems may support additional interval
timers. See your "setitimer()" documentation.
=item getitimer ( $which )
Return the remaining time in the interval timer specified by $which.
In scalar context, the remaining time is returned.
In list context, both the remaining time and the interval are returned.
The interval is always what you put in using "setitimer()".
=item clock_gettime ( $which )
Return as seconds the current value of the POSIX high resolution timer
specified by $which. All implementations that support POSIX high
resolution timers are supposed to support at least the $which value
of "CLOCK_REALTIME", which is supposed to return results close to the
results of "gettimeofday", or the number of seconds since 00:00:00:00
January 1, 1970 Greenwich Mean Time (GMT). Do not assume that
CLOCK_REALTIME is zero, it might be one, or something else.
Another potentially useful (but not available everywhere) value is
"CLOCK_MONOTONIC", which guarantees a monotonically increasing time
value (unlike time(), which can be adjusted). See your system
documentation for other possibly supported values.
=item clock_getres ( $which )
Return as seconds the resolution of the POSIX high resolution timer
specified by $which. All implementations that support POSIX high
resolution timers are supposed to support at least the $which value
of "CLOCK_REALTIME", see "clock_gettime".
=item clock_nanosleep ( $which, $seconds, $flags = 0)
Sleeps for the number of seconds (1e9ths of a second) specified.
Returns the number of seconds actually slept. The $which is the
"clock id", as with clock_gettime() and clock_getres(). The flags
default to zero but "TIMER_ABSTIME" can specified (must be exported
explicitly) which means that $nanoseconds is not a time interval
(as is the default) but instead an absolute time. Can sleep for more
than one second. Can also sleep for zero seconds, which often works
like a *thread yield*. See also "Time::HiRes::sleep()",
"Time::HiRes::usleep()", and "Time::HiRes::nanosleep()".
Do not expect clock_nanosleep() to be exact down to one nanosecond.
Getting even accuracy of one thousand nanoseconds is good.
=item clock()
Return as seconds the *process time* (user + system time) spent by
the process since the first call to clock() (the definition is not
"since the start of the process", though if you are lucky these times
may be quite close to each other, depending on the system). What this
means is that you probably need to store the result of your first call
to clock(), and subtract that value from the following results of clock().
The time returned also includes the process times of the terminated
child processes for which wait() has been executed. This value is
somewhat like the second value returned by the times() of core Perl,
but not necessarily identical. Note that due to backward
compatibility limitations the returned value may wrap around at about
2147 seconds or at about 36 minutes.
=back
-Des:
##----------------------------------------
=Pkg: perl-version 0.76 1.0.sles10.lc i386
=Sum: version - Perl module
+Des:
None.
-Des:
##----------------------------------------
=Pkg: cairo 1.4.14 24.1 i586
=Sum: Vector Graphics Library with Cross-Device Output Support
+Des:
Cairo is a vector graphics library with cross-device output support.
Currently supported output targets include the X Window System,
in-memory image buffers, and PostScript. Cairo is designed to produce
identical output on all output media while taking advantage of display
hardware acceleration when available.
Authors:
--------
Carl D. Worth
-Des:
##----------------------------------------
=Pkg: cairo-devel 1.4.14 21.1 x86_64
=Sum: Development environment for cairo
+Des:
This package contains all files necessary to build binaries using
cairo.
Authors:
--------
Carl D. Worth
-Des:
##----------------------------------------
=Pkg: ghostscript-fonts-std 8.70 15.2 i586
=Sum: Standard Fonts for Ghostscript
+Des:
The necessary fonts for the PostScript interpreter Ghostscript. The
URW fonts (URW Software, Poppenbuetteler Bogen 29A, D-22399 Hamburg,
Germany).
Authors:
--------
Peter Deutsch
Martin Lottermoser
Pierre-Olivier Gaillard
Gunther Hess
Yves Arrouye
and many others
-Des:
##----------------------------------------
=Pkg: gnuplot 4.4.2 4.8.sles10.lc i586
=Sum: GNUplot a Function Plotting Utility
+Des:
GNUplot is a command line driven interactive function plotting utility.
GNUplot supports many different types of terminals, plotters, and
printers (including many color devices and pseudodevices like LaTeX)
and can easily be extended to include new devices.
-Des:
##----------------------------------------
=Pkg: ImageMagick 6.4.3.6 5.3.sles10.lc i586
=Sum: Viewer and Converter for Images
+Des:
ImageMagick is a robust collection of tools and libraries to read,
write, and manipulate an image in many image formats, including popular
formats like TIFF, JPEG, PNG, PDF, PhotoCD, and GIF. With ImageMagick,
you can create images dynamically, making it suitable for Web
applications. You can also resize, rotate, sharpen, color-reduce, or
add special effects to an image and save your completed work in many
different image formats. Image processing operations are available from
the command line as well as through C, C++, and PERL-based programming
interfaces.
Authors:
--------
John Cristy
-Des:
##----------------------------------------
=Pkg: libblas3 3.2.0 5.1 i586
=Sum: BLAS Shared Library
+Des:
BLAS (Basic Linear Algebra Subprograms) is a standard library for
numerical algebra. BLAS provides a number of basic algorithms for
linear algebra.
Authors:
--------
UTK
-Des:
##----------------------------------------
=Pkg: libMagickCore1 6.4.3.6 5.3.sles10.lc i586
=Sum: Viewer and Converter for Images - runtime library
+Des:
ImageMagick is a robust collection of tools and libraries to read,
write, and manipulate an image in many image formats, including popular
formats like TIFF, JPEG, PNG, PDF, PhotoCD, and GIF. With ImageMagick,
you can create images dynamically, making it suitable for Web
applications. You can also resize, rotate, sharpen, color-reduce, or
add special effects to an image and save your completed work in many
different image formats. Image processing operations are available from
the command line as well as through C, C++, and PERL-based programming
interfaces.
Authors:
--------
John Cristy
-Des:
##----------------------------------------
=Pkg: libMagickWand1 6.4.3.6 5.3.sles10.lc i586
=Sum: Viewer and Converter for Images - runtime library
+Des:
ImageMagick is a robust collection of tools and libraries to read,
write, and manipulate an image in many image formats, including popular
formats like TIFF, JPEG, PNG, PDF, PhotoCD, and GIF. With ImageMagick,
you can create images dynamically, making it suitable for Web
applications. You can also resize, rotate, sharpen, color-reduce, or
add special effects to an image and save your completed work in many
different image formats. Image processing operations are available from
the command line as well as through C, C++, and PERL-based programming
interfaces.
Authors:
--------
John Cristy
-Des:
##----------------------------------------
=Pkg: libwmf 0.2.8.2 110.2 i586
=Sum: Library and Utilities for Displaying and Converting Metafile Images
+Des:
This library interprets metafile images and can either display them
using the X Window System or convert them to standard formats such as
PNG, JPEG, PS, EPS, and more.
Authors:
--------
Caolan McNamara
Francis James Franklin
-Des:
##----------------------------------------
=Pkg: LONCAPA-prerequisites 1 23.1.sles10.lc i586
=Sum: Stub rpm to set up LONCAPA dependencies
+Des:
LONCAPA-prerequisites configures a system to run LON-CAPA.
-Des:
##----------------------------------------
=Pkg: LONCAPA-prerequisites 1 24.sles10.lc i586
=Sum: Stub rpm to set up LONCAPA dependencies
+Des:
LONCAPA-prerequisites configures a system to run LON-CAPA.
-Des:
##----------------------------------------
=Pkg: LONCAPA-prerequisites 1 25.sles10.lc i586
=Sum: Stub rpm to set up LONCAPA dependencies
+Des:
LONCAPA-prerequisites configures a system to run LON-CAPA.
-Des:
##----------------------------------------
=Pkg: LONCAPA-prerequisites 1 26.sles10.lc i586
=Sum: Stub rpm to set up LONCAPA dependencies
+Des:
LONCAPA-prerequisites configures a system to run LON-CAPA.
-Des:
##----------------------------------------
=Pkg: maxima 5.23.2 1.26.0.sles10.lc i586
=Sum: Symbolic Computation Program/Computer Algebra System
+Des:
Maxima is a full symbolic computation program. It is full featured
doing symbolic manipulation of polynomials, matrices, rational
functions, integration, Todd-coxeter, graphing, bigfloats. It has a
symbolic debugger source level debugger for maxima code. Maxima is
based on the original Macsyma developed at MIT in the 1970's. It is
quite reliable, and has good garbage collection, and no memory leaks.
It comes with hundreds of self tests.
-Des:
##----------------------------------------
=Pkg: maxima-exec-clisp 5.23.2 1.26.0.sles10.lc i586
=Sum: Maxima compiled with clisp
+Des:
Maxima compiled with Common Lisp.
-Des:
##----------------------------------------
=Pkg: memcached 1.1.12 12.0.sles10.lc i586
=Sum: memcached is a high-performance, distributed memory object caching system
+Des:
memcached is a high-performance, distributed memory object caching
system, generic in nature, but intended for use in speeding up dynamic
web applications by alleviating database load.
Danga Interactive developed memcached to enhance the speed of
LiveJournal.com, a site which was already doing 20 million+ dynamic
page views per day for 1 million users with a bunch of webservers and a
bunch of database servers. memcached dropped the database load to
almost nothing, yielding faster page load times for users, better
resource utilization, and faster access to the databases on a memcache
miss.
Authors:
--------
Brad Fitzpatrick
-Des:
##----------------------------------------
=Pkg: perl-Algorithm-Diff 1.1901 13.2 i586
=Sum: Compute 'Intelligent' Differences Between Two Files or Lists
+Des:
This Perl module helps to create differences between two files or
lists. It is used by 'perl-diffmk'
-Des:
##----------------------------------------
=Pkg: perl-Archive-Zip 1.24 2.7 i586
=Sum: perl-Archive-Zip
+Des:
Perl module for creation and manipulation of ZIP-files
Authors:
--------
Ned Kon
-Des:
##----------------------------------------
=Pkg: perl-Class-C3-XS 0.11 1.0.sles10.lc i586
=Sum: Class-C3-XS - XS speedups for Class::C3
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Class-Spiffy 0.12 12.4 i586
=Sum: Framework for object oriented programming in Perl.
+Des:
"Spiffy" is a framework and methodology for doing object oriented (OO)
programming in Perl. Spiffy combines the best parts of Exporter.pm,
base.pm, mixin.pm and SUPER.pm into one magic foundation class. It
attempts to fix all the nits and warts of traditional Perl OO, in a
clean, straightforward and (perhaps someday) standard way. Spiffy
borrows ideas from other OO languages like Python, Ruby, Java and Perl
6. It also adds a few tricks of its own.
Authors:
--------
Brian Ingerson
-Des:
##----------------------------------------
=Pkg: perl-Crypt-Eksblowfish 0.009 1.0.sles10.lc i586
=Sum: Crypt-Eksblowfish - Perl module
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-DateTime 0.4304 1.0.sles10.lc i586
=Sum: Date and time objects
+Des:
DateTime is a class for the representation of date/time combinations, and
is part of the Perl DateTime project. For details on this project please
see http://datetime.perl.org/. The DateTime site has a FAQ which may help
answer many "how do I do X?" questions. The FAQ is at
http://datetime.perl.org/faq.html.
-Des:
##----------------------------------------
=Pkg: perl-Devel-GlobalDestruction 0.02 1.0.sles10.lc i586
=Sum: Devel-GlobalDestruction - Expose PL_dirty, the flag which marks global
+Des:
Perl's global destruction is a little tricky to deal with WRT finalizers
because it's not ordered and objects can sometimes disappear.
Writing defensive destructors is hard and annoying, and usually if global
destruction is happenning you only need the destructors that free up non
process local resources to actually execute.
For these constructors you can avoid the mess by simply bailing out if global
destruction is in effect.
-Des:
##----------------------------------------
=Pkg: perl-Devel-Symdump 2.05 12.4 i586
=Sum: Inspect Perl's Symbol Table
+Des:
Devel::Symdump is a Perl module that provides a convenient way to
inspect Perl's symbol table and the class hierarchy within a running
program.
Authors:
--------
Andreas König
-Des:
##----------------------------------------
=Pkg: perl-Digest-SHA1 2.13 1.0.sles10.lc i586
=Sum: Digest-SHA1 - Perl interface to the SHA-1 algorithm
+Des:
The `Digest::SHA1' module allows you to use the NIST SHA-1 message
digest algorithm from within Perl programs. The algorithm takes as
input a message of arbitrary length and produces as output a 160-bit
"fingerprint" or "message digest" of the input.
In 2005, security flaws were identified in SHA-1, namely that a possible
mathematical weakness might exist, indicating that a stronger hash function
would be desirable. The the Digest::SHA manpage module implements the stronger
algorithms in the SHA family.
The `Digest::SHA1' module provide a procedural interface for simple
use, as well as an object oriented interface that can handle messages
of arbitrary length and which can read files directly.
-Des:
##----------------------------------------
=Pkg: perl-Digest-SHA 5.96 1.0.sles10.lc i586
=Sum: Digest-SHA - Perl extension for SHA-1/224/256/384/512
+Des:
Digest::SHA is written in C for speed. If your platform lacks a
C compiler, you can install the functionally equivalent (but much
slower) the Digest::SHA::PurePerl manpage module.
The programming interface is easy to use: it's the same one found
in CPAN's the Digest manpage module. So, if your applications currently
use the Digest::MD5 manpage and you'd prefer the stronger security of SHA,
it's a simple matter to convert them.
The interface provides two ways to calculate digests: all-at-once,
or in stages. To illustrate, the following short program computes
the SHA-256 digest of "hello world" using each approach:
use Digest::SHA qw(sha256_hex);
$data = "hello world";
@frags = split(//, $data);
$digest1 = sha256_hex($data);
$state = Digest::SHA->new(256);
for (@frags) { $state->add($_) }
$digest2 = $state->hexdigest;
print $digest1 eq $digest2 ?
"whew!\n" : "oops!\n";
To calculate the digest of an n-bit message where *n* is not a
multiple of 8, use the *add_bits()* method. For example, consider
the 446-bit message consisting of the bit-string "110" repeated
148 times, followed by "11". Here's how to display its SHA-1
digest:
use Digest::SHA;
$bits = "110" x 148 . "11";
$sha = Digest::SHA->new(1)->add_bits($bits);
print $sha->hexdigest, "\n";
Note that for larger bit-strings, it's more efficient to use the
two-argument version *add_bits($data, $nbits)*, where *$data* is
in the customary packed binary format used for Perl strings.
The module also lets you save intermediate SHA states to a string. The
*getstate()* method generates portable, human-readable text describing
the current state of computation. You can subsequently restore that
state with *putstate()* to resume where the calculation left off.
To see what a state description looks like, just run the following:
use Digest::SHA;
print Digest::SHA->new->add("Shaw" x 1962)->getstate;
As an added convenience, the Digest::SHA module offers routines to
calculate keyed hashes using the HMAC-SHA-1/224/256/384/512
algorithms. These services exist in functional form only, and
mimic the style and behavior of the *sha()*, *sha_hex()*, and
*sha_base64()* functions.
use Digest::SHA qw(hmac_sha256_hex);
print hmac_sha256_hex("Hi There", chr(0x0b) x 32), "\n";
-Des:
##----------------------------------------
=Pkg: perl-Error 0.17009 3.1.0.sles10.lc i586
=Sum: Error/Exception Handling in an OO-ish Way
+Des:
The Error package provides two interfaces. Firstly Error provides a procedural
interface to exception handling. Secondly Error is a base class for
errors/exceptions that can either be thrown, for subsequent catch, or can
simply be recorded.
-Des:
##----------------------------------------
=Pkg: perl-File-MMagic 1.22 15.2 i586
=Sum: Perl modules to guess file types
+Des:
Perl modules to guess file types
Authors:
--------
Nokubi Takatsugu
-Des:
##----------------------------------------
=Pkg: perl-Image-Size 2.992 135.4 i586
=Sum: A Perl Module to deal with Dimensions of an Image in Several Popular Formats
+Des:
The Image::Size library is based upon the "wwwis" script written by
Alex Knowles *(alex@ed.ac.uk)*, a tool to examine HTML and add 'width'
and height' parameters to image tags. The sizes are cached internally
based on the file name, so multiple calls on the same file name (images
used in bulleted lists, for example) do not result in repeated
computations.
Authors:
--------
Randy J. Ray
Alex Knowles
Andrew Tong
and others
-Des:
##----------------------------------------
=Pkg: perl-JSON-DWIW 0.47 1.0.sles10.lc i586
=Sum: JSON-DWIW - JSON converter that does what I want
+Des:
Other JSON modules require setting several parameters before
calling the conversion methods to do what I want. This module
does things by default that I think should be done when working
with JSON in Perl. This module also encodes and decodes faster
than the JSON manpage.pm and the JSON::Syck manpage in my benchmarks.
This means that any piece of data in Perl (assuming it's valid
unicode) will get converted to something in JSON instead of
throwing an exception. It also means that output will be strict
JSON, while accepted input will be flexible, without having to
set any options.
For a list of changes in recent versions, see the documentation
for the JSON::DWIW::Changes manpage.
This module can be downloaded from http://www.cpan.org/authors/id/D/DO/DOWENS/.
-Des:
##----------------------------------------
=Pkg: perl-Params-Classify 0.013 1.0.sles10.lc i586
=Sum: Params-Classify - Perl module
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Params-Validate 0.79 12.4 i586
=Sum: provides a system for validation method/function call parameters
+Des:
The Params::Validate module provides a flexible system for validation
method/function call parameters. The validation can be as simple as
checking for the presence of required parameters or as complex as
validating object classes (via isa) or capabilities (via can), checking
parameter types, and using customized callbacks to ensure data
integrity.
Authors:
--------
Dave Rolsky
-Des:
##----------------------------------------
=Pkg: perl-PerlMagick 6.4.3.6 5.3.sles10.lc i586
=Sum: Perl interface for ImageMagick
+Des:
PerlMagick is an objected-oriented Perl interface to ImageMagick. Use
the module to read, manipulate, or write an image or image sequence
from within a Perl script. This makes it suitable for Web CGI scripts.
Authors:
--------
John Cristy
-Des:
##----------------------------------------
=Pkg: perl-RTF-HTMLConverter 0.051 1.0.sles10.lc i586
=Sum: RTF-HTMLConverter - Converter from RTF format to HTML.
+Des:
RTF::HTMLConverter is a high-level RTF to HTML format converter. It is
based on the low-level RTF parser module RTF::Lexer. Additionally, it
requires the W3C's DOM implementation and it is known to work with either
XML::DOM or XML::GDOME.
-Des:
##----------------------------------------
=Pkg: perl-Sub-Identify 0.04 1.0.sles10.lc i586
=Sum: Sub-Identify - Retrieve names of code references
+Des:
"Sub::Identify" allows you to retrieve the real name of code references. For
this, it uses perl's introspection mechanism, provided by the "B" module.
It provides four functions : "sub_name" returns the name of the
subroutine (or "__ANON__" if it's an anonymous code reference),
"stash_name" returns its package, and "sub_fullname" returns the
concatenation of the two.
The fourth function, "get_code_info", returns a list of two elements,
the package and the subroutine name (in case of you want both and are worried
by the speed.)
In case of subroutine aliasing, those functions always return the
original name.
-Des:
##----------------------------------------
=Pkg: perl-Sub-Name 0.04 1.0.sles10.lc i586
=Sum: Sub-Name - (re)name a sub
+Des:
This module has only one function, which is also exported by default:
-Des:
##----------------------------------------
=Pkg: perl-Sys-Hostname-FQDN 0.12 1.0.sles10.lc i586
=Sum: Sys-Hostname-FQDN - Get the short or long hostname
+Des:
Sys::Hostname::FQDN uses the host 'C' library to discover the (usually)
short host name, then uses (perl) gethostbyname to extract the real
hostname.
The results from gethostbyname are exported as gethostinfo and
asciihostinfo as a convenience since they are available. Similarly, the
'C' library functions inet_ntoa and inet_aton are exported.
=over 4
=item $host = short();
returns the host part of this host's FQDN.
=item $fqdn = fqdn();
returns the fully qualified host name of this host.
=item ($name,$aliases,$addrtype,$length,@addrs)=gethostinfo();
returns:
$name fully qualifed host name of this host.
$aliases alternate names for this host.
$addrtype The type of address; always AF_INET at present.
$length The length of the address in bytes.
@addrs array of network addresses for this host
in network byte order.
=item ($name,$aliases,$addrtype,$length,@addrs)=asciihostinfo();
returns:
$name fully qualifed host name of this host.
$aliases alternate names for this host.
$addrtype The type of address; always AF_INET at present.
$length The length of the address in bytes.
@addrs array of dot quad IP addresses for this host.
=item $dotquad = inet_ntoa($netaddr);
input: packed network address in network byte order.
returns: dot quad IP address.
=item $netaddr = inet_aton($dotquad);
input: dot quad IP address.
returns: packed network address in network byte order.
=back
-Des:
##----------------------------------------
=Pkg: perl-Test-Exception 0.29 46.4 i586
=Sum: Test::Exception - Test exception based code
+Des:
This module provides a few convenience methods for testing exception
based code. It is built with Test::Builder and plays happily with
Test::More and friends.
Authors: Adrian Howard
-Des:
##----------------------------------------
=Pkg: perl-XML-LibXML 1.62 1.0.sles10.lc i586
=Sum: XML-LibXML - Interface to Gnome libxml2 xml parsing and DOM library
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-XML-LibXML 2.0129 1.0.sles10.lc i586
=Sum: XML-LibXML - Interface to Gnome libxml2 xml parsing and DOM library
+Des:
None.
-Des:
##----------------------------------------
=Pkg: R-alr3 1.1.12 0.sles10.lc i586
=Sum: Methods and data to accompany Applied Linear Regression 3rd edition
+Des:
R package:
This library is a companion to the textbook S. Weisberg (2005), "Applied Linear Regression," 3rd edition, Wiley.
It includes all the data sets discussed in the book (except one), and several few functions that are tailored to
the methods discussed in the book.
-Des:
##----------------------------------------
=Pkg: R-base 2.13.0 12.1 i586
=Sum: R - statistics package (S-Plus like)
+Des:
R is a language which is not entirely unlike the S language developed at
AT&T Bell Laboratories by Rick Becker, John Chambers and Allan Wilks.
AUTHORS: R Core Team
-Des:
##----------------------------------------
=Pkg: R-base-devel 2.13.0 12.1 i586
=Sum: Libraries and includefiles for developing with R-base
+Des:
This package provides the necessary development headers and
libraries to allow you to devel with R-base.
-Des:
##----------------------------------------
=Pkg: R-car 1.2.16 0.sles10.lc i586
=Sum: Companion to Applied Regression
+Des:
R package:
This package accompanies J. Fox, An R and S-PLUS Companion to Applied Regression, Sage, 2002. The package contains mostly functions for applied regression, linear models, and generalized linear models, with an emphasis on regression diagnostics, particularly graphical diagnostic methods. There are also some utility functions. With some exceptions, I have tried not to duplicate capabilities in the basic distribution of R, nor in widely used packages. Where relevant, the functions in car are consistent with na.action = na.omit or na.exclude.
-Des:
##----------------------------------------
=Pkg: R-Hmisc 3.6.1 0.sles10.lc i586
=Sum: Library of functions for data analysis, variable clustering and various utilities
+Des:
R package:
The Hmisc library contains many functions useful for data analysis, high-level graphics, utility operations,
functions for computing sample size and power, importing datasets, imputing missing values, advanced table making,
variable clustering, character string manipulation, conversion of S objects to LaTeX code, and recoding variables.
-Des:
##----------------------------------------
=Pkg: R-leaps 2.9 0.sles10.lc i586
=Sum: Regression subset selection including exhaustive search
+Des:
R package:
Regression subset selection including exhaustive search
-Des:
##----------------------------------------
=Pkg: R-lmtest 0.9.26 0.sles10.lc i586
=Sum: Testing Linear Regression Models
+Des:
R package:
A collection of tests, data sets and examples for diagnostic checking in linear regression models.
-Des:
##----------------------------------------
=Pkg: R-phpSerialize 0.8.1 0.sles10.lc i586
=Sum: Serializes R objects for import by PHP into an associative array.
+Des:
R package:
Serializes R objects for import by PHP into an associative array. Can be used to build interactive web pages with R.
-Des:
##----------------------------------------
=Pkg: R-qAnalyst 0.6.0 0.sles10.lc i586
=Sum: Control Charts, Capability and Distribution Identification
+Des:
R package:
Control charts for variables and attributes according to Douglas C. Montgomery Introduction to Statistical Quality Control book,
Capability analysis for normal and non - normal distributions and Distributions Identification
-Des:
##----------------------------------------
=Pkg: R-quadprog 1.4.12 0.sles10.lc i586
=Sum: Functions to solve Quadratic Programming Problems.
+Des:
R package:
Library of routines and documentation for solving quadratic programming problems.
-Des:
##----------------------------------------
=Pkg: R-SuppDists 1.1.8 0.sles10.lc i586
=Sum: Ten Supplementary distributions and two Random Number Generators
+Des:
R package:
Ten distributions supplementing those built into R. Inverse Gauss, Kruskal-Wallis, Kendall's Tau, Friedman's chi squared, Spearman's rho, maximum F ratio, the Pearson product moment correlation coefficiant, Johnson distributions, normal scores and generalized hypergeometric distributions. In addition two random number generators of George Marsaglia are included.
-Des:
##----------------------------------------
=Pkg: R-zoo 1.6.2 0.sles10.lc i586
=Sum: Z's ordered observations
+Des:
R package:
An S3 class with methods for totally ordered indexed observations.
It is particularly aimed at irregular time series of numeric vectors/matrices and factors.
zoo's key design goals are independence of a particular index/date/time class and consistency with ts and base R by providing methods to extend standard generics.
-Des:
##----------------------------------------
=Pkg: swig 1.3.27 19.4 i586
=Sum: Simplified Wrapper and Interface Generator
+Des:
SWIG is a compiler that attempts to make it easy to integrate C, C++,
or Objective-C code with scripting languages including Perl, Tcl, and
Python. In a nutshell, you give it a bunch of ANSI C/C++ declarations
and it generates an interface between C and your favorite scripting
language. However, this is only scratching the surface of what SWIG
can do--some of its more advanced features include automatic
documentation generation, module and library management, extensive
customization options, and more.
Authors:
--------
Dave Beazley
-Des:
##----------------------------------------
=Pkg: te_ams 3.0 37.13.1 i586
=Sum: All about Ams-TeX
+Des:
This package provides AmS-TeX some parts of AmS-LaTeX, which is
released by the American Mathematical Society. For using AmS-TeX,
AmS-LaTeX, or their styles, install this package.
Authors:
--------
Karl Berry
Tim Morgan
Tomas Rokicki
Donald Ervin Knuth
Thomas Esser
-Des:
##----------------------------------------
=Pkg: te_latex 3.0 37.13.1 i586
=Sum: All About LaTeX
+Des:
This package provides LaTeX. To be exact, LaTeX2e, and a huge amount
software for LaTeX. This package is required by most (La)TeX
documents.
Authors:
--------
Leslie Lamport
Johannes Braams
David Carlisle
Alan Jeffrey
Frank Mittelbach
Chris Rowley
Rainer Schöpf
Markus Kohm
Members of the LaTeX3 project
-Des:
##----------------------------------------
=Pkg: tetex 3.0 37.13.1 i586
=Sum: The Base System of teTeX
+Des:
After installing teTeX and the package te_latex, find a large selection
of documentation for TeX, LaTeX, and various layout styles under
/usr/share/texmf/doc.
TeX (pronounced tech) is an interpreter for text formatting and was
developed by Donald E. Knuth. It works with control and macro commands
on a text file. Working with TeX is similar to typesetting methods.
LaTeX or better LaTeX2e is a complex macro package which removes the
cryptical TeX interface and does most of the work for the user.
TeX uses special fonts produced by the MetaFont program. Various
printer drivers and an X11 viewer is also included in this package. The
teTeX package is based on the standard TeX package of Karl Berry which
makes configuration much easier. It's also possible to use PostScript
fonts. A real PostScript printer is required however. If the
ghostscript (gs) package is installed, all drivers for printing and
viewing can use these fonts. Note, however, that the fonts included in
the ghostscript package are not identical to Adobe's PostScript fonts.
The copyright prohibits us from including them on the CD.
Besides these features, there are the programs MakeIndex (for producing
indexes), BibTeX (for literature data-processing), and the script
xtexsh (requires tcl/tk).
Note the differences between LaTeX2.09 and LaTeX2e. LaTeX2e can process
original LaTeX2.09 text, but style files that require LaTeX2.09
internal macros may not work correctly. Under
/usr/share/texmf/doc/latex/base/, find the documentation for LaTeX2e.
New users should review the documentation stored there.
The teTeX package from Thomas Esser includes a full texmf tree, many
programs (tex, dvips, ...), shell scripts configuration, and a big
collection of documentations. This package is simply configured by the
script texconfig and has multilanguage options.
Do not install this package together with ntex; ntex is not delivered
together with SuSE Linux.
teTeX is NOT an upgrade or update for the ntex package!!
Authors:
--------
Karl Berry
Tim Morgan
Tomas Rokicki
Donald Ervin Knuth
Thomas Esser
-Des:
##----------------------------------------
=Pkg: latex-ucs 20041017 13.2 noarch
=Sum: Unicode Support for LaTeX
+Des:
This package contains support for using UTF-8 as input encoding in
LaTeX documents.
Authors:
--------
Dominique Unruh
-Des:
##----------------------------------------
=Pkg: perl-Algorithm-C3 0.08 1.0.sles10.lc noarch
=Sum: Algorithm-C3 - Perl module
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Algorithm-Diff 1.1902 1.0.sles10.lc noarch
=Sum: Algorithm-Diff - Compute `intelligent' differences between two files / lists
+Des:
require Algorithm::Diff;
my $diff = Algorithm::Diff->new( \@seq1, \@seq2 );
$diff->Base( 1 ); # Return line numbers, not indices
while( $diff->Next() ) {
next if $diff->Same();
my $sep = '';
if( ! $diff->Items(2) ) {
printf "%d,%dd%d\n",
$diff->Get(qw( Min1 Max1 Max2 ));
} elsif( ! $diff->Items(1) ) {
printf "%da%d,%d\n",
$diff->Get(qw( Max1 Min2 Max2 ));
} else {
$sep = "---\n";
printf "%d,%dc%d,%d\n",
$diff->Get(qw( Min1 Max1 Min2 Max2 ));
}
print "< $_" for $diff->Items(1);
print $sep;
print "> $_" for $diff->Items(2);
}
use Algorithm::Diff qw(
LCS LCS_length LCSidx
diff sdiff compact_diff
traverse_sequences traverse_balanced );
@lcs = LCS( \@seq1, \@seq2 );
$lcsref = LCS( \@seq1, \@seq2 );
$count = LCS_length( \@seq1, \@seq2 );
( $seq1idxref, $seq2idxref ) = LCSidx( \@seq1, \@seq2 );
@diffs = diff( \@seq1, \@seq2 );
@sdiffs = sdiff( \@seq1, \@seq2 );
@cdiffs = compact_diff( \@seq1, \@seq2 );
traverse_sequences(
\@seq1,
\@seq2,
{ MATCH => \&callback1,
DISCARD_A => \&callback2,
DISCARD_B => \&callback3,
},
\&key_generator,
@extra_args,
);
traverse_balanced(
\@seq1,
\@seq2,
{ MATCH => \&callback1,
DISCARD_A => \&callback2,
DISCARD_B => \&callback3,
CHANGE => \&callback4,
},
\&key_generator,
@extra_args,
);
-Des:
##----------------------------------------
=Pkg: perl-aliased 0.34 1.0.sles10.lc noarch
=Sum: aliased - Perl module
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-AppConfig 1.66 1.0.sles10.lc noarch
=Sum: AppConfig - AppConfig is a bundle of Perl5 modules for reading configuration files and parsing command line arguments.
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Authen-Captcha 1.023 1.0.sles10.lc noarch
=Sum: Authen-Captcha - Perl extension for creating captcha's to verify the human element in transactions.
+Des:
use Authen::Captcha;
my $captcha = Authen::Captcha->new();
$captcha->data_folder('/some/folder');
$captcha->output_folder('/some/http/folder');
my $captcha = Authen::Captcha->new(
data_folder => '/some/folder',
output_folder => '/some/http/folder',
);
my $md5sum = $captcha->generate_code($number_of_characters);
my $results = $captcha->check_code($code,$md5sum);
-Des:
##----------------------------------------
=Pkg: perl-Cache-Memcached 1.18 1.0.sles10.lc noarch
=Sum: Cache-Memcached - client library for memcached (memory cache daemon)
+Des:
This is the Perl API for memcached, a distributed memory cache daemon.
More information is available at:
http://www.danga.com/memcached/
-Des:
##----------------------------------------
=Pkg: perl-CAM-PDF 1.52 1.0.sles10.lc noarch
=Sum: CAM-PDF - Perl module
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Captcha-reCAPTCHA 0.95 1.0.sles10 noarch
=Sum: Captcha-reCAPTCHA - A Perl implementation of the reCAPTCHA API
+Des:
reCAPTCHA is a hybrid mechanical turk and captcha that allows visitors
who complete the captcha to assist in the digitization of books.
From :
reCAPTCHA improves the process of digitizing books by sending words that
cannot be read by computers to the Web in the form of CAPTCHAs for
humans to decipher. More specifically, each word that cannot be read
correctly by OCR is placed on an image and used as a CAPTCHA. This is
possible because most OCR programs alert you when a word cannot be read
correctly.
This Perl implementation is modelled on the PHP interface that can be
found here:
To use reCAPTCHA you need to register your site here:
-Des:
##----------------------------------------
=Pkg: perl-Class-Accessor 0.34 1.0.sles10.lc noarch
=Sum: Class-Accessor - Automated accessor generation
+Des:
This module automagically generates accessors/mutators for your class.
Most of the time, writing accessors is an exercise in cutting and
pasting. You usually wind up with a series of methods like this:
sub name {
my $self = shift;
if(@_) {
$self->{name} = $_[0];
}
return $self->{name};
}
sub salary {
my $self = shift;
if(@_) {
$self->{salary} = $_[0];
}
return $self->{salary};
}
One for each piece of data in your object. While some will be unique,
doing value checks and special storage tricks, most will simply be
exercises in repetition. Not only is it Bad Style to have a bunch of
repetitious code, but it's also simply not lazy, which is the real
tragedy.
If you make your module a subclass of Class::Accessor and declare your
accessor fields with mk_accessors() then you'll find yourself with a
set of automatically generated accessors which can even be
customized!
The basic set up is very simple:
package Foo;
use base qw(Class::Accessor);
Foo->mk_accessors( qw(far bar car) );
Done. Foo now has simple far(), bar() and car() accessors
defined.
Alternatively, if you want to follow Damian's *best practice* guidelines
you can use:
package Foo;
use base qw(Class::Accessor);
Foo->follow_best_practice;
Foo->mk_accessors( qw(far bar car) );
Note: you must call `follow_best_practice' before calling `mk_accessors'.
-Des:
##----------------------------------------
=Pkg: perl-Class-C3 0.21 1.0.sles10.lc noarch
=Sum: Class-C3 - A pragma to use the C3 method resolution order algortihm
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Class-Data-Inheritable 0.08 1.0.sles10.lc noarch
=Sum: Class-Data-Inheritable - Inheritable, overridable class data
+Des:
Class::Data::Inheritable is for creating accessor/mutators to class
data. That is, if you want to store something about your class as a
whole (instead of about a single object). This data is then inherited
by your subclasses and can be overriden.
For example:
Pere::Ubu->mk_classdata('Suitcase');
will generate the method Suitcase() in the class Pere::Ubu.
This new method can be used to get and set a piece of class data.
Pere::Ubu->Suitcase('Red');
$suitcase = Pere::Ubu->Suitcase;
The interesting part happens when a class inherits from Pere::Ubu:
package Raygun;
use base qw(Pere::Ubu);
$suitcase = Raygun->Suitcase;
Raygun inherits its Suitcase class data from Pere::Ubu.
Inheritance of class data works analogous to method inheritance. As
long as Raygun does not "override" its inherited class data (by using
Suitcase() to set a new value) it will continue to use whatever is set
in Pere::Ubu and inherit further changes:
Pere::Ubu->Suitcase('Blue');
However, should Raygun decide to set its own Suitcase() it has now
"overridden" Pere::Ubu and is on its own, just like if it had
overriden a method:
Raygun->Suitcase('Orange');
Now that Raygun has overridden Pere::Ubu futher changes by Pere::Ubu
no longer effect Raygun.
Pere::Ubu->Suitcase('Samsonite');
-Des:
##----------------------------------------
=Pkg: perl-Class-Mix 0.005 1.0.sles10.lc noarch
=Sum: Class-Mix - Perl module
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Class-Singleton 1.4 1.0.sles10.lc noarch
=Sum: Class-Singleton - Base class for creating singleton objects
+Des:
This is the "Class::Singleton" module. A Singleton describes an object class
that can have only one instance in any system. An example of a Singleton
might be a print spooler or system registry. This module implements a
Singleton class from which other classes can be derived. By itself, the
"Class::Singleton" module does very little other than manage the instantiation
of a single object. In deriving a class from "Class::Singleton", your module
will inherit the Singleton instantiation method and can implement whatever
specific functionality is required.
For a description and discussion of the Singleton class, see
"Design Patterns", Gamma et al, Addison-Wesley, 1995, ISBN 0-201-63361-2.
-Des:
##----------------------------------------
=Pkg: perl-Crypt-RC4 2.02 1.0.sles10.lc noarch
=Sum: Crypt-RC4 - Perl implementation of the RC4 encryption algorithm
+Des:
A simple implementation of the RC4 algorithm, developed by RSA Security, Inc. Here is the description
from RSA's website:
RC4 is a stream cipher designed by Rivest for RSA Data Security (now RSA Security). It is a variable
key-size stream cipher with byte-oriented operations. The algorithm is based on the use of a random
permutation. Analysis shows that the period of the cipher is overwhelmingly likely to be greater than
10100. Eight to sixteen machine operations are required per output byte, and the cipher can be
expected to run very quickly in software. Independent analysts have scrutinized the algorithm and it
is considered secure.
Based substantially on the "RC4 in 3 lines of perl" found at http://www.cypherspace.org
A major bug in v1.0 was fixed by David Hook (dgh@wumpus.com.au). Thanks, David.
-Des:
##----------------------------------------
=Pkg: perl-Data-OptList 0.104 1.0.sles10.lc noarch
=Sum: Data-OptList - Perl module
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Devel-StackTrace 1.20 1.0.sles10.lc noarch
=Sum: Devel-StackTrace - Perl module
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-enum 1.11 1.0.sles10.lc noarch
=Sum: enum - C style enumerated types and bitmask flags in Perl
+Des:
This module is used to define a set of constants with ordered numeric values,
similar to the `enum' type in the C programming language.
You can also define bitmask constants, where the value assigned to each
constant has exactly one bit set (eg 1, 2, 4, 8, etc).
What are enumerations good for?
Typical uses would be for giving mnemonic names to indexes of arrays.
Such arrays might be a list of months, days, or a return value index from
a function such as localtime():
use enum qw(
:Months_=0 Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec
:Days_=0 Sun Mon Tue Wed Thu Fri Sat
:LC_=0 Sec Min Hour MDay Mon Year WDay YDay Isdst
);
if ((localtime)[LC_Mon] == Months_Jan) {
print "It's January!\n";
}
if ((localtime)[LC_WDay] == Days_Fri) {
print "It's Friday!\n";
}
This not only reads easier, but can also be typo-checked at compile time when
run under use strict. That is, if you misspell Days_Fri as Days_Fry,
you'll generate a compile error.
-Des:
##----------------------------------------
=Pkg: perl-Exception-Class 1.26 1.0.sles10.lc noarch
=Sum: Exception-Class - Perl module
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Expect 1.20 1 noarch
=Sum: Expect - Perl module
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-File-ReadBackwards 1.05 1.0.sles10.lc noarch
=Sum: File-ReadBackwards - - Read a file backwards by lines.
+Des:
This module reads a file backwards line by line. It is simple to use,
memory efficient and fast. It supports both an object and a tied handle
interface.
It is intended for processing log and other similar text files which
typically have their newest entries appended to them. By default files
are assumed to be plain text and have a line ending appropriate to the
OS. But you can set the input record separator string on a per file
basis.
-Des:
##----------------------------------------
=Pkg: perl-File-Slurp 9999.13 1.0.sles10.lc noarch
=Sum: File-Slurp - Efficient Reading/Writing of Complete Files
+Des:
This module provides subs that allow you to read or write entire files
with one simple call. They are designed to be simple to use, have
flexible ways to pass in or get the file contents and to be very
efficient. There is also a sub to read in all the files in a
directory other than "." and ".."
These slurp/spew subs work for files, pipes and
sockets, and stdio, pseudo-files, and DATA.
-Des:
##----------------------------------------
=Pkg: perl-File-Slurp 9999.19 1.0.sles10.lc noarch
=Sum: File-Slurp - Simple and Efficient Reading/Writing/Modifying of Complete Files
+Des:
This module provides subs that allow you to read or write entire files
with one simple call. They are designed to be simple to use, have
flexible ways to pass in or get the file contents and to be very
efficient. There is also a sub to read in all the files in a
directory other than `.' and `..'
These slurp/spew subs work for files, pipes and sockets, stdio,
pseudo-files, and the DATA handle. Read more about why slurping files is
a good thing in the file 'slurp_article.pod' in the extras/ directory.
If you are interested in how fast these calls work, check out the
slurp_bench.pl program in the extras/ directory. It compares many
different forms of slurping. You can select the I/O direction, context
and file sizes. Use the --help option to see how to run it.
-Des:
##----------------------------------------
=Pkg: perl-GD-Barcode 1.15 1.0.sles10.lc noarch
=Sum: GD-Barcode - Create barcode image with GD
+Des:
GD::Barcode is a subclass of GD and allows you to create barcode image with GD.
This module based on "Generate Barcode Ver 1.02 By Shisei Hanai 97/08/22".
From 1.14, you can use this module even if no GD (except plot method).
-Des:
##----------------------------------------
=Pkg: perl-GDGraph 1.4308 1.0.sles10.lc noarch
=Sum: GDGraph - Produces charts with GD
+Des:
GD::Graph is a *perl5* module to create charts using the GD module.
The following classes for graphs with axes are defined:
=over 4
=item "GD::Graph::lines"
Create a line chart.
=item "GD::Graph::bars" and "GD::Graph::hbars"
Create a bar chart with vertical or horizontal bars.
=item "GD::Graph::points"
Create an chart, displaying the data as points.
=item "GD::Graph::linespoints"
Combination of lines and points.
=item "GD::Graph::area"
Create a graph, representing the data as areas under a line.
=item "GD::Graph::mixed"
Create a mixed type graph, any combination of the above. At the moment
this is fairly limited. Some of the options that can be used with some
of the individual graph types won't work very well. Bar graphs drawn
after lines or points graphs may obscure the earlier data, and
specifying bar_width will not produce the results you probably expected.
=back
Additional types:
=over 4
=item "GD::Graph::pie"
Create a pie chart.
=back
-Des:
##----------------------------------------
=Pkg: perl-GD-Graph3d 0.63 1.0.sles10.lc noarch
=Sum: GD-Graph3d - Creates 3D charts with GD::Graph and GD.
+Des:
This is the GD::Graph3d extensions module. It provides 3D graphs for the
GD::Graph module by Martien Verbruggen, which in turn generates graph
using Lincoln Stein's GD.pm.
You use these modules just as you would any of the GD::Graph modules, except
that they generate 3d-looking graphs. Each graph type is described below
with only the options that are unique to the 3d version. The modules are
based on their 2d versions (e.g. GD::Graph::bars3d works like
GD::Graph::bars), and support all the options in those. Make sure to read
the documentation on GD::Graph.
=over 4
=item GD::Graph::pie3d
This is merely a wrapper around GD::Graph::pie for consistency. It also
sets 3d pie mode by default (which GD::Graph does as of version 1.22).
All options are exactly as in GD::Graph::pie.
=item GD::Graph::bars3d
This works like GD::Graph::bars, but draws 3d bars. The following settings
are new or changed in GD::Graph::bars3d.
=over 4
=item bar_depth
Sets the z-direction depth of the bars. This defaults to 10. If you have a
large number of bars or a small chart width, you may want to change this.
A visually good value for this is approximately
width_of_chart / number_of_bars.
=item overwrite
In GD::Graph::bars, multiple series of bars are normally drawn side-by-side.
You can set overwrite to 1 to tell it to draw each series behind the
previous one. By setting overwrite to 2 you can have them drawn on top of
each other, that is the series are stacked.
=item shading
By default this is set to '1' and will shade and highlight the bars (and axes).
The light source is at top-left-center which scan well for most computer
users. You can disable the shading of bars and axes by specifying a false
value for this option.
=back
=item GD::Graph::lines3d
This works like GD::Graph::lines, but draws 3d line. The following settings
are new or changed in GD::Graph::line3d.
=over 4
=item line_depth
Sets the z-direction depth of the lines. This defaults to 10. If you have a
large number of bars or a small chart width, you may want to change this.
A visually good value for this is approximately
width_of_chart / number_of_bars.
=item shading
By default this is set to '1' and will shade and highlight the line (and axes).
The light source is at top-left-center which scan well for most computer
users. You can disable the shading of lines and axes by specifiying a false
value for this option.
=back
=back
-Des:
##----------------------------------------
=Pkg: perl-GDTextUtil 0.86 1.0.sles10.lc noarch
=Sum: GDTextUtil - text utilities for GD
+Des:
This module provides a font-independent way of dealing with text in
GD, for use with the GD::Text::* modules and GD::Graph.
-Des:
##----------------------------------------
=Pkg: perl-HTML-Tiny 1.05 1.0.sles10 noarch
=Sum: HTML-Tiny - Lightweight, dependency free HTML/XML generation
+Des:
"HTML::Tiny" is a simple, dependency free module for generating
HTML (and XML). It concentrates on generating syntactically correct
XHTML using a simple Perl notation.
In addition to the HTML generation functions utility functions are
provided to
=over
=item * encode and decode URL encoded strings
=item * entity encode HTML
=item * build query strings
=item * JSON encode data structures
=back
-Des:
##----------------------------------------
=Pkg: perl-HTML-Tree 3.21 1.0.sles10.lc noarch
=Sum: HTML-Tree - build and scan parse-trees of HTML
+Des:
HTML-Tree is a suite of Perl modules for making parse trees out of
HTML source. It consists of mainly two modules, whose documentation
you should refer to: HTML::TreeBuilder
and HTML::Element.
HTML::TreeBuilder is the module that builds the parse trees. (It uses
HTML::Parser to do the work of breaking the HTML up into tokens.)
The tree that TreeBuilder builds for you is made up of objects of the
class HTML::Element.
If you find that you do not properly understand the documentation
for HTML::TreeBuilder and HTML::Element, it may be because you are
unfamiliar with tree-shaped data structures, or with object-oriented
modules in general. Sean Burke has written some articles for
*The Perl Journal* ("www.tpj.com") that seek to provide that background.
The full text of those articles is contained in this distribution, as:
=over 4
=item HTML::Tree::AboutObjects
"User's View of Object-Oriented Modules" from TPJ17.
=item HTML::Tree::AboutTrees
"Trees" from TPJ18
=item HTML::Tree::Scanning
"Scanning HTML" from TPJ19
=back
Readers already familiar with object-oriented modules and tree-shaped
data structures should read just the last article. Readers without
that background should read the first, then the second, and then the
third.
-Des:
##----------------------------------------
=Pkg: perl-Image-Base 1.07 1.0.sles10.lc noarch
=Sum: Image-Base - Base class for image manipulation
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Image-Info 1.28 1.0.sles10.lc noarch
=Sum: Image-Info - Extract meta information from image files (DEPRECATED)
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Image-Xbm 1.08 1.0.sles10.lc noarch
=Sum: Image-Xbm - Load, create, manipulate and save xbm image files.
+Des:
This class module provides basic load, manipulate and save functionality for
the xbm file format. It inherits from "Image::Base" which provides additional
manipulation functionality, e.g. "new_from_image()". See the "Image::Base"
pod for information on adding your own functionality to all the "Image::Base"
derived classes.
-Des:
##----------------------------------------
=Pkg: perl-Image-Xpm 1.09 1.0.sles10.lc noarch
=Sum: Image-Xpm - Load, create, manipulate and save xpm image files.
+Des:
This class module provides basic load, manipulate and save functionality for
the xpm file format. It inherits from "Image::Base" which provides additional
manipulation functionality, e.g. "new_from_image()". See the "Image::Base"
pod for information on adding your own functionality to all the Image::Base
derived classes.
-Des:
##----------------------------------------
=Pkg: perl-LaTeX-Driver 0.08 1.0.sles10.lc noarch
=Sum: LaTeX-Driver - LaTeX Driver
+Des:
The LaTeX::Driver module encapsulates the details of invoking the
Latex programs to format a LaTeX document. Formatting with LaTeX is
complicated; there are potentially many programs to run and the output
of those programs must be monitored to determine whether further
processing is required.
This module runs the required commands in the directory specified,
either explicitly with the "dirname" option or implicitly by the
directory part of "basename", or in the current directory. As a
result of the processing up to a dozen or more intermediate files are
created. These can be removed with the "cleanup" method.
-Des:
##----------------------------------------
=Pkg: perl-LaTeX-Encode 0.03 1.0.sles10.lc noarch
=Sum: LaTeX-Encode - encode characters for LaTeX formatting
+Des:
This module provides a function to encode text that is to be formatted
with LaTeX. It encodes characters that are special to LaTeX or that
are represented in LaTeX by LaTeX commands.
The special characters are: "\" (command character), "{" (open
group), "}" (end group), "&" (table column separator), "#"
(parameter specifier), "%" (comment character), "_" (subscript),
"^" (superscript), "~" (non-breakable space), "$" (mathematics mode).
Note that some of the LaTeX commands for characters are defined in the
LaTeX "textcomp" package. If your text includes such characters, you
will need to include the following lines in the preamble to your LaTeX
document.
\usepackage[T1]{fontenc}
\usepackage{textcomp}
The function is useful for encoding data that is interpolated into
LaTeX document templates, say with "Template::Plugin::Latex"
(shameless plug!).
-Des:
##----------------------------------------
=Pkg: perl-LaTeX-Table 0.9.11 1.0.sles10.lc noarch
=Sum: LaTeX-Table-0.9.11.tar.gz - Perl module
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Math-Calculus-Expression_loncapa 0.2.2 1.0.sles10.lc noarch
=Sum: Math-Calculus-Expression - Algebraic Calculus Tools Expression Class
+Des:
This module can take an algebraic expression, parse it into a tree structure, simplify
the tree, substitute variables and named constants for other variables or constants
(which may be numeric), numerically evaluate the tree and turn the tree back into an
output of the same form as the input.
It supports a wide range of expressions including the +, -, *, / and ^ (raise to
power) operators, bracketed expressions to enable correct precedence and the functions
ln, exp, sin, cos, tan, sec, cosec, cot, sinh, cosh, tanh, sech, cosech, coth, asin,
acos, atan, asinh, acosh and atanh.
Modifed from standard Math-Calculus-Expression-0.2.2, for use in LON-CAPA, by the
addition of a math_calculus_expression() routine, which can be used with Safe::Hole
to create a Math::Calculus::Expression object which can use all object methods inside
the a perl Safe space container.
sub math_calc_expression {
return Math::Calculus::Expression->new(shift);
}
-Des:
##----------------------------------------
=Pkg: perl-MIME-Lite 3.01_05 1.0.sles10.lc noarch
=Sum: MIME-Lite - low-calorie MIME generator
+Des:
In the never-ending quest for great taste with fewer calories,
we proudly present: *MIME::Lite*.
MIME::Lite is intended as a simple, standalone module for generating
(not parsing!) MIME messages... specifically, it allows you to
output a simple, decent single- or multi-part message with text or binary
attachments. It does not require that you have the Mail:: or MIME::
modules installed, but will work with them if they are.
You can specify each message part as either the literal data itself (in
a scalar or array), or as a string which can be given to open() to get
a readable filehandle (e.g., " sequences
+Des:
This module provides things that are useful in decoding
Pod E<...> sequences. Presumably, it should be used
only by Pod parsers and/or formatters.
By default, Pod::Escapes exports none of its symbols. But
you can request any of them to be exported.
Either request them individually, as with
"use Pod::Escapes qw(symbolname symbolname2...);",
or you can do "use Pod::Escapes qw(:ALL);" to get all
exportable symbols.
-Des:
##----------------------------------------
=Pkg: perl-Pod-POM 0.17 1.0.sles10.lc noarch
=Sum: Pod-POM - POD Object Model
+Des:
This module implements a parser to convert Pod documents into a simple
object model form known hereafter as the Pod Object Model. The object
model is generated as a hierarchical tree of nodes, each of which
represents a different element of the original document. The tree can
be walked manually and the nodes examined, printed or otherwise
manipulated. In addition, Pod::POM supports and provides view objects
which can automatically traverse the tree, or section thereof, and
generate an output representation in one form or another.
Let's look at a typical Pod document by way of example.
-Des:
##----------------------------------------
=Pkg: perl-Pod-Simple 3.16 1.0.sles10.lc noarch
=Sum: Pod-Simple - framework for parsing Pod
+Des:
Pod::Simple is a Perl library for parsing text in the Pod ("plain old
documentation") markup language that is typically used for writing
documentation for Perl and for Perl modules. The Pod format is explained
perlpod; the most common formatter is called "perldoc".
Pod formatters can use Pod::Simple to parse Pod documents and render them into
plain text, HTML, or any number of other formats. Typically, such formatters
will be subclasses of Pod::Simple, and so they will inherit its methods, like
"parse_file".
If you're reading this document just because you have a Pod-processing
subclass that you want to use, this document (plus the documentation for the
subclass) is probably all you need to read.
If you're reading this document because you want to write a formatter
subclass, continue reading it and then read Pod::Simple::Subclassing, and
then possibly even read perlpodspec (some of which is for parser-writers,
but much of which is notes to formatter-writers).
-Des:
##----------------------------------------
=Pkg: perl-PostScript-Simple 0.07 1.0.sles10.lc noarch
=Sum: PostScript-Simple - Produce PostScript files from Perl
+Des:
PostScript::Simple allows you to have a simple method of writing PostScript
files from Perl. It has graphics primitives that allow lines, curves, circles,
polygons and boxes to be drawn. Text can be added to the page using standard
PostScript fonts.
The images can be single page EPS files, or multipage PostScript files. The
image size can be set by using a recognised paper size (""A4"", for example) or
by giving dimensions. The units used can be specified (""mm"" or ""in"", etc)
and are the same as those used in TeX. The default unit is a bp, or a PostScript
point, unlike TeX.
-Des:
##----------------------------------------
=Pkg: perl-Readonly 1.03 1.0.sles10.lc noarch
=Sum: Readonly - Facility for creating read-only scalars, arrays, hashes.
+Des:
This is a facility for creating non-modifiable variables. This is
useful for configuration files, headers, etc. It can also be useful
as a development and debugging tool, for catching updates to variables
that should not be changed.
If any of the values you pass to "Scalar", "Array", or "Hash" are
references, then those functions recurse over the data structures,
marking everything as Readonly. Usually, this is what you want: the
entire structure nonmodifiable. If you want only the top level to be
Readonly, use the alternate "Scalar1", "Array1" and "Hash1"
functions.
Please note that most users of Readonly will also want to install a
companion module Readonly::XS. See the "CONS" section below for more
details.
-Des:
##----------------------------------------
=Pkg: perl-Scope-Guard 0.12 1.0.sles10.lc noarch
=Sum: Scope-Guard - lexically-scoped resource management
+Des:
This module provides a convenient way to perform cleanup or other forms of resource
management at the end of a scope. It is particularly useful when dealing with exceptions:
the "Scope::Guard" constructor takes a reference to a subroutine that is guaranteed to
be called even if the thread of execution is aborted prematurely. This effectively allows
lexically-scoped "promises" to be made that are automatically honoured by perl's garbage
collector.
For more information, see:
-Des:
##----------------------------------------
=Pkg: perl-Spreadsheet-WriteExcel 2.17 1.0.sles10.lc noarch
=Sum: Spreadsheet-WriteExcel - Write to a cross platform Excel binary file
+Des:
The Spreadsheet::WriteExcel module can be used to create a cross-platform Excel binary file. Multiple worksheets can be added to a workbook and formatting can be applied to cells. Text, numbers, formulas, hyperlinks and images can be written to the cells.
The Excel file produced by this module is compatible with 97, 2000, 2002 and 2003.
The module will work on the majority of Windows, UNIX and Macintosh platforms. Generated files are also compatible with the Linux/UNIX spreadsheet applications Gnumeric and OpenOffice.org.
This module cannot be used to write to an existing Excel file.
-Des:
##----------------------------------------
=Pkg: perl-Sub-Exporter 0.982 1.0.sles10.lc noarch
=Sum: Sub-Exporter - a sophisticated exporter for custom-built routines
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Sub-Install 0.925 1.0.sles10.lc noarch
=Sum: Sub-Install - install subroutines into packages easily
+Des:
This module makes it easy to install subroutines into packages without the
unslightly mess of "no strict" or typeglobs lying about where just anyone can
see them.
-Des:
##----------------------------------------
=Pkg: perl-Sub-Uplevel 0.22 1.0.sles10.lc noarch
=Sum: Sub-Uplevel - Perl module
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Task-Weaken 1.03 1.0.sles10.lc noarch
=Sum: Task-Weaken - Ensure that a platform has weaken support
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Test-Deep 0.108 1.0.sles10.lc noarch
=Sum: Test-Deep - Perl module
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Test-NoWarnings 1.01 1.0.sles10.lc noarch
=Sum: Test-NoWarnings - Make sure you didn't emit any warnings while testing
+Des:
In general, your tests shouldn't produce warnings. This modules causes any
warnings to be captured and stored. It automatically adds an extra test that
will run when your script ends to check that there were no warnings. If
there were any warings, the test will give a "not ok" and diagnostics of
where, when and what the warning was, including a stack trace of what was
going on when the it occurred.
If some of your tests are supposed to produce warnings then you should be
capturing and checking them with Test::Warn, that way Test::NoWarnings
will not see them and so not complain.
The test is run by an END block in Test::NoWarnings. It will not be run when
any forked children exit.
-Des:
##----------------------------------------
=Pkg: perl-Test-Pod-Coverage 1,08 1.0.sles10.lc noarch
=Sum: Test-Pod-Coverage - Check for pod coverage in your distribution
+Des:
Checks for POD coverage in files for your distribution.
use Test::Pod::Coverage tests=>1;
pod_coverage_ok( "Foo::Bar", "Foo::Bar is covered" );
Can also be called with Pod::Coverage parms.
use Test::Pod::Coverage tests=>1;
pod_coverage_ok(
"Foo::Bar",
{ also_private => [ qr/^[A-Z_]+$/ ], },
"Foo::Bar, with all-caps functions as privates",
);
The Pod::Coverage parms are also useful for subclasses that don't
re-document the parent class's methods. Here's an example from
Mail::SRS.
pod_coverage_ok( "Mail::SRS" ); # No exceptions
my $trustme = { trustme => [qr/^(new|parse|compile)$/] };
pod_coverage_ok( "Mail::SRS::DB", $trustme );
pod_coverage_ok( "Mail::SRS::Guarded", $trustme );
pod_coverage_ok( "Mail::SRS::Reversable", $trustme );
pod_coverage_ok( "Mail::SRS::Shortcut", $trustme );
Alternately, you could use Pod::Coverage::CountParents, which always allows
a subclass to reimplement its parents' methods without redocumenting them. For
example:
my $trustparents = { coverage_class => 'Pod::Coverage::CountParents' };
pod_coverage_ok( "IO::Handle::Frayed", $trustparents );
(The "coverage_class" parameter is not passed to the coverage class with other
parameters.)
If you want POD coverage for your module, but don't want to make
Test::Pod::Coverage a prerequisite for installing, create the following
as your t/pod-coverage.t file:
use Test::More;
eval "use Test::Pod::Coverage";
plan skip_all => "Test::Pod::Coverage required for testing pod coverage" if $@;
plan tests => 1;
pod_coverage_ok( "Pod::Master::Html");
Finally, Module authors can include the following in a t/pod-coverage.t
file and have "Test::Pod::Coverage" automatically find and check all
modules in the module distribution:
use Test::More;
eval "use Test::Pod::Coverage 1.00";
plan skip_all => "Test::Pod::Coverage 1.00 required for testing POD coverage" if $@;
all_pod_coverage_ok();
-Des:
##----------------------------------------
=Pkg: perl-Test-Tester 0.107 1.0.sles10.lc noarch
=Sum: Test-Tester - Ease testing test modules built with Test::Builder
+Des:
If you have written a test module based on Test::Builder then Test::Tester
allows you to test it with the minimum of effort.
-Des:
##----------------------------------------
=Pkg: perl-Test-Warn 0.21 1.0.sles10.lc noarch
=Sum: Test-Warn - Perl extension to test methods for warnings
+Des:
A good style of Perl programming calls for a lot of diverse regression tests.
This module provides a few convenience methods for testing warning based code.
If you are not already familiar with the Test::More manpage
now would be the time to go take a look.
-Des:
##----------------------------------------
=Pkg: perl-Text-Autoformat 1.14.0 1.0.sles10.lc noarch
=Sum: Text-Autoformat - Perl module
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Text-CSV 1.10 1.0.sles10.lc noarch
=Sum: Text-CSV - comma-separated values manipulator (using XS or PurePerl)
+Des:
Text::CSV provides facilities for the composition and decomposition of
comma-separated values using Text::CSV_XS or its pure Perl version.
An instance of the Text::CSV class can combine fields into a CSV string
and parse a CSV string into fields.
The module accepts either strings or files as input and can utilize any
user-specified characters as delimiters, separators, and escapes so it is
perhaps better called ASV (anything separated values) rather than just CSV.
-Des:
##----------------------------------------
=Pkg: perl-Text-PDF 0.29 1.0.sles10.lc noarch
=Sum: Text-PDF - PDF Manipulation and generation
+Des:
This module allows interaction with existing PDF files directly. It includes
various tools including:
pdfbklt - make booklets out of existing PDF files
pdfrevert - remove edits from a PDF file
pdfstamp - stamp text on each page of a PDF file
various example programs are also included
-Des:
##----------------------------------------
=Pkg: perl-Text-Query 0.07 1.0.sles10.lc noarch
=Sum: Text-Query - Query processing framework
+Des:
This module provides an object that matches a data source
against a query expression.
Query expressions are compiled into an internal form when a new object is created
or the "prepare" method is
called; they are not recompiled on each match.
The class provided by this module uses four packages to process the query.
The query parser parses the question and calls a query expression
builder (internal form of the question). The optimizer is then called
to reduce the complexity of the expression. The solver applies the expression
on a data source.
The following parsers are provided:
=over 4
=item Text::Query::ParseAdvanced
=item Text::Query::ParseSimple
=back
The following builders are provided:
=over 4
=item Text::Query::BuildAdvancedString
=item Text::Query::BuildSimpleString
=back
The following solver is provided:
=over 4
=item Text::Query::SolveSimpleString
=item Text::Query::SolveAdvancedString
=back
-Des:
##----------------------------------------
=Pkg: perl-Text-Reform 1.12.2 1.0.sles10.lc noarch
=Sum: Text-Reform - Perl module
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Text-Unidecode 1.30 1.0.sles10.lc noarch
=Sum: Text-Unidecode - Provide plain ASCII transliterations of Unicode text
+Des:
It often happens that you have non-Roman text data in Unicode, but
you can't display it-- usually because you're trying to
show it to a user via an application that doesn't support Unicode,
or because the fonts you need aren't accessible. You could
represent the Unicode characters as "???????" or
"\15BA\15A0\1610...", but that's nearly useless to the user who
actually wants to read what the text says.
What Text::Unidecode provides is a function, `unidecode(...)' that
takes Unicode data and tries to represent it in US-ASCII characters
(i.e., the universally displayable characters between 0x00 and
0x7F). The representation is
almost always an attempt at *transliteration*-- i.e., conveying,
in Roman letters, the pronunciation expressed by the text in
some other writing system. (See the example in the synopsis.)
NOTE:
To make sure your perldoc/Pod viewing setup for viewing this page is
working: The six-letter word "résumé" should look like "resume" with
an "/" accent on each "e".
For further tests, and help if that doesn't work, see below,
the A POD ENCODING TEST entry elsewhere in this document.
-Des:
##----------------------------------------
=Pkg: perl-Tie-IxHash-Easy 0.01 1.0.sles10.lc noarch
=Sum: Tie-IxHash-Easy - Auto-tie()s internal hashes in a tied hash
+Des:
This module automatically ties any hash reference in the tied hash to
the same class, making all of them behave like Tie::IxHash hashes.
-Des:
##----------------------------------------
=Pkg: perl-Tree 1.01 1.0.sles10.lc noarch
=Sum: Tree - Perl module
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-Tree-DAG_Node 1.06 1.0.sles10.lc noarch
=Sum: Tree-DAG_Node - (super)class for representing nodes in a tree
+Des:
This class encapsulates/makes/manipulates objects that represent nodes
in a tree structure. The tree structure is not an object itself, but
is emergent from the linkages you create between nodes. This class
provides the methods for making linkages that can be used to build up
a tree, while preventing you from ever making any kinds of linkages
which are not allowed in a tree (such as having a node be its own
mother or ancestor, or having a node have two mothers).
This is what I mean by a "tree structure", a bit redundantly stated:
* A tree is a special case of an acyclic directed graph.
* A tree is a network of nodes where there's exactly one root
node (i.e., 'the top'), and the only primary relationship between nodes
is the mother-daugher relationship.
* No node can be its own mother, or its mother's mother, etc.
* Each node in the tree has exactly one "parent" (node in the "up"
direction) -- except the root, which is parentless.
* Each node can have any number (0 to any finite number) of daughter
nodes. A given node's daughter nodes constitute an *ordered* list.
(However, you are free to consider this ordering irrelevant.
Some applications do need daughters to be ordered, so I chose to
consider this the general case.)
* A node can appear in only one tree, and only once in that tree.
Notably (notable because it doesn't follow from the two above points),
a node cannot appear twice in its mother's daughter list.
* In other words, there's an idea of up (toward the root) versus
down (away from the root), and left (i.e., toward the start (index 0)
of a given node's daughter list) versus right (toward the end of a
given node's daughter list).
Trees as described above have various applications, among them:
representing syntactic constituency, in formal linguistics;
representing contingencies in a game tree; representing abstract
syntax in the parsing of any computer language -- whether in
expression trees for programming languages, or constituency in the
parse of a markup language document. (Some of these might not use the
fact that daughters are ordered.)
(Note: B-Trees are a very special case of the above kinds of trees,
and are best treated with their own class. Check CPAN for modules
encapsulating B-Trees; or if you actually want a database, and for
some reason ended up looking here, go look at AnyDBM_File.)
Many base classes are not usable except as such -- but Tree::DAG_Node
can be used as a normal class. You can go ahead and say:
use Tree::DAG_Node;
my $root = Tree::DAG_Node->new();
$root->name("I'm the tops");
$new_daughter = Tree::DAG_Node->new();
$new_daughter->name("More");
$root->add_daughter($new_daughter);
and so on, constructing and linking objects from Tree::DAG_Node and
making useful tree structures out of them.
-Des:
##----------------------------------------
=Pkg: perl-Try-Tiny 0.28 1.0.sles10.lc noarch
=Sum: Try-Tiny - Minimal try/catch with proper preservation of $@
+Des:
None.
-Des:
##----------------------------------------
=Pkg: perl-XML-SAX 0.99 1.0.sles10.lc noarch
=Sum: XML-SAX - Simple API for XML
+Des:
XML::SAX is a SAX parser access API for Perl. It includes classes
and APIs required for implementing SAX drivers, along with a factory
class for returning any SAX parser installed on the user's system.
-Des:
##----------------------------------------
=Pkg: perl-XML-SAX-Base 1.09 1.0.sles10.lc noarch
=Sum: XML-SAX-Base - Base class for SAX Drivers and Filters
+Des:
None.
-Des:
##----------------------------------------
=Pkg: tetex-acrotex 6.05 1.0.sles10.lc noarch
=Sum: The AcroTeX eDucation Bundle used for PDF forms
+Des:
Acrotex package to support PDF forms which students can use to complete LON-CAPA homework problems offline
-Des:
##----------------------------------------
=Pkg: tetex-actuarialangle 0 1.0.sles10.lc noarch
=Sum: Actuarial angle symbol in LaTeX
+Des:
This package provides the actuarialangle symbol in LaTeX documents.
The simplest use of this package is to add
\usepackage{actuarialangle}
to your header
-Des:
##----------------------------------------
=Pkg: xdg-utils 1.0.2 85.1.0.sles10.lc noarch
=Sum: Utilities to uniformly interface desktop environments
+Des:
The xdg-utils package is a set of simple scripts that provide basic
desktop integration functions for any Free Desktop, such as Linux.
They are intended to provide a set of defacto standards. This means
that: * Third party software developers can rely on these
xdg-utils for all of their simple integration needs.
* Developers of desktop environments can make sure that their
environments are well supported
If a desktop developer wants to be certain that their environment
functions with all third party software, then can simply make sure that
these utilities work properly in their environment.
-Des:
##----------------------------------------
=Pkg: clisp 2.39 17.0.sles10.lc x86_64
=Sum: A Common Lisp Interpreter
+Des:
Common Lisp is a high-level, all-purpose programming language. CLISP is
an implementation of Common Lisp that closely follows the book "Common
Lisp - The Language" by Guy L. Steele Jr. This package includes an
interactive programming environment with an interpreter, a compiler,
and a debugger. Start this environment with the command 'clisp'.
CLISP documentation is placed in the following directories:
/usr/share/doc/packages/clisp/
/usr/share/doc/packages/clisp/doc/
As well as the conventional CLISP, this package also includes CLX, an
extension of CLISP for the X Window System. The X Window System must be
installed before running the clx command. The description of this CLX
version (new-clx) is placed in
/usr/share/doc/packages/clisp/clx/
with the file README. The subdirectory
/usr/share/doc/packages/clisp/clx/demos/
contains two nice applications.
Authors:
--------
Bruno Haible
Michael Stoll
Marcus Daniels
Gilbert Baumann
-Des:
##----------------------------------------
=Pkg: ghostscript-fonts-std 8.62 8.1 x86_64
=Sum: Standard Fonts for Ghostscript
+Des:
The necessary fonts for the PostScript interpreter Ghostscript. The
URW fonts (URW Software, Poppenbuetteler Bogen 29A, D-22399 Hamburg,
Germany).
Authors:
--------
Peter Deutsch
Martin Lottermoser
Pierre-Olivier Gaillard
Gunther Hess
Yves Arrouye
and many others
-Des:
##----------------------------------------
=Pkg: libwmf 0.2.8.4 13.1 x86_64
=Sum: library and utilities for displaying and converting metafile images
+Des:
libwmf is a library for interpreting metafile images and either displaying them
using X or converting them to standard formats such as PNG, JPEG, PS, EPS and
SVG(Z)...
-Des:
##----------------------------------------
=Pkg: perl-Crypt-SSLeay 0.51 1.0.sles10.lc x86_64
=Sum: Crypt-SSLeay - OpenSSL glue that provides LWP https support
+Des:
This perl module provides support for the https
protocol under LWP, so that a LWP::UserAgent can
make https GET & HEAD & POST requests. Please see
perldoc LWP for more information on POST requests.
The Crypt::SSLeay package contains Net::SSL,
which is automatically loaded by LWP::Protocol::https
on https requests, and provides the necessary SSL glue
for that module to work via these deprecated modules:
Crypt::SSLeay::CTX
Crypt::SSLeay::Conn
Crypt::SSLeay::X509
Work on Crypt::SSLeay has been continued only to
provide https support for the LWP - libwww perl
libraries. If you want access to the OpenSSL
API via perl, check out Sampo's Net::SSLeay.
-Des:
##----------------------------------------
=Pkg: swig 1.3.27 19.2 x86_64
=Sum: Simplified Wrapper and Interface Generator
+Des:
SWIG is a compiler that attempts to make it easy to integrate C, C++,
or Objective-C code with scripting languages including Perl, Tcl, and
Python. In a nutshell, you give it a bunch of ANSI C/C++ declarations
and it generates an interface between C and your favorite scripting
language. However, this is only scratching the surface of what SWIG
can do--some of its more advanced features include automatic
documentation generation, module and library management, extensive
customization options, and more.
Authors:
--------
Dave Beazley
-Des:
##----------------------------------------
=Pkg: te_ams 3.0 37.2 x86_64
=Sum: All about Ams-TeX
+Des:
This package provides AmS-TeX some parts of AmS-LaTeX, which is
released by the American Mathematical Society. For using AmS-TeX,
AmS-LaTeX, or their styles, install this package.
Authors:
--------
Karl Berry
Tim Morgan
Tomas Rokicki
Donald Ervin Knuth
Thomas Esser
-Des:
##----------------------------------------
=Pkg: te_latex 3.0 37.2 x86_64
=Sum: All About LaTeX
+Des:
This package provides LaTeX. To be exact, LaTeX2e, and a huge amount
software for LaTeX. This package is required by most (La)TeX
documents.
Authors:
--------
Karl Berry
Tim Morgan
Tomas Rokicki
Donald Ervin Knuth
Thomas Esser
-Des:
##----------------------------------------
=Pkg: tetex 3.0 37.2 x86_64
=Sum: The Base System of teTeX
+Des:
After installing teTeX and the package te_latex, find a large selection
of documentation for TeX, LaTeX, and various layout styles under
/usr/share/texmf/doc.
TeX (pronounced tech) is an interpreter for text formatting and was
developed by Donald E. Knuth. It works with control and macro commands
on a text file. Working with TeX is similar to typesetting methods.
LaTeX or better LaTeX2e is a complex macro package which removes the
cryptical TeX interface and does most of the work for the user.
TeX uses special fonts produced by the MetaFont program. Various
printer drivers and an X11 viewer is also included in this package. The
teTeX package is based on the standard TeX package of Karl Berry which
makes configuration much easier. It's also possible to use PostScript
fonts. A real PostScript printer is required however. If the
ghostscript (gs) package is installed, all drivers for printing and
viewing can use these fonts. Note, however, that the fonts included in
the ghostscript package are not identical to Adobe's PostScript fonts.
The copyright prohibits us from including them on the CD.
Besides these features, there are the programs MakeIndex (for producing
indexes), BibTeX (for literature data-processing), and the script
xtexsh (requires tcl/tk).
Note the differences between LaTeX2.09 and LaTeX2e. LaTeX2e can process
original LaTeX2.09 text, but style files that require LaTeX2.09
internal macros may not work correctly. Under
/usr/share/texmf/doc/latex/base/, find the documentation for LaTeX2e.
New users should review the documentation stored there.
The teTeX package from Thomas Esser includes a full texmf tree, many
programs (tex, dvips, ...), shell scripts configuration, and a big
collection of documentations. This package is simply configured by the
script texconfig and has multilanguage options.
Do not install this package together with ntex; ntex is not delivered
together with SuSE Linux.
teTeX is NOT an upgrade or update for the ntex package!!
Authors:
--------
Karl Berry
Tim Morgan
Tomas Rokicki
Donald Ervin Knuth
Thomas Esser
-Des: