Free wordnet similarity 1.04 software for linux

WordNet::Similarity::PathFinder is a Perl module to implement path finding methods (by node counting) for WordNet::Similarity measures of semantic relatedness.

SYNOPSIS

use WordNet::QueryData;

my $wn = WordNet::QueryData->new;

use WordNet::Similarity::PathFinder;

my $obj = WordNet::Similarity::PathFinder->new ($wn);

my $result = $obj->parseWps($wps1, $wps2);

my @paths = $obj->getShortestPath("dog#n#1", "cat#n#1", "n", "wps");

my ($length, $path) = @{shift @paths};

defined $path or die "No path between synsets";

my @paths = $obj->getAllPaths("worship#v#1", "adore#v#1", "v", "wps");

my ($length, $path) = @{shift @paths};

defined $path or die "No path between synsets";

my @paths = $obj->getShortestPath("02895418", "02724985", "n", "offset");

my ($length, $path) = @{shift @paths};

defined $path or die "No path between synsets";

Introduction

This class is derived from (i.e., is a sub-class of) WordNet::Similarity.

The methods in this module are useful for finding paths between concepts in WordNets is-a taxonomies. Concept A is-a concept B if, and only if, B is a hypernym of A or A is in the hypernym tree of B. N.B., only nouns and verbs have hypernyms.

The methods that find path lengths (such as getShortestPath() and getAllPaths() compute the lengths using node-counting not edge-counting. In general, the length of a path using node-counting will always be one more than the length using edge-counting. For example, if concept A is a hyponym of concept B, then the path length between A and B using node-counting is 2, but the length using edge-counting is 1. Likewise, the path between A and A is 1 using node-counting and 0 using edge-counting.

xmlformat is a configurable formatter (or "pretty-printer") for XML documents. xmlformat gives the user control over indentation, line-breaking, and text wrapping. These properties can be defined on a per-element basis.
Enhancements:
- Each token is now assigned an input line number, which is displayed in error messages.
- This provides better information to the user about the location of problems in input files.
- The token stack is now printed when an error occurs.
- This provides some idea of the context of the element that is malformed or has malformed content.

Mailing List project is a Web-based, full-featured mailing list and newsletter system. Users can subscribe and unsubscribe themselves.
Email confirmation is used for new subscriptions. The list of subscribers to a list can be imported and exported.
Installation:
- copy all files to your web host
- use phpmyadmin or your mysql interface to run site.sql against your database.
- open site.xml and edit the database section with your database details.
- go to index.php and login with username of admin with a password of test.
Setup the site.xml file with your database settings as follows.
< database type="mysql" >
< server >database server address< /server >
< login >database login< /login >
< password >database password< /password >
< default >mysql database name< /default >
< /database >
Add this to your ".htaccess" file to prevent viewing of the xml config file.
< Files ~ ".xml" >
Order allow,deny
Deny from all
Satisfy All
< /Files >
Enhancements:
- A problem with the SQL setup file which caused the setup to fail on some systems was fixed.

Religion is a Perl module that can generate tracebacks and create and install die() and warn() handlers.

This is a second go at a module to simplify installing die() and warn() handlers, and to make such handlers easier to write and control.

For most people, this just means that if use use Religion; then youll get noticably better error reporting from warn() and die(). This is especially useful if you are using eval().

Religion provides four classes, WarnHandler, DieHandler, WarnPreHandler, and DiePreHandler, that when you construct them return closures that can be stored in variables that in turn get invoked by $SIG{__DIE__} and $SIG{__WARN__}. Note that if Religion is in use, you should not modify $SIG{__DIE__} or $SIG{__WARN__}, unless you are careful about invoking chaining to the old handler.

Religion also provides a TraceBack function, which is used by a DieHandler after you die() to give a better handle on the current scope of your situation, and provide information about where you were, which might influence where you want to go next, either returning back to where you were, or going on to the very last. [Sorry - Ed.]

See below for usage and examples.

USAGE

DieHandler SUB

Invoke like this:

$Die::Handler = new DieHandler sub {
#...
};

where #... contains your handler code. Your handler will receive the following arguments:

$message, $full_message, $level, $eval,
$iline, $ifile, $oline, $ofile, $oscope

$message is the message provided to die(). Note that the default addition of " at FILE line LINE.n" will have been stripped off if it was present. If you want to add such a message back on, feel free to do so with $iline and $ifile.

$full_message) is the message with a scope message added on if there was no newline at the end of $message. Currently, this is not the original message that die() tacked on, but something along the lines of " at line 3 of the eval at line 4 of Foo.pln".

$eval is non-zero if the die() was invoked inside an eval.

The rest of the arguments are explained in the source for Religion::TraceBack. Yes, I need to document these, but not just now, for they are a pain to explain.
Whenever you install a DieHandler, it will automatically store the current value of $Die::Handler so it can chain to it. If you want to install a handler only temporarily, use local().

If your handler returns data using return or by falling off the end, then the items returns will be used to fill back in the argument list, and the next handler in the chain, if any, will be invoked. Dont fall off the end if you dont want to change the error message.

If your handler exits using last, then no further handlers will be invoked, and the program will die immediatly.

If your handler exits using next, then the next handler in the chain will be invoked directly, without giving you a chance to change its arguments as you could if you used return.

If your handler invokes die(), then die() will proceed as if no handlers were installed. If you are inside an eval, then it will exit to the scope enclosing the eval, otherwise it will exit the program.

WarnHandler SUB

Invoke like this:

$Warn::Handler = new WarnHandler sub {
#...
};

For the rest of its explanation, see DieHandler, and subsitute warn() for die(). Note that once the last DieHandler completes (or last is invoked) then execution will return to the code that invoked warn().

DiePreHandler SUB

Invoke like this:

$Die::PreHandler = new DiePreHandler sub {
#...
};

This works identically to $Die::Handler, except that it forms a separate chain that is invoked before the DieHandler chain. Since you can use last to abort all the handlers and die immediately, or change the messages or scope details, this can be useful for modifying data that all future handlers will see, or to dispose of some messages from further handling.

This is even more useful in $Warn::PreHandler, since you can just throw away warnings that you know arent needed.

WarnPreHandler SUB

Invoke like this:

$Warn::PreHandler = new WarnPreHandler sub {
#...
};

This works identically to $Warn::Handler, except that it forms a separate chain that is invoked before the WarnHandler chain. Since you can use last to abort all the handlers and return to the program, or change the messages or scope details, this can be useful for modifying data that all future handlers will see, or to dispose of some messages.

This is very useful, since you can just throw away warnings that you know arent needed.

Resources is a Perl module to handle application defaults in Perl.

SYNOPSIS

use Resources;

$res = new Resources;
$res = new Resources "resfile";

Resources are a way to specify information of interest to program or packages.
Applications use resource files to specify and document the values of quantities or attributes of interest.

Resources can be loaded from or saved to resource files. Methods are provided to search, modify and create resources.

Packages use resources to hardwire in their code the default values for their attributes, along with documentation for the attibutes themselves.

Packages inherit resources when subclassed, and the resource names are updated dynamically to reflect a class hierarchy.

TEKlib is a games operating system and cross-development SDK for games.

TEKlib is an open-source library and operating system effort under the terms of the free MIT software license. This project has a many of facets; it is a

virtual operating system that runs hosted on platforms such as Linux, Windows, BSD and MorphOS,
freestanding operating system on architectures such as the Playstation 2, where it runs on a thin layer of ROM calls,
middleware providing a constistent interface across all hosting environments,
component library in that it is not strictly limited to OS services,
development platform that comes with a cross-platform build system and documentation tools.

TEKlib was started around the year 1999 out of frustration from the ended lifecycle of the AmigaOS and the lack of a worthy successor for its most basic principle, excellence by simplicity. Today, TEKlib is a virtual operating system, distributed over a set of portable libraries. You can use it as your sole environment on the Playstation 2 (provided that you are hardcore enough); most people however will use it as a development platform under Linux or Windows.

By picking from its facilities, it can serve as

a games operating system and cross-development SDK for games and everything multimedia,
a hosting environment for libraries that depend on non-trivial features like plugins and threads, striving for portability and durability,
a virtual OS target as a backend for applications that would have to be ported to many individual hosts,
a toolkit to provide an extensible virtual filesystem,
an ubiquitous component architecture that allows plugins and their host to compile from the same source on all platforms,
a small and powerful replacement for standard C libraries in embedded applications.

TEKlib is both an architecture and component library. In short, it can be embedded into any kind of library and application, and conversely, any kind of library and application can be based on TEKlib.