Free compound nouns software for linux

Objective-C Foundation Classes is an Objective-C library.
It contains general purpose classes for easier development of applications, in areas such as data types, network, C library wrappers, collections, and compound classes.
The classes in the library are grouped in five clusters:
- DataTypes - integer, text string, fraction, bitarray, date/time, random generators, big integer, big double ...
- Collections - array, list, hash table, AVL and n-tree, circular array, graph ...
- Network - TCP/UDP server and client, HTTP client, Telnet client ...
- C-library wrappers - DBM, socket, MD5, regular expression, timer, file, directory, gzip and bzip2 file, text screen ...
- Compound - Argument parser, calendar, finite state machine, tokenizer, XML tree, discrete distribution, objective-c source tokenizer ...
Enhancements:
- A new class (DBigFraction) and a new protocol (DBitArithmetic) have been added to the library.
- There are also several bugfixes related to 64-bit platforms.
- The copy-constructor support has been improved, and as a result all collections can now be (deep) copied.
- There are some small bugfixes, and several classes have been extended with new methods.

GMP compiler tool simplifies the use of GMP, the GNU multiple precision library. It scans a C source file for specially marked GMPS arithmetic expressions and replaces them with plain C.
The abbreviation gmpc stands for GMP compiler, or alternatively GMPS-to-C compiler. GMPS arithmetic expressions are straightforward infix expressions which transparently support the special types mpq_t, mpz_t and mpf_t as defined by GMP. GMPS means, rather unimaginatively, `GMP script.
No dependencies are added to the resulting C source, so there is no need to include additional header files or link with special libraries other than GMP.
Invoking gmpc
To translate a .gmpc file to C source, at least the input and output files must be given. The most concise invocation would look like this:
gmpc -o foo.c foo.gmpc
This will translate foo.gmpc into foo.c.
It is highly recommended to enable all warnings with the -Wall switch:
gmpc -Wall -o foo.gmpc foo.c
Other switches can be used to change the default behaviour of gmpc. They are listed in the following sections.
Enhancements:
- Added support for C-like compound assignments, increment and decrement operators.
- Fixed an assignment precedence bug.
- Temporary variables and constants are grouped together to make generated code more readable.
- Added Doxygen comments and configuration file.

POI provides a java ports of popular OLE 2 file formats.
The POI project contains several components for dealing with popular OLE 2 formats in Java. POIFS is a pure Java implementation of the OLE 2 Compound document format.
HSSF is a pure Java implementation of Excel 97 XLS file format based on POIFS. HSSF Serializer is a pure Java serializer for Cocoon 2 that uses the Gnumeric XML format to output XLS.
Full documentation of the POIFS file format is included. If you wish to output reports in the Excel file format, or if you have existing XML documents that you need to get into Excel, then this project is probably what youre looking for.
Enhancements:
- Support for evaluating formulas in HSSF, initial support for HSLF (PowerPoint), and support for editing document properties (HPSF).

POLE is a portable C++ library to access structured storage. It is designed to be compatible with Microsoft structured storage, also sometimes known as OLE Compound Document.

A structured storage is normally used to store files inside another file; you can even have complex directory tree inside. It can be treated as a filesystem inside a file.

The most popular use of structured storage is in Microsoft Office. Structured storage does not offer compression nor encryption support, hence usually it is used only for interoperability purposes.

Compared to structured storage routines offered by Microsoft Windows API, POLE has the advantage that it is portable. You can access any structured storage in the supported platform, you dont need to rely on Windows library.

Using

To compile POLE, you need a C++ compiler, with standard C++ library which supports STL (Standard Template Library).

POLE is just a library, you have to integrate it as part of your application/project. Since it consists of one source file and one header file, it does not make much sense to compile POLE as separate library (either static or dynamic). Simply add these files to your project and you are done.

The source tarball of POLE demonstrates the use of POLE to build poledump, a small utility to extract any stream inside a structured storage. If you use g++ as the compiler, you can compile poledump using the following command:

g++ -o poledump pole.cpp poledump.cpp

You may use poledump like the example below:

poledump budget.xls Workbook result.xls

The above command will extract a stream named Workbook inside Excel document (budget.xls) and save it as result.xls. File result.xls will still be recognized as a valid workbook (in raw format). Launch Microsoft Excel, open this file, and convince yourself.

Since version 0.2, the source tarball also includes a graphical tool named POLEView. Its purpose is to show the content of a structured storage in a tree view. It is also possible to view each stream in hexadecimal format and/or export the stream as well. You can study its source code to get familiar on how to use POLE API.

To compile POLEView, you need Qt (from Trolltech) version 3.x. Most Linux distributions normally already package the latest version of Qt, so it is likely that you need to worry about this. The Windows version is still planned, awaiting for the release of Qt version 4.

The build command for poleview is:

qmake && make

Mknew project is an investigation of how to build simple Unix shell scripts to manage common development and administrative tasks.
The emphasis is on using languages and tools that already exist and are in common use rather than inventing something new. A related emphasis is on exploring the functional programming nature of the bash shell.
This is accomplished by (1) using the bash function capability, and (2) using the bash "$(" ")"syntax to delay function execution in bash scripts. This allows building scripts that have a Lisp like function syntax.
Capturing and factoring the syntax of procedures into bash funtions permits shell scripts to be written as a series of function calls with minimal syntax. A common syntactical pattern in mknew scripts is
verb noun noun noun ...
or, somewhat more precisely,
function argument1 argument2 ...
The goal of mknew is to provide a way to specify make procedures of heterogeneous components in a bash script. These components can include
- diverse source code languages,
- documentation texts,
- test procedures and
- data.
mknew supports the integration of software build procedures with other software development administration procedures, such as unit, integration, and systems testing; distribution; and installation.
In addition to the mknew function library, these "make" procedures rely only on tools provided by the bash shell, and common Unix command line utilities.
Enhancements:
- This release provides new capabilities and further explorations of bash functions.
- This version of mknew supports the deployment of files to arbitrary destinations, and is useful for managing many different types of files, such as configuration files, using a consistent activity pattern.
- Once mknew is installed, an "mkd" file is created in the source file directory, specifying the primary source file types.
- To deploy files, simply type "mk all" at the shell prompt.

KMol calculates the elemental compositon and molecular weight of compounds from their chemical formula. KMol supports user defined groups and elements, unlimited nesting of subgroups, multicomponent compounds, global and per-user symbol definitions.
KMol is designed to be able to parse any chemical formula that can be
unambiguously interpreted if written as a simple character sequence (i.e.,
without subscript and superscript formating). If you can understand a chemical
formula, chances are KMol will understand it in exactly the same way.
Enhancements:
- Fixed KDE3 compilation problem. Fixed saving of user-defined weights.

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.