Free semantic 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.

Emacspeak is a speech interface that allows visually impaired users to interact independently and efficiently with the computer.

Audio formatting --a technique pioneered by AsTeR-- and full support for W3Cs Aural CSS (ACSS) allows Emacspeak to produce rich aural presentations of electronic information. By seamlessly blending all aspects of the Internet such as Web-surfing and messaging, Emacspeak speech-enables local and remote information via a consistent and well-integrated user interface.

Available free of cost on the Internet, Emacspeak has dramatically changed how the author and hundreds of blind and visually impaired users around the can interact with the their computer and the Internet. A rich suite of task-oriented tools provides efficient speech-enabled access to the audio desktop and evolving semantic WWW. When combined with Linux running on low-cost PC hardware, Emacspeak/Linux provides a reliable, stable speech-friendly solution that opens up the Internet to visually impaired users around the world.

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.

Search::ContextGraph is a Perl module for spreading activation search engine.

SYNOPSIS

use Search::ContextGraph;

my $cg = Search::ContextGraph->new();

# first you add some documents, perhaps all at once...

my %docs = (
first => [ elephant, snake ],
second => [ camel, pony ],
third => { snake => 2, constrictor => 1 },
);

$cg->bulk_add( %docs );

# or in a loop...

foreach my $title ( keys %docs ) {
$cg->add( $title, $docs{$title} );
}

# or from a file...

my $cg = Search::ContextGraph->load_from_dir( "./myfiles" );

# you can store a graph object for later use

$cg->store( "stored.cng" );

# and retrieve it later...

my $cg = ContextGraph->retrieve( "stored.cng" );


# SEARCHING

# the easiest way

my @ranked_docs = $cg->simple_search( peanuts );


# get back both related terms and docs for more power

my ( $docs, $words ) = $cg->search(snake);


# you can use a document as your query

my ( $docs, $words ) = $cg->find_similar(First Document);


# Or you can query on a combination of things

my ( $docs, $words ) =
$cg->mixed_search( { docs => [ First Document ],
terms => [ snake, pony ]
);


# Print out result set of returned documents
foreach my $k ( sort { $docs->{$b} $docs->{$a} }
keys %{ $docs } ) {
print "Document $k had relevance ", $docs->{$k}, "n";
}

# Reload it
my $new = Search::ContextGraph->retrieve( "filename" );

Spreading activation is a neat technique for building search engines that return accurate results for a query even when there is no exact keyword match. The engine works by building a data structure called a context graph, which is a giant network of document and term nodes. All document nodes are connected to the terms that occur in that document; similarly, every term node is connected to all of the document nodes that term occurs in. We search the graph by starting at a query node and distributing a set amount of energy to its neighbor nodes. Then we recurse, diminishing the energy at each stage, until this spreading energy falls below a given threshold. Each node keeps track of accumulated energy, and this serves as our measure of relevance.

This means that documents that have many words in common will appear similar to the search engine. Likewise, words that occur together in many documents will be perceived as semantically related. Especially with larger, coherent document collections, the search engine can be quite effective at recognizing synonyms and finding useful relationships between documents. You can read a full description of the algorithm at http://www.nitle.org/papers/Contextual_Network_Graphs.pdf.

The search engine gives expanded recall (relevant results even when there is no keyword match) without incurring the kind of computational and patent issues posed by latent semantic indexing (LSI). The technique used here was originally described in a 1981 dissertation by Scott Preece.

Emacs Configuration Framework is a versatile configuration package for Emacs. It is meant for users whose Emacs configuration has become so complex that it appears to be unmanageable.
It enables you to write and load the configuration for individual Emacs packages in pieces. You can use it to setup some autoloads for a package when you start Emacs and then do extra configuration after the package has loaded.
This speeds up your Emacs startup without compromising your ability to do complicated things.
Enhancements:
- This release adds a new rc.d/lang directory.
- Modes added: speedbar, semantic, cedet, and ecb.

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.

BuddySpace is an instant messenger with four novel twists: (1) it allows optional maps for geographical & office-plan visualizations in addition to standard buddy lists; (2) it is built on open source Jabber, which makes it interoperable with ICQ, MSN, Yahoo and others; (3) it is implemented in Java, so it is cross-platform; (4) it is built by a UK research lab, so it is 100% free with full sources readiily available. But BuddySpace is about more than just messaging, as we explain below.

One of the key factors that led to the widespread popularity of Instant Messaging applications from 1997 onwards (including ICQ, AOL, Yahoo!, MSN, Odigo, and Jabber messengers) was the concept of pushed presence: the automatic notification of the appearance of friends and colleagues online.

However, Instant Messaging (IM) is just one of many possible presence-related and presence-dependent applications. For example, presence-enabled applications can facilitate safety-tracking of children by mobile phone, support for emergency services, blind-date radar, group teleconference management, multiplayer games, and anything involving the collaboration of individuals separated in space and time.

Why phone a contact only to receive an engaged tone or pre-recorded message, when the telephone network already knows what state your contact is in, and could indicate this directly on your contact list? All of these concepts embody varying degrees of what we refer to as enhanced presence management.

The concept of presence has matured in recent years to move away from the simple notion of online/offline/away, towards a rich blend of attributes that can be used to characterise an individuals physical and/or spatial location, work trajectory, time frame of reference, mental mood, goals, and even intentions! Our challenge is how best to characterise presence, how to make it easy to manage and easy to visualise, and how to remain consistent with the users own expectations, work habits, and existing patterns of Instant Messaging and other communication tool usage.

BuddySpace generalizes the concept of Buddy List (popularised by Instant Messaging tools such as AOL Instant Messenger, ICQ, MSN Messenger, and Yahoo Messenger) to provide multiple views of collaborative workgroups according to users needs and tastes. Our aim has been to provide a personal dashboard or radar screen so that one can observe the availability and interaction state of colleagues worldwide in a manner that exhibits the following desirable properties:

* immediate: real-time updates need to be pushed instantly to users rather than pulled in by request -- the push approach helps keep updates more palpable and informative
* peripheral and therefore non-intrusive: users lead busy lives, and dislike being bombarded with yet more information, so we aim to keep awareness of colleagues available in a compact manner that can be noticed peripherally
* customisable: some people prefer simple or hierarchical lists, some prefer visual maps, some prefer status lights, and so on; some prefer a Windows look-and-feel, some a Mac-- we need to cater for diverse user preferences and capabilities
* scaleable: we have to provide ways to indicate the presence of potentially enormous numbers of people, even given that these numbers will be filtered down for personal use -- researchers inhabit workspaces with many hundreds of colleagues around the globe; the Open University has well over 150,000 students online; large peer-spaces like music swapping communities have many millions of users connected simultaneously
* interoperable: with several hundred million users of the Big Four (AIM/ICQ/MSN/Yahoo!), it is crucial that any approach allow interopebility with systems to which our users already subscribe; this is one of the many reasons we built BuddySpace entirely on top of Jabber (www.jabber.org), which provides gateways to the Big Four products.
* cross-platform: we need to service a community not only on Windows, Unix/Linux, and Mac desktop and notebook configurations, but also on PDAs and mobile phones -- we therefore develop entirely in Java
* XML-literate: for future intelligent applications, communication transport needs to be about more than just string-transmission; another we adopted Jabber is that it is based entirely on a generic XML transport architecture, ideally suited for this purpose.
* open source: for the research community to join us and to gain leverage via our research output, we have ensured that BuddySpace is open source, available on SourceForge.
* clean: BuddySpace adheres rigorously to the Jabber specification, which means that it interoperates with other Jabber clients and servers without danger of the rogue behaviour that non-standard implementations inadvertently allow (e.g. the semantics of users inhabiting multiple groups is undefined in some clients, and can cause crashes).
* extendable: BuddySpace deploys a plug-in architecture which means that additions, such as new visualizations, and new concepts such as gaming interfaces, are readily achievable

BuddySpace fulfills all the above criteria, and provides a compelling user interface that can be highly compact, yet provide users with an important feel-good factor, akin to seeing nearby office lights turned on when entering ones office building at night. By studying the semantics of presence, we can also augment the existing impoverished presence states in a principles manner, providing capabilities that are more representative of the way real users work. Forthcoming capabilities will include automatic location updates via mobile devices, and the use of semantic matchmaking via intelligent profile handling, in order to help users quickly find and filter colleagues of particular interest.