Free semantic relatedness software for linux

Mantissa is a collection of various mathematical tools aimed towards for simulation.
Mantissa contains a collection of algorithms, among which:
a small set of linear algebra classes
a least squares estimator
some curve fitting classes
several ordinary differentials equations integrators, either with fixed steps or adaptive stepsize control (see below)
vectors and rotations in a three dimensional space
algebra-related classes like rational and double polynomials
various orthogonal polynomials:
Chebyshev
Hermite
Laguerre
Legendre
some random numbers and vectors generation classes:
Robert M. Ziff four tap shift register (contributed by Bill Maier)
Makoto Matsumoto and Takuji Nishimura Mersenne twister
generators for vectors with correlated components
some basic (min, max, mean, standard deviation) statistical analysis classes
some optimization algorithms using direct search methods:
the Nelder-Mead simplex method
Virginia Torczons multi-directional method
Enhancements:
- For many basic objects provided by Mantissa like Vector3D, Rotation, and the various Polynomial classes, instances are now guaranteed to be immutable.
- This greatly simplifies safe sharing of instances without forcing users to either put severe restrictions on their use of Mantissa classes or make numerous copies just to make sure everything is safe.
- Since the change is a semantic change on the contract of the classes, this version introduces some incompatibilities with respect to previous ones.
- Upgrading to this version is not difficult, though.

WordNet::SenseRelate::AllWords is a Perl module to perform Word Sense Disambiguation.

SYNOPSIS

use WordNet::SenseRelate::AllWords;
use WordNet::QueryData;
my $qd = WordNet::QueryData->new;
my $wsd = WordNet::SenseRelate::AllWords->new (wordnet => $qd,
measure => WordNet::Similarity::lesk);
my @results = $wsd->disambiguate ();

WordNet::SenseRelate::AllWords implements an algorithm for Word Sense Disambiguation that uses measures of semantic relatedness. The algorithm is an extension of an algorithm described by Pedersen, Banerjee, and Patwardhan[1]. This implementation is similar to the original SenseRelate package but disambiguates every word in the given context rather than just single word.

OpenBerg Reader is an open-standards-based, multi-platform eBook reader.
The objective of the OpenBerg project is to design and implement open-source tools for the creation, edition and usage of open-standard eBooks.
We are currently developing the OpenBerg reader, an advanced eBook reader based on Mozilla technologies. This reader will allow, among other features, rich eBook contents, semantical find facilities and reader annotations, in a multi-language environment.
This program is developed Linux and Windows, using cross-platform technologies available for Linux, Windows, MacOS X, OpenBSD, FreeBSD... If you wish to contribute or donate, do not hesitate to contact us. We need developers and beta-testers on all these platforms, as well as package, website and documentation maintainers. Soon, hopefully, we will also need help with translation. Last but not least, we need help to spread the word.
Enhancements:
- This release is the first in a new generation of OpenBerg Reader / Lector.
- It enriches Firefox with the ability to read several formats of e-Books, while using all the usual features of Firefox, including printing, bookmarking, following hyperlinks, zooming in or out, copying or exporting parts of the book, etc.
- With the right (existing) Firefox extensions, you can even take yellow-sticker-notes on e-Books, add and share comments on chapters, have your book read out to you, etc.

WebService::GoogleHack::Rate is a Perl module that implements a simple relatedness measure and semantic orientation related type functions.

SYNOPSIS

use WebService::GoogleHack::Rate;

#GIVE PATH TO INPUT FILE HERE

my $INPUTFILE="";

#GIVE PATH TO TRACE FILE HERE

my $TRACEFILE="";

#create an object of type Rate

my $rate = WebService::GoogleHack::Rate->new();

$results=$rate->measureSemanticRelatedness1("dog", "cat");

#The PMI measure is stored in the variable $results, and it can also
#be accessed as $rate->{PMI};

$results=$rate->predictSemanticOrientation($INPUTFILE, "excellent", "bad",$TRACEFILE);

#The resutls can be accessed through
print $results->{prediction}."n";
$results->{PMI Measure}."n";
$rate->{prediction} &."n";
$rate->{PMI Measure}."n";

WebService::GoogleHack::Rate - This package uses Google to do some basic natural language processing. For example, given two words, say "knife" and "cut", the module has the ability to retrieve a semantic relatedness measure, commonly known as the PMI (Pointwise mututal information) measure. The larger the measure the more related the words are. The package can also predict the semantic orientation of a given paragraph of english text. A positive measure means that the paragraph has a positive meaning, and negative measure means the opposite.

Marathon project is a testing framework for GUI applications developed using Java/Swing. Marathon composes of recorder, runner and editor. The testscripts are composed of python code.

Marathon focuses on end-user testing. One need not know Java or Swing to record test scripts using Marathon. Marthon is kept intentionally simple. The aim to produce test scripts that are readable by everyone on the project. This includes the developers, testers and the customers. Marathon is flexible and provides facilities to extend the functionality available through python scripts or through writing ones own component resolvers.

Marathon captures the semantic actions on components instead of the mouse & keyboard events. This results in scripts that are simple and at a higher granular level. Marathon suites well for applications that mostly depend on forms-paradigm.

WebService::GoogleHack is a Perl package that ties together all GoogleHack modules (Webservice::GoogleHack::Search, Webservice::GoogleHack::Spelling, Webservice::GoogleHack::Rate, and Webservice::GoogleHack::Text) to implement Natural Language Processing techniques that use the World Wide Web as a source of information. Use this package to access all the functionality of GoogleHack.
SYNOPSIS
use WebService::GoogleHack;
my $google = new WebService::GoogleHack;
#Initializing the object to the contents of the configuration file
# API Key, GoogleSearch.wsdl file location.
$google->initConfig("initconfig.txt");
#Printing the contents of the configuration file
$google->printConfig();
#Measure the semantic relatedness between the words "white house" and
#"president".
$measure=$google->measureSemanticRelatedness1("white house","president");
print "nRelatedness measure between white house and president is: ";
print $measure."n";
#Going to search for words that are related to "toyota" and "ford"
my @terms=();
push(@terms,"toyota");
push(@terms,"ford");
#The parameters are the search terms, number of web page results to look
#at, the number of iterations,output file and the "true" indicates that the
#diagnostic data should be stored in the file "results.txt"
$results=$google->Algorithm1(@terms,10,25,1,"results.txt","true");
print $results;
WebService::GoogleHack is a PERL package that interacts with the Google API, and implements basic functions that allow the user to interact with Google and retrieve results in an easy to use format. GoogleHack also implements and extends a number of Natural Language Processing by using the World Wide Web as a source of information.
Main features:
- Issue queries to Google (WebService::GoogleHack, WebService::GoogleHack::Search)
- Retrieve Spelling suggestions from Google (WebService::GoogleHack, WebService::GoogleHack::Spelling)
- Find the Pointwise Mututal Information (PMI) measure between two words (WebService::GoogleHack,WebService::GoogleHack::Rate)
- Given a paragraph find if the paragraph has a positive or negative semantic orientation.(WebService::GoogleHack,WebService::GoogleHack::Rate)
- Given a set of words along with a positively oriented word such as "excellent" and a negatively oriented word such as "poor", find if the word has a positive or negative semantic orientation.(WebService::GoogleHack,WebService::GoogleHack::Rate)
- Given a set of phrases along with a positively oriented word such as "excellent" and a negatively oriented word such as "poor", predict if the given phrases are positive or negative in sentiment.(WebService::GoogleHack,WebService::GoogleHack::Rate)
- Given two or more words finds a set of related words. (WebService::GoogleHack)

AdaControl is a free (GMGPL) tool that detects the use of various kinds of constructs in Ada programs. AdaControls first goal is to control proper usage of style or programming rules, but it can also be used as a powerful tool to search for use (or non-use) of various forms of programming styles or design patterns. Searched elements range from very simple, like the occurrence of certaine entities, declarations, or statements, to very sophisticated, like verifying that certain programming patterns are being obeyed..
Which elements or constructs are searched is defined by a set of rules; the following table gives a short summary of rules currently checked by AdaControl. The number in parentheses after the rule name gives the number of subrules, if any. Considering all possible rules and subrules, this makes 216 tests that can be performed currently by AdaControl!
- Abnormal_Function_Return Controls a design pattern that ensures that a function always returns a result .
- Allocators Controls ocurrences of allocators, either all of them, or those targeting specified types.
- Array_Declarations (x2) Controls several metrics in array declarations.
- Barrier_Expressions Controls elements allowed in the expression of protected entries barriers
- Case_Statement (x4) Controls several metrics in case statements.
- Control_Characters Controls occurrences of control characters (like tabs) in the source.
- Declarations (x75) Controls occurrences of certain Ada declarations.
- Default_Parameter Controls subprogram calls and generic instantiations that use (or not) the default value for a given parameter.
- Directly_Accessed_Globals Controls a design pattern that ensures that all global variables are accessed only through dedicated subprograms.
- Entities Controls occurrences of any Ada entity.
- Entity_Inside_Exception Controls occurrences of entities inside exception handlers.
- Exception_Propagation (x4) Controls that certain subprograms (or tasks) cannot propagate exceptions, or that no elaboration can propagate exceptions.
- Expressions (x9) Controls usage of certain forms of expressions
- Global_References Controls unsynchronized accesses to global variables.
- Header_Comments (x2) Controls the presence of comments at the start of each module.
- If_For_Case Controls if statements that could be replaced by case statements.
- Instantiations Controls generic instantiations, either all of them, or those that use specified entities.
- Insufficient_Parameters Controls the use of positional parameters in calls where the value does not provide sufficient information.
- Local_Hiding Controls occurrences of local identifiers that hide an identical outer one.
- Local_Instantiation Controls instantiations in local scopes.
- Max_Blank_Lines Controls the occurrence of more than a specified number of consecutive empty lines.
- Max_Call_Depth Controls the maximum depth of subprogram calls.
- Max_Line_Length Controls maximal length of source lines.
- Max_Nesting Controls scopes nested more deeply than a given limit.
- Max_Parameters (x6) Controls the maximum numbers of parameters in callable entities (procedures, functions and entries)
- Max_Statement_Nesting (x5) Controls composite statements nested more deeply than a given limit.
- Movable_Accept_Statements Controls statements that could be moved outside an accept statement.
- Naming_Convention Controls the form of allowed (or forbidden) names in declarations.
- No_Safe_Initialization Controls a design pattern that ensures that any variable is initialized before being used.
- Non_Static (x3) Controls non static expressions in index or discriminant constraints, or in instantiations.
- Not_Elaboration_Calls Controls subprogram calls performed from places outside package elaboration code.
- Other_Dependencies Controls semantic dependencies to other units than those indicated
- Parameter_Aliasing Controls subprograms and entry calls where a variable is provided to more than one [in] out parameter.
- Potentially_Blocking_Operations Controls the use of potentially blocking operations from within protected operations.
- Pragmas Controls the use of specific pragmas.
- Real_Operators Controls occurrences of = or /= operators on real types.
- Reduceable_Scope Controls declarations that could be move to more deeply nested scopes.
- Representation_Clauses Controls occurrences of representation clauses.
- Return_Type Controls the use of certain kinds of types as return types of functions.
- Side_Effect_Parameters Controls subprogram calls and generic instantiations that call functions with side effect, thus creating a dependance to the order of evaluation.
- Silent_Exceptions Controls exception handlers that do not reraise exceptions nor call indicated subprograms.
- Simplifiable_Expressions (x4) Controls occurrences of various forms of expressions that could be simplified.
- Special_Comments Controls the presence of certain string patterns in comments.
- Statements (x42) Controls occurrences of Ada statements.
- Style (x12) Controls various forms of constructs generally recommended in style rules.
- Terminating_Tasks Controls a design pattern that ensures that tasks never terminate.
- Uncheckable (x3) Controls constructs that are not statically checkable by other rules
- Unnecessary_Use_Clause Controls use clauses on packages, where no element of the package is referred to within the scope of the use clause.
- Unsafe_Paired_Calls Controls a design pattern that ensures that certain calls are allways paired (like P/V procedures).
- Unsafe_Unchecked_Conversion Controls instantiations of Unchecked_Conversion between types of different or unspecified sizes.
- Usage (x5) Controls usage of objects under certain conditions (in package specifications, read, written modified...).
- Use_Clauses Controls occurrences of use clauses, except for indicated packages.
- With_Clauses (x3) Controls proper usage of with clauses.
Enhancements:
- This release adds rules to check that header comments match a given pattern.
- It has indication of possible false positives and false negatives due to non-statically analyzable constructs.
- There is a fine definition of constructs allowed in entry barriers (including the one of the Ravenscar profile).
- There is better integration into GPS, and much more.

KeyNote is a simple and flexible trust-management system designed to work well for applications.

Trust management, introduced in the PolicyMaker system [BFL96], is a unified approach to specifying and interpreting security policies, credentials, and relationships; it allows direct authorization of security-critical actions. A trust-management system provides standard, general-purpose mechanisms for specifying application security policies and credentials. Trust-management credentials describe a specific delegation of trust and subsume the role of public key certificates; unlike traditional certificates, which bind keys to names, credentials can bind keys directly to the authorization to perform specific tasks.

A language for describing `actions, which are operations with security consequences that are to be controlled by the system.
A mechanism for identifying `principals, which are entities that can be authorized to perform actions.
A language for specifying application `policies, which govern the actions that principals are authorized to perform.
A language for specifying `credentials, which allow principals to delegate authorization to other principals.
A `compliance checker, which provides a service to applications for determining how an action requested by principals should be handled, given a policy and a set of credentials.

The trust-management approach has a number of advantages over other mechanisms for specifying and controlling authorization, especially when security policy is distributed over a network or is otherwise decentralized.

Trust management unifies the notions of security policy, credentials, access control, and authorization. An application that uses a trust- management system can simply ask the compliance checker whether a requested action should be allowed. Furthermore, policies and credentials are written in standard languages that are shared by all trust-managed applications; the security configuration mechanism for one application carries exactly the same syntactic and semantic structure as that of another, even when the semantics of the applications themselves are quite different.

Trust-management policies are easy to distribute across networks, helping to avoid the need for application-specific distributed policy configuration mechanisms, access control lists, and certificate parsers and interpreters.

For a general discussion of the use of trust management in distributed system security, see [Bla99].

KeyNote is a simple and flexible trust-management system designed to work well for a variety of large- and small- scale Internet-based applications. It provides a single, unified language for both local policies and credentials. KeyNote policies and credentials, called `assertions, contain predicates that describe the trusted actions permitted by the holders of specific public keys. KeyNote assertions are essentially small, highly-structured programs. A signed assertion, which can be sent over an untrusted network, is also called a `credential assertion. Credential assertions, which also serve the role of certificates, have the same syntax as policy assertions but are also signed by the principal delegating the trust.

In KeyNote:

Actions are specified as a collection of name-value pairs.
Principal names can be any convenient string and can directly represent cryptographic public keys.
The same language is used for both policies and credentials.
The policy and credential language is concise, highly expressive, human readable and writable, and compatible with a variety of storage and transmission media, including electronic mail.
The compliance checker returns an application-configured `policy compliance value that describes how a request should be handled by the application. Policy compliance values are always positively derived from policy and credentials, facilitating analysis of KeyNote-based systems.
Compliance checking is efficient enough for high-performance and real-time applications.

This document describes the KeyNote policy and credential assertion language, the structure of KeyNote action descriptions, and the KeyNote model of computation.