Free reliably thesaurus software for linux

Thesaurus is a Perl module that maintains lists of associated items.

SYNOPSIS

use Thesaurus;

my $th = Thesaurus->new( -files => [ file1, file2 ],
-ignore_case => 1 );

@words = $th->find(vegan);

%words = $th->find( Faye );

foreach $word ( @{ $words{Faye} } )
{
#something ...
}

$th->add_file( file1, file2 );

$th->add( [ tofu, mock duck ] );

$th->delete( meat, vivisection );

Thesaurus is a module that allows you to create lists of related things. It was created in order to facilitate searches of a database of Chinese names in Anglicized form. Because there are various schemes to create phonetic representations of Chinese words, the following can all represent the same Chinese character:

Woo
Wu
Ng

Thesaurus can be used for anything that fits into a scalar by using the new method with no parameters and then calling the add method to add data.
Thesaurus also acts as the parent class to several child classes which implement various forms of persistence for the data structure. This module can be used on its own to instantiate an object that lives for the life of its scope.

Easymacs is an easy-to-learn, one-size-fits-all configuration for new users of GNU Emacs. The project sets up key bindings that conform to a common denominator of the Gnome/KDE/OS X/Microsoft Windows human interface guidelines, and provides function-key bindings for other powerful Emacs features.
It is fully documented, and the new user can productively edit text right away, without going through the Emacs tutorial. Many commonly-used functions can be accessed without having to learn the "chords" or multiple keystrokes that Emacs uses by default.
Humanists:
Easymacs was designed with the non-programmer in mind, someone who would like to use Emacs to edit mainly text files, especially LaTeX and TEI-conforming XML. Since many aspects of the configuration of Emacs require a certain knowledge of programming, this sort of person might find the default behavior of Emacs too foreign and too hard to reconfigure.
Programmers:
On the other hand, Easymacs is also a great environment for programmers who would like to use Emacs, but dont want to spend the time in learning how to configure it.
Main features:
- All of the usual features of an editor: undo, redo, search and replace, intelligent indentation and wrapping.
- Spell-checking as you type. This distinguishes between true misspellings and words which are used more than once in a file, and so are likely to be correct but unknown. You can correct misspellings with a single keystroke (F8).
- There are many convenient ways of entering non-ASCII text, including Unicode and various exotic encodings.
- Rectangular selection of text, which can be also used to insert the same text in many columns (Ctrl-Return).
- Most file-types define syntax-sensitive folding (F7).
- Visible, persistent bookmarks to mark particular lines in a file (Alt-F2).
- You can search for text in multiple files in a given folder or set of subfolders (Ctrl-Shtf-F9). The output displays a menu of the lines in the different files that match a your pattern, and you can jump from one to the next with a single keystroke (F10 or Alt-`).
- Auto-completion of words based on the content of other open files (F5), or on a dictionary (Shft-F8).
- Multiple cut and paste clipboards (just hit Ctrl-number before cutting, copying or pasting, and the commands will use the clipboard numbered 0-9 for that operation).
- History of clipboard contents: you can browse through the past contents of the clipboard and insert any one of the previous contents (Shft-Ctrl-V).
- Keyboard macros that let you record (Alt-Shft-F5) and play back (Alt-F5) a series of keystrokes, to ease repetitive tasks.
- You can look up the word at the cursor in dictionaries and thesauri with a single keystroke (Alt-F8).
- You can easily switch between open files via a menu (F9), or other quick shortcuts (Shft-F9, Ctrl-F9). There is also a menu of recently opened files (Alt-Shft-F1).
- There is a full command shell for manipulating files and running commands. (Alt-F9).
Enhancements:
- A number of small updates and additions were made.
- At a minimum, the forthcoming Emacs 22 is required.

classesfaq is a Perl module with frequently asked questions about the Perl classes pragma.
Main features:
- Compile-time classes, no base class required
- Dynamic classes, alter or create at run-time
- Attributes, class and object, private, read-only, public
- Mixins, methods by name or regx, attributes also
- Single and multiple inheritance
- Accessors, optimized, overridable with read-only
- Accessor dispatch methods set and get
- Method declaration, delegation, ABSTRACT and EMPTY
- Separate new and clone methods, overridable
- Optional initialize method, aggregation
- Utility methods: dump, load, CLASS, SUPER
- Dynamically preserved declaration and mixin tracking
- Simplified exceptions, one line exception classes with inheritance trees
- Base exception class, light, robust, traceable
- 8 reusable exception classes in X:: namespace
- Compatible standard internals, easy porting, no surprises
What is the classes pragma?
A simple, stable, fast, and flexible way to use Perl 5 classes. If you look at no other Perl OO module look at this one, really. If you have done OO in Perl you will find this comfortably familiar. If not you may save yourself time and pain learning the classes pragma first or as you learn Perl OO--many have already.
Why should I use the classes pragma?
- Relevant: fills real-world need for conventional Perl OO
- Lazy: 100+ conventional lines reduced to 1
- Simple: standard readable terms, UML friendly
- Stable: 1000+ unit test points, used reliably in large applications
- Portable: OS independent, single file, 100% pure perl
- Fast: benchmarks faster or equal to the long way
- Light: only standard deps, requires greater than 5.6.1
- Sustainable: tag model, clean, commented
- Open: Perl artistic license, multi-language friendly
- Supported: mailing list, site, documented, actively maintained
If for no other reason because it is a new approach.

Atocha is a Python package for parsing and rendering data from web forms.
Atocha is framework-agnostic, generic, and it should be possible to use it with CGI scripts or to incorporate it in your favourite web application framework.
Just before I decided to write this software (2005-09-30), I had the following problems:
- There was no library that could parse input from widgets and perform automatic types conversions reliably, that was both decent and simple, or that was not tied to a specific web application framework. (A few options were starting to sprout and mature around that time, such as FormEncode);
- I was having lots of trouble in the various data paths of my handlers with type conversions, often having unicode encoding problems;
- I felt that the problem of handling and rendering web forms were really tied closely, and that it could be solved in a generic manner.
At the time, I had written my own web application framework, and a small form library I had copied from somewhere had grown into a messy monster. So I decided to attack the problem directly and rewrite my forms handling generically, with the following goals in mind:
- Reuse the form definition for parsing submitted arguments as well as rendering and displaying data (leverage the knowledge stored in the form definition as much as possible);
- Robustness: an emphasis on strict type checking and robustness via tests;
- Fields automatically perform appropriate type conversion when returning the parsed value to the user; Like desktop UI toolkit widgets, fields may return all sorts of data types. Also, fields can use multiple HTML input widgets, the notion of input and its mechanism are separate.
Essentially, I wanted functionality closer to what desktop UI toolkits provide, which is often not present in web form parsing toolkits.
Main features:
- Generic library that is possible to reused in many frameworks and applications. It is not tied to any storage model or domain model, this library provides the data, and you must then store the data yourself. This makes sense, as user-interfaces may change but the underlying data model remain the same;
- Extensible: it is easy to create and add new field types without having to modify the framework. It is also possible to create renderers for your favourite output library (e.g. Stan)
- Fields may render to multiple input widgets and are consolidated in a single value automatically;
- Internationalization (I18n) of all messages is supported (all messages generated by the library are grouped in a s single place and can be easily customized);
- Supports hidden, disabled, and read-only widgets that can be used for implementing multiple-page forms;
- Supports per-field errors, to be rendered next to the erroneous widgets;
- Supports a UI message and status for the re-rendering a form with errors;
- Could easily be extended to support widgets with JavaScript/AJAX code.

SpamTestBuddy is a simple, light-weight, multiple-input spam scoring tool. SpamTestBuddy project is standalone and can be used with simple procmail rules without root access or daemons. Features built-in support for simple DNS checks including DNSBL (DNS-based blocklist) queries, and can scan headers from filters such as SpamProbe, QSF, DSPAM that you already use.
The configuration is flexible and easy to edit in a human readable file. Different tests can add or remove from the total score.
(I am not trying to re-invent SpamAssassin. That is a very powerful piece of software with all the features you need. It is also somewhat large and is a greater challenge to install. SpamTestBuddy will just help you bring together existing scores from filters you already use, with a few useful extra tests thrown in. For an all-in-one solution, try SpamAssassin).
Tested under Linux, FreeBSD, and NetBSD.
COMMON USES
1) Combining more than one external filter:
If you have a number of filters that output a numeric probability or score, you can combine them together using +TestHeaderFloat and make a decision on the total (floating point) score. Examples of filters which integrate seamlessly are SpamProbe, QSF, DSPAM, CRM114.
2) Querying DNSBL (DNS based blocklists, real time lists) or local IP files:
Typically this is done by mail servers at the time of mail receipt. However, there are advantages to doing these "RBL" lookups later. SpamTestBuddy will let you query multiple real-time lists for fresh data on known spam sources, abusive networks, etc. You can combine the results with your other statistical body-reading filters. You can also use TestFileIP to look up the IP in a local text file, such as a custom whitelist or blacklist.
3) Reducing false positives from other filters:
You can use SpamTestBuddy as a secondary filter to interpret existing scores differently. Alternatively, you can make a more conservative configuration by combining scores. This may be helpful for revisiting classification errors
4) Parsing the IP address of the sender
The IP address of the SMTP server which relayed mail is always visible in the Received headers, but parsing and extracting the correct IP address is hard to do reliably with procmail recipes alone. SpamTestBuddy can pick out the correct address by applying SkipReceived, a list of networks you define to consider local and ignore. The resulting IP address is conveniently displayed in the new X-SpamTestBuddy header, simplifying your procmail recipes.
Enhancements:
- This is the first public release of this software.
- The configuration file was enhanced for ease of use.
- DNSBL (RBL) support was added.

Check Your Network Address Translator for Compatibility with Peer-to-Peer Protocols.
If you are accessing the Internet from behind a Network Address Translator (NAT) of some kind, I would appreciate your help in surveying the behavior of different NATs, in terms of how and whether they support a certain technique for enabling peer-to-peer communication between NATted hosts (particularly when both endpoints are behind NATs). Down, you can understand what NAT is.
Suppose there are three communicating hosts: A, B, and C. Host A is a "well-known" Internet server with a permanent IP address, which acts as an "introducer" for the other two nodes. (For example, Host A might be a well-known ultrapeer or a game catalog server of some kind.) Host B, using Host As "introduction" services, would like to establish a direct peer-to-peer connection with host C. Both B and C, however, are behind (probably different) network address/port translators, and neither of them has exclusive use of any public IP address.
To initiate a peer-to-peer connection with host C, host B first sends A a message requesting an "introduction" to host C. A sends B a reply message containing Cs IP address and UDP port number as reported by host C, in addition to Cs IP address and UDP port number as observed by A. (If C is behind a NAT, then these two address/port combinations will be different.) At the same time, host A sends host C a message containing Bs IP address and UDP port numbers - again, both the ones reported by B and the ones observed by A, which will be different if B is behind a NAT.
Now B and C each know that they want to initiate a connection with each other, and they know each others public (NATted) as well as original IP addresses and UDP port numbers. Both B and C now start attempting to send UDP messages directly to each other, at each of the available addresses. If B and C happen to be behind the same NAT, then they will be able to communicate with each other directly using their "originally reported" IP addresses and UDP port numbers.
In the more common case where B and C are behind different NATs, the "originally reported" addresses will be useless because they will both be private IP addresses in different addressing domains. Instead, the IP address/UDP port combinations observed by A can be used in this case to establish direct communication. Although Bs NAT will initially filter out any UDP packets arriving from Cs public (NATted) UDP port directed at Bs public port, the first UDP message B sends to C will cause Bs NAT to open up a new UDP session keyed on Cs public port, allowing future incoming traffic from C to pass through the NAT to B. Similarly, the first few messages from B to C may be filtered out by Cs NAT, but will be able to start passing through the firewall as soon as Cs first message to B causes Cs NAT to open up a new session. In this way, each NAT is tricked into thinking that its respective internal host is the "initiator" of this new session, when in fact the session is fully symmetrical and was initiated (with As help) simultaneously in each direction.
Required NAT Behavior
There is one important requirement that the NATs must satisfy in order for this technique to work: the NATs must be designed so that they assign only one (public IP address, public UDP port) pair to each (internal IP address, internal UDP port) combination, rather than allocating and assigning a new public UDP port for each new UDP session. Recall that a "session" in Internet terminology is defined by the IP addresses and port numbers of both communicating endpoints, so host Bs communication with host A is considered to be one session while host Bs communication with host C is a different session. If Bs NAT, for example, assigns one public UDP port for Bs communication with A, and then assigns B a different public UDP port for the new session B tries to open up with C, then the above technique for peer-to-peer communication will not work because Cs messages to B will be directed to the wrong UDP port.
RFC 3022 explicitly allows and suggests that NATs behave in the former, "desirable" fashion, by maintaining a single (public IP, public port) mapping for a given (internal IP, internal port) combination independent of the number of active sessions involving this mapping. This behavior is not only good for compatibility with UDP applications, but it also helps to conserve the NATs scarce pool of public port numbers. Maintaining a consistent public port mapping does not adversely affect security in any way, either, because incoming traffic can still be filtered on a per-session basis regardless of how addresses are translated. There in fact appears to be no good reason not to implement the desirable behavior in a NAT, except perhaps for the implementation simplicity of naively allocating a new public port for every new session. Unfortunately, RFC 3022 does not require NATs to implement the desirable behavior, which has led me to wonder just how many real NATs actually do, and hence this page.
What NAT Check Does
The program natcheck.c is basically just a program that "pings" a well-known UDP port at two different servers that are publically accessible on the Internet. Both of these servers run the program natserver.c, with the command-line arguments "1" and "2" respectively. In addition, there a third "conspiring" server runs natserver with the command-line argument "3". Whenever each of the first two servers receives a UDP request, it not only sends a reply directly to the sender of that request, but also sends a message to the third server, which in turn "bounces" the reply back to the original client. The effect is that the client will receive not only solicited "ping" replies from the server the request was directed to, but also "unsolicited" replies from the third server.
To determine if the network address translator in use is implementing the desirable behavior of maintaining a single (public IP address, public port) mapping for a given (client IP address, client port), the client program natcheck.c basically just initiates a sequence of simultaneous pings to the first two servers (in case some of the requests or replies are lost in transit) and checks that the clients address and UDP port as reported by both servers is the same. If the NAT naively allocates a new public port for each new session, then the source port as reported by the two servers will be different, and its time to upgrade your NAT.
The replies echoed from the third server are used only to check whether the NAT properly filters out unsolicited incoming traffic on a per-session basis. Since the client never sends any messages to the third server, if the NAT is properly implementing firewall functionality, the client should never see the third servers echoed replies even after opening up active communication sessions with the first two servers.
Enhancements:
- The NAT Check client no longer attempts to guess whether you have Basic NAT or Network Address/Port Translation (NAPT). It turns to be quite difficult to test for this property reliably, because many NAPTs attempt to bind a private UDP port to a public port with the same port number if that port number is available, causing NAT Check to falsely report Basic NAT. The only way to test for this property reliably would be to run NAT Check on at least two client machines simultaneously, and since this property isnt terribly important to P2P apps its just not worth the trouble.
- The NAT Check client now tests for one additional NAT feature, which I call loopback translation. If a NAT supports loopback translation, it means that a host on the private network behind the NAT can communicate with other hosts on the same private network using public (translated) port bindings assigned by the NAT. Most NATs probably do not support this feature yet, but it may become increasingly important in the future where P2P clients may be located behind a common ISP-deployed NAT as well as individual home NATs. More details on loopback translation will appear in the next version of my Internet-Draft, to be released soon.
- The NAT Check client program now has a command-line option, "-v", which turns on verbose messages during the test.

PDL::MatrixOps Perl module contains some useful Matrix operations.

SYNOPSIS

$inv = $a->inv;

$det = $a->det;

($lu,$perm,$par) = $a->lu_decomp;
$x = lu_backsub($lu,$perm,$b); # solve $a x $x = $b

PDL::MatrixOps is PDLs built-in matrix manipulation code. It contains utilities for many common matrix operations: inversion, determinant finding, eigenvalue/vector finding, singular value decomposition, etc. PDL::MatrixOps routines are written in a mixture of Perl and C, so that they are reliably present even when there no FORTRAN compiler or external library available (e.g. PDL::Slatec or PDL::GSL).

Matrix manipulation, particularly with large matrices, is a challenging field and no one algorithm is suitable in all cases. The utilities here use general-purpose algorithms that work acceptably for many cases but might not scale well to very large or pathological (near-singular) matrices.

Except as noted, the matrices are PDLs whose 0th dimension ranges over column and whose 1st dimension ranges over row. The matrices appear correctly when printed.

These routines should work OK with PDL::Matrix objects as well as with normal PDLs.