Free gray matters software for linux

Grey Matter is a CGI-based logging application suitable for a variety of purposes, mainly blogging. The project doesnt require a backend database and features a very flexible template system, as well as a karma and comment system.
Enhancements:
- Continuing code refactoring, with small admin UI enhancements such as paging on very long screens.
- Contains security enhancements and bugfixes as well.

Gray-Kde package contains the Kde version of the Gray Color Scheme.

smf-grey is a Sendmail milter that implements the GreyList Anti SPAM technology.
This technology can significantly reduce the amount of SPAM and viruses going from zombie computers (infected Windows PC), which produce more than 80% of SPAM.
GreyList Sendmail milter has a very effective GreyList algorithm on the base of the tuple: sender IP address (C class subnet), sender envelope and recipient envelope.
Its very recommended to use the smf-grey milter combined with the smf-zombie and the smf-spf milters. Its a triple impact on SPAM and viruses, that will seriously increase the efficiency of filtration.
This milter aims to be lightweight, reliable and simple. Its written in C.
Main features:
- It has a hosts/networks whitelist;
- It has an autowhitelist;
- It can add the information header with GreyList results to scanned messages;
- It can log all milter activities through the syslog service.
Advantages:
- Small code;
- Fast work;
- Stability (production quality);
- Few system resources are required.
Enhancements:
- Whitelists auto reloading was implemented.
- Autowhitelisted records regular dumping and reloading was implemented.
- The default greylisting time period was increased.
- New TODO tasks were added.
- Cosmetic enhancements were made.

Math::Numbers is a Perl module that contains methods for mathematical approaches of concepts of the number theory.

SYNOPSIS

use Math::Numbers;

my $a = 123;
my $b = 34;

my $numbers = Math::Numbers->new($a, $b [, ...]);

print "They are coprimes (relatively primes)!n" if $numbers->are_coprimes;
print "The greatest common divisor of these at least two numbers is ", $numbers->gcd;

my $number = Math::Numbers->new($a);

print "It is prime!n" if $number->is_prime;

my @divisors = $number->get_divisors;

print "$a is divisor of $b!n" if $number->is_divisor_of($b);

Math::Numbers is quite a simple module on matters of programming. What its interesting is the focus and approach it is intended to be made from the Number Theory basis for Perl beginners (like me) and also for young mathematicians (like me).

The normal topics of Number Theory include divisibility, prime numbers (which is separately intended to be covered by Math::Primes), congruences, quadratic residues, approximation for Real numbers, diophantine equations, etc. and all this is intended to be convered by the module on the concept on getting and setting values and also retriving the proof methods.

METHODS

new

# Some methods require more than only one argument.
my $numbers = Math::Numbers->new($p, $q, ...);

# Some methods require only one.
my $number = Math::Numbers->new($p);

Create a Math::Numbers object. Note that some of the methods will require objects created with only one or a defined numbers of arguments.

gcd
my $gcd = $numbers->gcd;

Calculation of the Greatest Common Divisor. This is made by two different methods which are described below: Blutos algorithm and Euclidean algorithm: The former is used when computing GCD for more than two integers; the latter is used when getting the GCD for two numbers to improve speed. See below for information on each.

Bluto_algorithm

You will mostly not require to call this method, but directly gcd(). Blutos algorithm uses a brute force calculation used by mathematicians to get divisors and then GCD also called Primality Test. Bluto takes some spinaches stolen from Popeye and starts dividing m all the way through 2 to m/2.

Euclidean_algorithm

Euclid rocks. I have a very nice Budgerigar (http://en.wikipedia.org/wiki/Budgerigar) called the same in honor of him (have to upload a pic of him).

As of now, this algorithm is only computed on two integers. From the Wikipedia entry: Given two natural numbers a and b: check if b is zero; if yes, a is the gcd. If not, repeat the process using (respectively) b, and the remainder after dividing a by b. This is exactly what our method does.
is_divisor_of

print "Yes, $p is divisor of $a...n" if $number->is_divisor_of($a);

Lets see if the number from the object is a divisor of $a, which means that the division $number/$a will return an integer (not necesarily a natural). If it does, itll return 1; 0, otherwise.

get_divisors
my @divisors = $number->get_divisors;

What are the divisors of the number brought by the object? This only includes the Natural numbers.

is_prime
print "$p is not prime!n" unless $number->is_prime

Returns 0 or 1 if the number from the object is prime or not, respectively. This method uses the, a bit slow, primality test.

are_coprimes
print "They are coprimes because their GCD is 1!n" if $numbers->are_coprimes;

Are the numbers from the object coprimes (relatively primes)? This means, the GCD is 1; (a, b, c, ...) = 1. Returns 1 or 0.

Grid::Transform is a Perl module with fast grid transformations.

SYNOPSIS

use Grid::Transform;

$g = Grid::Transform->new([a..o], rows=>5);
$g->rotate_270->flip_vertical;
print join( , $g->grid), "n";

The Grid::Transform module provides fast methods to transform a grid of arbitrary data types.

METHODS

$g = Grid::Transform->new( @grid, rows=>num, columns=>num )

Creates a new Grid::Transform object. The first argument is a reference to a 1-dimensional array representing a 2-dimensional "row major" (row by row) grid. (A column major grid is simply the counter transpose of a row major one.) The grid may be composed of arbitrary data types. The original array is never modified- all transformations operate on a copy.

At least one dimension must be specified. If the grid and dimensions do not produce a rectangular grid extra empty elements ("") will be added to the grid.

$g2 = $g->copy

Returns a copy of the original Grid::Transform object.

These methods get or set the grid attributes:

@grid = $g->grid
$grid = $g->grid
@grid = $g->grid( @grid )

In list context, returns an array representing the current grid. In scalar context, returns a reference to the array. Accepts an array reference representing a new grid. The new grid will be resized if the dimensions of the previous grid do not match.

$g->rows
$g->rows( $num )

Returns the current number of rows.

$g->columns
$g->cols
$g->columns( $num )

Returns the current number of columns.

All transform methods return the Grid::Transform object, so transforms can be chained.

$g->rotate_90
$g->rotate90

Rotates the grid 90 degrees clock-wise.

a b c d e f g h i j k l a b c d i e a
| e f g h -> j f b
i e a j f b k g c l h d i j k l k g c
l h d

$g->rotate_180
$g->rotate180

Rotates the grid 180 degrees clock-wise.

a b c d e f g h i j k l a b c d l k j i
| e f g h -> h g f e
l k j i h g f e d c b a i j k l d c b a

$g->rotate_270
$g->rotate270

Rotates the grid 270 degrees clock-wise.

a b c d e f g h i j k l a b c d d h l
| e f g h -> c g k
d h l c g k b f j a e i i j k l b f j
a e i

$g->flip_horizontal
$g->mirror_horizontal

Flips the grid across the horizontal axis.

a b c d e f g h i j k l a b c d i j k l
| e f g h -> e f g h
i j k l e f g h a b c d i j k l a b c d

$g->flip_vertical
$g->mirror_vertical

Flips the grid across the vertical axis.

a b c d e f g h i j k l a b c d d c b a
| e f g h -> h g f e
d c b a h g f e l k j i i j k l l k j i

$g->transpose

Flips the grid across the vertical axis and then rotates it 90 degress clock-wise.

a b c d e f g h i j k l a b c d l h d
| e f g h -> k g c
l h d k g c j f b i e a i j k l j f b
i e a

$g->counter_transpose
$g->countertranspose

Flips the grid across the horizontal axis and then rotates it 90 degrees clock-wise.

a b c d e f g h i j k l a b c d a e i
| e f g h -> b f j
a e i b f j c g k d h l i j k l c g k
d h l

$g->fold_right

Folds the columns to the right.

a b c d e f g h i j k l a b c d b c d a
| e f g h -> f g e h
b c a d f g e h j k i l i j k l j k i l

$g->fold_left

Folds the columns to the left.

a b c d e f g h i j k l a b c d d a c b
| e f g h -> h e g f
d a c b h e g f l i k j i j k l l i k j

AudioMixer is a small Xforms based audiomixer, with a neat and clean interface. It supports OSS/Linux and OSS/Free, and features of most soundcards. A special feature is the ability to fade from one source to another which is useful for voice-overs during recording and such.
To install, type make, copy mix binary in path.
Or use the dynamic binary provided here... - move libforms.so.88 to
/lib or /usr/lib, and re-run ldconfig...
If you dont trust binaries, feel free to grab xforms lib from
http://bragg.phys.uwm.edu:80/xforms, and recompile yourself.
Enhancements:
- gray out non existent controls
- volume led bar, stupid but works
- cdplayer controls, DOESNT CONTROL CDPLAYER YET
- audiopci pcm2 fix - report if this doesnt work
- fader now has menus to choose input sources from
- more bloated code

IFSgr is a command line two-dimensional linear IFS (Iterated Function System) grayscale renderer.
IFSgr uses Fractints IFS file format, and features automatic fractal scaling and gray level adjustment and consistent image look independent of size or the numbers of iterations.
It can also convert Fractint files to Gimp IFS Compose files and back.
Main features:
- Reads and writes Fractint 2D IFS files, allowing to select particular fractals from them with easy :: notation.
- Reads FDESIGN TRN files.
- Reads and writes Gimp IFS Compose (IFSC) files.
- Renders high-quality grayscale images (see the IFS gallery), automatically scaling the fractals to fit to the canvas and adjusting gray levels.
- Writes Portable GrayMap images with bit depth 8 or 16, or raw pixel hit counts in pseudo-PGM format (like PGM but with 32bit depth).
- Can rotate, skew, asymmetricaly scale or flip the fractal before rendering or exporting to another format
- Allows selection of speed/quality trade-off and gamma (darkness) modification.
- Keeps consistent image impression the same when changing size or the number of iterations (quality).
- Can estimate box-counting dimension of the fractals.
- Its functionality is available as a library, libifsgr.
Enhancements:
- The code should be 64-bit clean now.

GOCR is an OCR (Optical Character Recognition) program, developed under the GNU Public License. It converts scanned images of text back to text files. Joerg Schulenburg started the program, and now leads a team of developers.

GOCR can be used with different front-ends, which makes it very easy to port to different OSes and architectures. It can open many different image formats, and its quality have been improving in a daily basis.

GOCR or JOCR?

The original name is GOCR. Its what is used internally in the sources. But, when registering the site at Sourceforge, gocr was already taken. So, its kind of both. Yeah, we know.

Some examples of how you can use gocr:

gocr -h # help
gocr file.pbm # minimum options
gocr -v 1 file.pbm >out.txt 2>out.log # generate text- and log file
djpeg -pnm -gray text.jpg | gocr - # using JPEG-files
gzip -cd text.pbm.gz | gocr - # using gzipped PBM-files
giftopnm text.gif | gocr - # using GIF-files
gocr -v 1 -v 32 -m 4 file.pbm # zoning and out30.bmp output
xli -geometry 400x400 out30.bmp # see details using xli (recommanded viewer)
wish gocr.tcl # X11-tcl/tk-frontend (development version)
# see manual pages for more details