bc is an arbitrary precision numeric processing language. Syntax is similar to C, but differs in many substantial areas. It supports interactive execution of statements. bc is a utility included in the POSIX P1003.2/D11 draft standard.

Since the POSIX document does not specify how bc must be implemented, this version does not use the historical method of having bc be a compiler for the dc calculator.

This version has a single executable that both compiles the language and runs the resulting `byte code. The byte code is not the dc language.

Convert::yEnc::Entry is a Perl module as an entry in a Convert::yEnc::RC database.

SYNOPSIS

use Convert::yEnc::Entry;

$entry = new Convert::yEnc::Entry { size => 10000 };
$entry = new Convert::yEnc::Entry { size => 50000, part => 1 };

$entry = load Convert::yEnc::Entry "10000t10000";
$entry = load Convert::yEnc::Entry "20000t1-20000t1-2";

$ok = $entry->ybegin( { size=>10000 } );
$ok = $entry->ypart ( { begin=>1, end=>10000 } );
$ok = $entry->yend ( { size=>10000 } );

$entry->complete and ...

print "$entryn";

ABSTRACT

An entry in a Convert::yEnc::RC database

Convert::yEnc::Entry manages a single entry in a Convert::yEnc::RC database

Bobs Calculator is a simple command-line calculator. Does standard math in base 2/8/10/16, binary and/or/xor/not, and binary shift left / right.

Uses readline for command history and prints out calculation results in base 2/8/10/16. Great for random calculations during coding, or whatever. New version 1.1 inspired by ? key in IDA. Not a bc(1) clone.

Installation:

1. make
2. ./bc
3. help
4. C-d
5. vi calc.y
6. read top comment
7. :q
8. cp bc /somewhere/in/path
9. rehash (on *csh)

Date::Roman is a Perl OO extension for handling roman style dates.

SYNOPSIS

use Date::Roman;

$caesar_death = Date::Roman->new(roman => id 3 702);

print $caesar_death->ical(),"n"; #prints -520315

This module defines a class for handling Roman dates as defined by Julius Caesar in 45 BC.

WebService::Basecamp is a Perl interface to the Basecamp API webservice.

SYNOPSIS

use WebService::Basecamp;

my $bc = WebService::Basecamp->new( url => http://mysite.clientsection.com,
user => username,
pass => password );

my $test = $bc->ping || die $bc->error();

my $projects = $bc->projects; # a list of all projects

Basecamp is a web based project collaboration tool that makes it simple to communicate and collaborate on projects. Basecamp is built on the Ruby on Rails platform but provides a webservice API to many of the application functions. WebService::Basecamp is a Perl interface to the Basecamp web service API.

For more information on Basecamp, visit the Basecamp website. http://www.basecamphq.com.

This module does much of the heavy lifting for you when accessing the Basecamp API. Once initialising a WebService::Basecamp object you can access the API function via method calls. The module takes care of the creation and parsing of the XML (using XML::Simple) that relays the data across the web service, however there is an option to access the XML directly (see new()).

The documentation for this module is based on the Basecamp API docs available at http://www.basecamphq.com/api. It is recommended you read the official docs to become familiar with the data reference.

Math::Pari is a Perl interface to PARI.

SYNOPSIS

use Math::Pari;
$a = PARI 2;
print $a**10000;
or
use Math::Pari qw(Mod);
$a = Mod(3,5);
print $a**10000;

This package is a Perl interface to famous library PARI for numerical/scientific/number-theoretic calculations. It allows use of most PARI functions as Perl functions, and (almost) seamless merging of PARI and Perl data. In what follows we suppose prior knowledge of what PARI is (see ftp://megrez.math.u-bordeaux.fr/pub/pari, or Math::libPARI).

Algorithm::SocialNetwork is a social network analysis.

SYNOPSIS

use Graph::Undirected;
use Algorithm::SocialNetwork;

my $G = Graph::Undirected->new();
$G->add_edges([qw(a b)], [qw(b c)]);
my $algo = Algorithm::SocialNetwork->new(graph => $G3);
my $BC = $algo->BetweenessCentrality();
# $BC->{a} is 0
# $BC->{b} is 2
# $BC->{c} is 0

METHODS

So far this module implement the algorithm provided in [1]. More handy algorithm would be included in the future.
This module is a Spiffy module, methods provided as "field" are marked.

new([graph => $G])

Object constructor, an optional graph parameter could be passed in to specify the network graph to be analyzed.

graph([$G]) [Spiffy field]

Without arguments, this method return the current Graph object.

BetweenessCentrality([$vertex])

The implementation of algorithm provided in [1], if an optional parameter $vertex is given, return the BetwenessCentrality value of that vertex, otherwise, return all vertices BetweenessCentrality value, stored in a hash, which hash node name as keys.

ClusteringCoefficient($vertex)

Return the clustering coefficient of a given vertex.
WeightedClusteringCoefficient($vertex)

Return the weighted clustering coefficient of a given vertex. The graph object passed in should have weight attribute set on edges. Weights are default to 1 if its not set.

DistanceCentrality($vertex)

Return the distance centrality of a given vertex.

ClosenessCentrality($vertex)

An alias of DistanceCentrality().

GraphCentrality($vertex)

Return the graph centrality of a given vertex.

edges(@vertices)

Return a list of edges that connets any two of @vertices.

HTTP::Browscap is a Perl module that can parse and search browscap.ini files.

SYNOPSIS

use HTTP::Browscap;

my $capable = browscap();

if( $capable->{wap} ) {
output_WAP();
}

if( $capable->{css} > 1 ) {
# Browser can handle CSS2
}

# OO interface
my $BC = HTTP::Browscap->new( browscap.ini );

$capable = $BC->match( $ENV{HTTP_USER_AGENT} );

ABSTRACT

Browscap.ini is a file, introduced with Microsofts IIS, that lists the User-Agent strings that different browsers send, and various capabilities of those browsers. This module parses browscap.ini and allows you to find the capability definitions for a given browser.

Starting with Microsofts IIS, a browscap.ini file was used to list the capabilities of various browsers. Using the User-Agent string that a browser sends in the HTTP request, the capabilities of a browser are retrieved. If an exact match of the User-Agent string isnt found, wild-card expantion is done. If all fails, a default browser definition is used.

There are limits the usefulness of browscap.ini. It only detects if a browser has a certain capability, but not if this capability has been deactivated or if its a buggy implementation. In particular, most CSS and JavaScript implementations will make you scream.

KAstrHorloge is an astronomy software for Linux & KDE.

KAstrHorloge is provided with a 10000 stars database. For any of these stars or planets, the software can compute its position in the sky of your observation site. It displays the object location both in a map and in terms of coordinates (alpha and delta)

For each star or planet, you can add your own comments (for example, some physical data, or observation comments) and even a CCD image of the object !

All functions of KAstrHorloge are intuitive and easily accessible, so you can use this software without reading the doc !

Good observations !

Whats New in This Release:

· Added a dialog to choose the geographic location
· Used libAstronomy and libnova for calculations

Algorithm::Huffman is a Perl extension that implements the Huffman algorithm.

SYNOPSIS

use Algorithm::Huffman;

my %char_counting = map {$_ => int rand(100)} (a .. z, A .. Z);
# or better the real counting for your characters
# as the huffman algorithm doesnt work good with random data :-))

my $huff = Algorithm::Huffman->new(%char_counting);
my $encode_hash = $huff->encode_hash;
my $decode_hash = $huff->decode_hash;

my $encode_of_hello = $huff->encode_bitstring("Hello");

print "Look at the encoding bitstring of Hello: $encode_of_hellon";
print "The decoding of $encode_of_hello is ", $huff->decode_bitstring($encode_of_hello), "";

This modules implements the huffman algorithm. The aim is to create a good coding scheme for a given list of different characters (or even strings) and their occurence numbers.

ALGORITHM

Please have a look to a good data compression book for a detailed view. However, the algorithm is like every good algorithm very easy.

Assume we have a heap (keys are the characters/strings; values are their occurencies). In each step of the algorithm, the two rarest characters are looked at. Both get a suffix (one "0", the other "1"). They are joined together and will occur from that time as one "element" in the heap with their summed occurencies. The joining creates a tree growing on while the heap is reducing.
Lets take an example. Given are the characters and occurencies.

a (15) b(7) c(6) d(6) e(5)

In the first step e and d are the rarest characters, so we create this new heap and tree structure:

a(15) de(11) b(7) c(6)

de
/
"0"/ "1"
d e

Next Step:

a(15) bc(13) de(11)

de bc
/ /
"0"/ "1" "0"/ "1"
d e b c

Next Step:

a(15) bcde(24)

bcde
/
"0"/ "1"
/
de bc
/ /
"0"/ "1" "0"/ "1"
d e b c

Next Step unifies the rest:

Huffman-Table
/
"0"/ "1"
/
/
bcde a
/
"0"/ "1"
/
de bc
/ /
"0"/ "1" "0"/ "1"
d e b c

Finally this encoding table would be created:

a 1
b 010
c 011
d 000
e 001

Please note, that there is no rule defining what element in the tree is ordered to left or to right. So its also possible to get e.g. the coding scheme:

a 0
b 100
c 101
d 110
e 111

Abakus project is a simple calculator for KDE, based on a concept of Roberto Alsinas. Think of it as bc (the command-line calculator) with a nice GUI.

Here are some key features of "abakus":

· Roberto Alsinas UseCalc PyQt-based calculator.
· Zack Rusins Ruby-based calculator.
· Mine.
· Ariya Hiyadats SpeedCrunch, a pure Qt/C++ solution, which is closest in functionality to abakus. It doesnt use yacc or lex, making it a good choice if abakus cant build for your system for whatever reason.

Whats New in This Release:

· Abakus supports the "," decimal separator correctly (both input and output).
· Show the most significant digits when an answer must be cut off due to space restrictions.
· Other minor stuff.

libparportled library is intended to control a LED device plugged on parallel port.

A such device is composed of a number of LED (default is 8, maybe more is possible, I dont know) plugged on parallel port.

Usage:

gcc option: -lparportled
#include < parportled.h >

MAXLED is defined as the number of LED available.
(--with-maxled= in configure option)

BASEPORT is the IO address of parallel port
(--with-port= in configure option)

Functions available are:

int led_setperm();
Initialise the parallel port, MUST be root !
Return -1 on error.

void led_on_all();
Turn all LED on.

void led_off_all();
Turn all LED off.

int led_on(int led);
Turn LED number "led" on.

int led_off(int led);
Turn LED number "led" off.

int led_set_on(int *state);
State must be a int vector. If value is > 0, LED will be turned on.

int led_set_off(int *state);
Do the inverse of led_set().

int led_blink_on(int led, int us_time);
Start blinking LED number "led". us_time is the time in microsecond of
the state changement.
This function starts a new thread.
Please note that all LED are blinking with in a same interval, the first
us_time is used.
If you do:
led_blink_on(1, 10000);
led_blink_on(2, 2000);
10000 will be used for ALL blinking LED.

int led_blink_off(int led);
Stop blinking LED number led.
If no more led are blinking, thread exits.

Whats New in This Release:

· Some bug fix

AI::NeuralNet::Simple is a simple learning module for building neural nets.

SYNOPSIS

use AI::NeuralNet::Simple;
my $net = AI::NeuralNet::Simple->new(2,1,2);
# teach it logical or
for (1 .. 10000) {
$net->train([1,1],[0,1]);
$net->train([1,0],[0,1]);
$net->train([0,1],[0,1]);
$net->train([0,0],[1,0]);
}
printf "Answer: %dn", $net->winner([1,1]);
printf "Answer: %dn", $net->winner([1,0]);
printf "Answer: %dn", $net->winner([0,1]);
printf "Answer: %dnn", $net->winner([0,0]);

ABSTRACT

This module is a simple neural net learning tool designed for those who have an interest in artificial intelligence but need a "gentle" introduction. This is not intended to replace any of the neural net modules currently available on the CPAN. Instead, the documentation is designed to be easy enough for a beginner to understand.

Googolplex is just a Python class to do a query on Google search engine, parse it and returns the result as a list.

My friend Matias Torchinsky wrote me a pretty brief history about the Googolplex:

"According to the penguin dictionary of curious and interesting Numbers a googol is a number that a child wrote on the board at the kindergarten: It is one followed by 100 zeros, the number the child considered the largest in the universe." The mathematician Edward Kastner , the uncle of the child who invented the googol, suggested that a much larger number will be called googolplex , and that it be defined as 1 followed by a googol of zeros. A googolplex is thus 10^googol. Indeed, we could propose the very large number defined by 10^googolplex or 10000^googolplex or googolplex^googolplex.

IMPORTANT!

Following the Google Terms of Service you cant use this kind of software, so use it for your education only!

PyFortune project is a GUI fortune program with over 10,000 fortunes built-in.

PyFortune is a BSD fortune-compatible GUI fortune program.

It has over 10,000 fortunes built-in, keeps track of all fortunes that have been displayed so they arent repeated prematurely, a history with back and forward, bookmarks with a bookmark editor, a fortune weight function to make some categories more likely to appear than others, and a search to find specific fortunes.

Here are some key features of "PyFortune":

· Over 10000 fortunes built-in
· Keeps track of which fortunes have been displayed so you dont see any again
· Unlimited history of displayed fortunes
· Built-in bookmarks and bookmark editor
· Loading and saving BSD fortune files
· Fortune weight function to make categories more likely to appear
· Find function to find specific fortunes

gmbCrossword is an application for making swedish type crosswords. It is written i Gambas and has support for word lookup in databases.

It is written in english but is translated to swedish. I have some problems to get Gambas to use the swedish translation myself but its probably my own fault.

In the distribution file youll find databases for english, swedish and computer words. They are rather small databases (10000-20000 words) to keep the filesize down but it is easy to import new words. I also have a bigger swedish file (>200000 words) but it is not currently in the distribution.

Instructions:

Unpack the file in your home directory (or somewhere else where you have write permissions). You need write permissions to the databases to be able to edit them.

The application file (gmbcrossword) can be located anywhere in your path.
The first time you start the program you need to specify the path to the databases using the settings menu.

nmzmail is a tool to use the namazu2 search engine from within the mutt mail reader to search mail stored in maildir folders. Based on the result of the namazu query, nmzmail generates a maildir folder containing symbolic links to the mails matching the query.

Here are some key features of "nmzmail":

· fast mail searching even with large number of mails; I use it currently on about 10000 emails
· incremental index building
· rich query language including regular expressions (see the namazu documentation)
· integrates nicely into mutt
· query history



Whats New in This Release:

· Fix getopt on PPC platform (patch by Sebastien Cevey).
· Change commandline syntax for indexing (the -m option is deprecated now), simply use "nmzmail -i ..." (noticed by Tom Martin on zsh mailing list).
· Use automake/autoconf.

Rescue Max is a Action Adventure in Space written in java.

Rescue! Max is a 2D space, real-time, action/strategy game in which you are in control of a ship that you fly around space, fighting enemies and making friends on your way.

Rescue! Maxs main objective is to rescue people from planets and take them to star bases.

Whats New in This Release:

· made select enimies default
· added particle explosions
· redone SpaceObjects inheritance
· added wait curser when new mission is laoding
· Rescue theme: maximum energy to 9999 instead of 10000
· Rescue theme: added better romulan warbird
· Rescue theme: added original main ship
· Rescue max theme: less of those evil nutrals as default
· Fixed: make auto impulse and auto warp clear when the ship is killed (that is set as the destination)
· game ends when u get killed
· game does not start when u start the app

dicelab allows you to express complex dice rolling schemes in a functional language and then roll dice according to such a scheme or analyze the statistic distribution of values.

It is useful when designing games (and to some degree when playing them).

Usage: dicelab [options] [-f < file >]

Options:

--help -h -? print this text
--version -v print the program version
--print-tree -p print the parse tree (for debugging)
--eval -e evaluate the statistical distribution by
re-rollingp
--count -c specify the number of rolls used with --eval
default is 10000
--roll -r roll the dice as specified, will also be used
if no other action is requested
File:
--file -f read the dice rolling specs from the file
specified, use stdin if not supplied

Whats New in This Release:

· The program is much faster now.

GParted LiveCD is a linux distribution based on Gnome Partition Editor.

It uses libparted to detect and manipulate devices and partitiontables while several (optional) filesystemtools provide support for filesystems not included in libparted.

These optional packages will be detected at runtime and dont require a rebuild of GParted.

GParted is written in C++ and uses gtkmm as Graphical Toolkit. The general approach is to keep the GUI as simple as possible. Thats why i try to conform to the GNOME Human Interface Guidelines.

GParted comes under the terms of the General Public License.

Whats New in This Release:

New package :
· bc (text-calculator)

Packages updated :
· sys-apps/portage-2.1.2.7
· sys-fs/ntfs3g-1.616-r1
· sys-fs/udev-112-r1

kernel-2.6.21
· - adding support in kernel to fix i810 problem ! According to : http://www.gkmac.co.uk/linuxacer.php

Device drivers --> Character devices -->
· < * > /dev/agpgart (AGP Support)
· < * > Intel 440LX/BX/GX, I8xx and E7x05 chipset support
· [*] Direct Rendering Manager (XFree86 4.1.0 and higher DRI support)
· < * > Intel 830M, 845G, 852GM, 855GM, 865G (i915 driver)