Free index software for linux

SVN::Log::Index is a Perl module that can index and search over Subversion commit logs.

SYNOPSIS

my $index = SVN::Log::Index->new({ index_path => /path/to/index });

if($creating) { # Create from scratch if necessary
$index->create({ repo_url => url://for/repo });
}

$index->open(); # And then open it

# Now add revisions from the repo to the index
$index->add({ start_rev => $start_rev,
end_rev => $end_rev);

# And query the index
my $results = $index->search(query);

SVN::Log::Index builds a KinoSearch index of commit logs from a Subversion repository and allows you to do arbitrary full text searches over.

Bio::Index::Blast is a Perl module with indexes Blast reports and supports retrieval based on query accession(s).

SYNOPSIS

use strict;
use Bio::Index::Blast;
my ($indexfile,$file1, $file2);
my $index = new Bio::Index::Blast(-filename => $indexfile,
-write_flag => 1);
$index->make_index($file1, $file2);

my $id;
my $data = $index->get_stream($id);

my $bplite_report = $index->fetch_report($id);
print "query is ", $bplite_report->query, "n";
while( my $sbjct = $bplite_report->nextSbjct ) {
print $sbjct->name, "n";
while( my $hsp = $sbjct->nextHSP ) {
print "t e-value ", $hsp->P,
}
print "n";
}

This object allows one to build an index on a blast file (or files) and provide quick access to the blast report for that accession. Note: for best results use strict.

PDL::Indexing Perl module contains a tutorial on how to index piddles.

This manpage should serve as a first tutorial on the indexing and threading features of PDL.

This manpage is still in alpha development and not yet complete. "Meta" comments that point out deficiencies/omissions of this document will be surrounded by square brackets ([]), e.g. [ Hopefully I will be able to remove this paragraph at some time in the future ]. Furthermore, it is possible that there are errors in the code examples. Please report any errors to Christian Soeller (c.soeller@auckland.ac.nz).

Still to be done are (please bear with us and/or ask on the mailing list, see PDL::FAQ):

document perl level threading
threadids
update and correct description of slice
new functions in slice.pd (affine, lag, splitdim)
reworking of paragraph on explicit threading

Indexing and threading with PDL

A lot of the flexibility and power of PDL relies on the indexing and looping features of the perl extension. Indexing allows access to the data of a pdl object in a very flexible way. Threading provides efficient implicit looping functionality (since the loops are implemented as optimized C code).

Pdl objects (later often called "pdls") are perl objects that represent multidimensional arrays and operations on those. In contrast to simple perl @x style lists the array data is compactly stored in a single block of memory thus taking up a lot less memory and enabling use of fast C code to implement operations (e.g. addition, etc) on pdls.

pdls can have children

Central to many of the indexing capabilities of PDL are the relation of "parent" and "child" between pdls. Many of the indexing commands create a new pdl from an existing pdl. The new pdl is the "child" and the old one is the "parent". The data of the new pdl is defined by a transformation that specifies how to generate (compute) its data from the parents data. The relation between the child pdl and its parent are often bidirectional, meaning that changes in the childs data are propagated back to the parent. (Note: You see, we are aiming in our terminology already towards the new dataflow features. The kind of dataflow that is used by the indexing commands (about which you will learn in a minute) is always in operation, not only when you have explicitly switched on dataflow in your pdl by saying $a->doflow. For further information about data flow check the dataflow manpage.)

Another way to interpret the pdls created by our indexing commands is to view them as a kind of intelligent pointer that points back to some portion or all of its parents data. Therefore, it is not surprising that the parents data (or a portion of it) changes when manipulated through this "pointer". After these introductory remarks that hopefully prepared you for what is coming (rather than confuse you too much) we are going to dive right in and start with a description of the indexing commands and some typical examples how they might be used in PDL programs. We will further illustrate the pointer/dataflow analogies in the context of some of the examples later on.

There are two different implementations of this ``smart pointer relationship: the first one, which is a little slower but works for any transformation is simply to do the transformation forwards and backwards as necessary. The other is to consider the child piddle a ``virtual piddle, which only stores a pointer to the parent and access information so that routines which use the child piddle actually directly access the data in the parent. If the virtual piddle is given to a routine which cannot use it, PDL transparently physicalizes the virtual piddle before letting the routine use it.

Currently (1.94_01) all transformations which are ``affine, i.e. the indices of the data item in the parent piddle are determined by a linear transformation (+ constant) from the indices of the child piddle result in virtual piddles. All other indexing routines (e.g. ->index(...)) result in physical piddles. All routines compiled by PP can accept affine piddles (except those routines that pass pointers to external library functions).

Note that whether something is affine or not does not affect the semantics of what you do in any way: both

$a->index(...) .= 5;
$a->slice(...) .= 5;

change the data in $a. The affinity does, however, have a significant impact on memory usage and performance.

Extended Path Index provides an extended index type based on the Zope index type that has additional query methods that are especially suited to generating navigation trees, site maps - and also supports querying a single folder, something the standard PathIndex cant do.
Note: You normally dont need to install this separately, as it ships as a standard part of Plone 2.1 and up. This download is for people wanting to use it outside of Plone or in earlier releases of Plone.
This index supports depth limiting, and the ability to build a structure usable for navtrees and sitemaps. The actual navtree implementations are not (and should not) be in this Product, this is the index implementation only.
Main features:
- Can construct a site map with a single catalog query
- Can construct a navigation tree with a single catalog query
- Doesnt wake up any objects
- Much lower RAM consumption
- Massively improved performance
- Catalog based instead of traversal based
Works with:
- Plone 2.5.1
- Plone 2.5
- Plone 2.1.4
- Plone 2.1.3
- Plone 2.1.2
- Plone 2.1.1
- Plone 2.1
Enhancements:
- A minor release for Plone 2.5.1

Bio::Index::Swissprot is a Perl Interface for indexing (multiple) Swissprot .dat files (ie flat file swissprot format).

SYNOPSIS

# Complete code for making an index for several
# Swissprot files
use Bio::Index::Swissprot;
use strict;

my $Index_File_Name = shift;
my $inx = Bio::Index::Swissprot->new(-filename => $Index_File_Name,
-write_flag => WRITE);
$inx->make_index(@ARGV);

# Print out several sequences present in the index
# in gcg format
use Bio::Index::Swissprot;
use Bio::SeqIO;
use strict;

my $out = Bio::SeqIO->new( -format => gcg, -fh => *STDOUT );
my $Index_File_Name = shift;
my $inx = Bio::Index::Swissprot->new(-filename => $Index_File_Name);

foreach my $id (@ARGV) {
my $seq = $inx->fetch($id); # Returns Bio::Seq object
$out->write_seq($seq);
}

# alternatively
my ($id, $acc);
my $seq1 = $inx->get_Seq_by_id($id);
my $seq2 = $inx->get_Seq_by_acc($acc);

Inherits functions for managing dbm files from Bio::Index::Abstract.pm, and provides the basic funtionallity for indexing Swissprot files, and retrieving the sequence from them. Heavily snaffled from James Gilberts Fasta system. Note: for best results use strict.

Details on configuration and additional example code are available in the biodatabases.pod file.

JSAN::Index::Library is a JavaScript Archive Network (JSAN) Software Library.

This class provides objects for the various libraries (software components) in the JSAN.

METHODS

In addition to the general methods provided by Class::DBI, it has the following methods

name

The name accessor returns the name (possibly including the use of pseudo-namespaces) of the library. e.g. "Test.Simple.Container.Browser"

release

The release method returns the JSAN::Index::Release object for the release that the library is defined in.

version

The version accessor returns the version of the library.

doc

The doc accessor returns the root-relative location of the documentation for this library on the http://openjsan.org/ website.

distribution

The distribution method is a shortcut for $library->release->distribution and returns the JSAN::Index::Distribution for the distribution that this library is of.

extract_libs to => $path

The extract_libs method will extract the libraries for a release (i.e. the contents of the lib directory> to the local filesystem.

It takes named parameters to control its behaviour.

to

The to parameter specifies the destination for the files to be extracted to. When passed as a single string, this is taken to be a directory on the local host.

No other destination options other than the local filesystem are available at this time, but more destination options are expected at a later date.

Returns the number of files extracted, or dies on error.

extract_tests to => $path

The extract_tests method will extract the test scripts for a release (i.e. the contents of the tests directory> to the local filesystem.

Returns the number of files extracted, or dies on error.

Contentment::Index is a Perl module that provides categorization and indexing features.

SYNOPSIS

# Get a list of the available indexes
my @indexes = Contentment::Index->indexes;

for my $index (@indexes) {

# Get a list of avilable terms
my @terms = $index->terms;

for my $term (@terms) {

# Get a list of generators
my @generators = $index->generators;

}

}

One frequently controversial component of a CMS is the categorization system. Contentment attempts to avoid this problem by providing a framework for building categorization systems so that any controversy just leads to the replacement of whatever system someone doesnt like.

That is, rather than create some all encompassing categorization system or some dead-simple one that your grandma who thinks the boogey-man is going to jump out of the her CD-ROM drive can use, you can have either or both or neither depending upon your need. Thus, instead of providing a category or taxonomy system, Contentment provides the indexing system, which allows you to implement whatever category system you prefer.