Free group dynamics software for linux

DynaMo is a software library providing classes that takes care of the calculation of the motions of geometries moving under the influence of forces and torques and impulses.
In addition, the library can also compute forces for you through the mechanism of constraints.
These allow you to easily connect geometries to each other in various ways. A constraint only has to be specified once, and the Dynamo library will continually enforce it from that moment on by applying the required reaction forces.
Main features:
- Full forward dynamics support for forces, torques and impulses.
- Runs side-by-side with your application, and has a low-bandwidth interface communicating the newly calculated positions and orientations to your application.
- Fast, tunable inverse dynamics support via constraints.
- Over a dozen constraints available, including several types of hinges and a constraint for collision response calculations.
- Support for controllers, activators and sensors.
- Fully object oriented design, allowing for easy extension of the library by adding your own constraints and controllers via inheritance: just derive your own class from the provided constraint or controller classes by implementing a few predefined methods.

HTTPD::GroupAdmin is a Perl module for the management of HTTP server group databases.

SYNOPSIS

use HTTPD::GroupAdmin ();

This software is meant to provide a generic interface that hides the inconsistencies across HTTP server implementations of user and group databases.

METHODS

new ()

Heres where we find out whats different about your server.

Some examples:

@DBM = (DBType => DBM,
DB => .htgroup,
Server => apache);

$group = new HTTPD::GroupAdmin @DBM;

This creates an object whose database is a DBM file named .htgroup, in a format that the Apache server understands.

@Text = (DBType => Text,
DB => .htgroup,
Server => ncsa);

$group = new HTTPD::GroupAdmin @Text;

This creates an object whose database is a plain text file named .htgroup, in a format that the NCSA server understands.

Full list of constructor attributes:

Note: Attribute names are case-insensitive

Name - Group name

DBType - The type of database, one of DBM, Text, or SQL (Default is DBM)

DB - The database name (Default is .htpasswd for DBM & Text databases)

Server - HTTP server name (Default is the generic class, that works with NCSA, Apache and possibly others)

Note: run perl t/support.t matrix to see what support is currently availible

Path - Relative DB files are resolved to this value (Default is .)

Locking - Boolean, Lock Text and DBM files (Default is true)

Debug - Boolean, Turn on debug mode

Specific to DBM files:

DBMF - The DBM file implementation to use (Default is NDBM)

Flags - The read, write and create flags. There are four modes: rwc - the default, open for reading, writing and creating. rw - open for reading and writing. r - open for reading only. w - open for writing only.

Mode - The file creation mode, defaults to 0644

Specific to DBI: We talk to an SQL server via Tim Bunces DBI interface. For more info see: http://www.hermetica.com/technologia/DBI/

Host - Server hostname

Port - Server port

User - Database login name

Auth - Database login password

Driver - Driver for DBI (Default is mSQL)

GroupTable - Table with field names below

NameField - Field for the name (Default is user)

GroupField - Field for the group (Default is group)

From here on out, things should look the same for everyone.

add($username[,$groupname])

Add user $username to group $groupname, or whatever the Name attribute is set to.

Fails if $username exists in the database

if($group->add(dougm, www-group)) {
print "Welcome!n";
}

delete($username[,$groupname])

Delete user $username from group $groupname, or whatever the Name attribute is set to.

if($group->delete(dougm)) {
print "Hes gone from the groupn";
}

exists($groupname, [$username])

True if $groupname is found in the database

if($group->exists(web-heads)) {
die "oh no!";
}
if($group->exists($groupname, $username) {
#$username is a member of $groupname
}

list([$groupname])

Returns a list of group names, or users in a group if $name is present.

@groups = $group->list;

@users = $group->list(web-heads);
user()

Short cut for creating an HTTPD::UserAdmin object. All applicable attributes are inherited, but can be overridden.

$user = $group->user();

(See HTTPD::UserAdmin)

convert(@Attributes)

Convert a database.

#not yet

remove($groupname)

Remove group $groupname from the database

name($groupname)

Change the value of Name attribute.

$group->name(bew-ediw-dlrow);

debug($boolean)

Turn debugging on or off

lock([$timeout]) =item unlock()

These methods give you control of the locking mechanism.

$group = new HTTPD::GroupAdmin (Locking => 0); #turn off auto-locking
$group->lock; #lock the objects database
$group->add($username,$passwd); #write while database is locked
$group->unlock; release the lock
db($dbname);

Select a different database.

$olddb = $group->db($newdb);
print "Now were reading and writing $newdb, done with $olddbn";
flags([$flags])

Get or set read, write, create flags.

commit

Commit changes to disk (for Text files).

Yahoo Group Archiver project is a collection of scripts to interact with Yahoo Groups and download various sections of each group to your local workspace.
Currently the following scripts are being actively supported:
- yahoogroup-messages
- yahoogroup-files
- yahoogroup-photos
- yahoogroup-members
Main features:
yahoogroup-messages
- Downloads all the messages from a group in the order in which they were received.
- Note: Yahoo has user based and group based limits on the number of messages you can download
yahoogroup-files
- Downloads all the content from the Files section in a group maintaining the heirarchy as present on the website
- Note: Yahoo has user based and group based limits on the number of files you can download
yahoogroup-photos
- Downloads all the content from the Photos section in a group maintaining the heirarchy as present on the website
- Note: Yahoo has user based and group based limits on the number of images you can download
yahoogroup-members
- Extract the members list and output it as a tab separated data.
- Note: MS Excel users may read this data by redirecting it to a file with a extension .xls
Enhancements:
- Yahoo! has made HTTPS-based login mandatory, and the script has been updated with the new Yahoo! Group HTML layout.

Async::Group is a Perl class to deal with simultaneous asynchronous calls.

SYNOPSIS

use Async::Group ;
use strict ;

sub sub1
{
print "Dummy subroutine n";
my $dummy = shift ;
my $cb = shift ;

&$cb(1);
}

sub allDone
{
print "All done, result is ", shift ,"n" ;
}
my $a = Async::Group->new(name => aTest, test => 1) ;

$a->run(set => [ sub {⊂1( callback => sub {$a->callDone(@_)} )},
sub {⊂1( callback => sub {$a->callDone(@_)} )} ],
callback => &allDone
)

# or another way which avoids the clumsy nested subs
my $cb = $a->getCbRef();
$a->run(set => [ sub {⊂1( callback => $cb)},
sub {⊄1( callback => $cb )} ],
callback => &allDone
)

If you sometimes have to launch several asynchronous calls in parrallel and want to call one call-back function when all these calls are finished, this module may be for you.

Async::Group is a class which enables you to call several asynchronous routines. Each routine may have their own callback. When all the routine are over (i.e. all their callback were called), Async::Group will call the global callback given by the user.

Note that one Async::Group objects must be created for each group of parrallel calls. This object may be destroyed (or will vanish itself) once the global callback is called.

Note also that Async::Group does not perform any fork or other system calls. It just run the passed subroutines and keep count of the call-back functions called by the aforementionned subroutines. When all these subs are finished, it calls another call-back (passed by the user) to perform whatever function required by the user.

Using fork or threads or whatever is left to the user.

Math::Group::Thompson Perl module contains OO methods that calculates the cardinality of the ball of radius n of Thompson group F.

SYNOPSIS

use Math::Group::Thompson;

my $F = Math::Group::Thompson->new( VERBOSE => 0 );
my $card = $F->cardBn(3,);

print "#B(3) = $cardn";

The Math::Group::Thompson module provides objetct oriented methods that calculates the cardinality of the ball of radius n of Thompson group F.

This module uses the presentation of F

F = < A,B | [AB^(-1),A^(-1)BA] = [AB^(-1),A^(-2)BA^2] = e >

where A,B are formal symbols, [x,y] is the usual commutator and e is the identity element of F.

[x,y] = xyx^(-1)y^(-1)

This means that for every g in F, g can be written as word

g = a_{1}a_{2} ... a_{n}

where all the a_{i} are A,B,A^(-1) or B^(-1) for all i r br Usage: my $F = new-Math::Group::Thompson( VERBOSE => $v );
Verbose argument tells Math::Group::Thompson whether print every word generated ($v == 1) or not ($v == 0), or store them in a file, where $v is the name of the file (obviously different to 0 or 1). If the verbose file exists it is replaced, so you have to check for its integrity.

NOTE:
Its not recommend to store the words on a file because for
very small values of n, #B(n) or #gB(n)-B(n) are very very large.
For example for n = 19, #B(n) ~ 3^n = 1162261467 ~ 1.1 Giga, but
the space ocupped by the file will be (in bytes):

#B(1) + sum(i=2 to 19){i*(#B(i) - #B(i-1))} =
cardBn

This method calculates #B(n) or #(gB(n) - B(n)) depending on if the argument passed to the first call of cardBn is or not.

Usage: my $c = $F->cardBn($radius,$g);

where

$radius is an integer number >= 0 and $g is an element of F (word written with A,B,C or D).

If the first time cardBn is called $g is not equal to , then cardBn returns the cardinality of the set

gB(n) - B(n) = { w in F | w in gB(n) and w not in B(n) }

If the firs time cardBn is callen $g is equal to , then cardBn returns #B(n).

This algorithm runs on exponential time because F is of exponential growth (more "exactly", this algorithm is O(3^n) ).

reset

Resets the counter used on cardBn method, set the FIRST_ELEMENT property at , and the FIRST_CALL proporty to 1.

Usage: $F->reset;

multiply

Multiplication between two words of F. This method considers the inverse relations stored in the attribute INV.

Usage: my $mul = $F->multiply($g,$w);

where $g and $w are elements of F, and $mul is the result of $g$w.

rotate

This module receives as argument a word in F and puts the last letter on word in its first place.

Usage: $w = ABC; $W = $self->rotate($w); # $W is now equal to CBA

inverse

This method receives a word in F and returns its inverse.

Usage: $w = ABC; $W = $self->inverse($w); # $W == ADC

divide

This method receives a word in F and returns a 2-dimensional array where the first element is the first half of the word, and the second is the inverse of the second half of the word.

Usage: $w = AABC; ($w1,$w2) = $self->divide($w); # Now $w1 == AA and $w2 == AD

get_inv

This method return the hash of inverse relations between the generators elements of F.

note

This method prints in STDERR the string received or puts it on the correspondent file.

Usage: $F->note(AA); # Print AA."n" or store it on a file.

WWW::Yahoo::Groups is an automated access to Yahoo! Groups archives.

SYNOPSIS

my $y = WWW::Yahoo::Groups->new();
$y->login( $user => $pass );
$y->list( Jade_Pagoda );
my $email = $y->fetch_message( 2345 );

# Error catching
my $email = eval { $y->fetch_message( 93848 ) };
if ( $@ and ref $@ and $@->isa(X::WWW::Yahoo::Groups) )
{
warn "Problem: ".$@->error;
}

WWW::Yahoo::Groups retrieves messages from the archive of Yahoo Groups. It provides a simple OO interface to logging in and retrieving said messages which you may then do with as you will.

Things it does

Handles access to restricted archives. It lets you login.
Handles the intermittent advertisements. It notes that it got one and progresses straight to the message.
Handle adult confirmation requests. It just goes straight on.
Handles attachments. We get the source which happens to be the raw stuff.
Sanity checking. Could be improved, but it will generally barf if it doesnt understand something.
Header restoration. Ive found that some groups archives have unusually corrupted headers. Evidently it would be beneficial to restore these headers. As far as I can tell, it comes from not being a moderator on the lists in question.

USAGE

Try to be a well behaved bot and sleep() for a few seconds (at least) after doing things. Its considered polite. Theres an autosleep method that should be useful for this. Recently, this has been set to a default of 1 second. Feel free to tweak if necessary.

If youre used to seeing munged email addresses when you view the message archive (i.e. youre not a moderator or owner of the group) then youll be pleased to know that WWW::Yahoo::Groups can demunge those email addresses.

All exceptions are subclasses of X::WWW::Yahoo::Groups, itself a subclass of Exception::Class. See WWW::Yahoo::Groups::Errors for details.

Parrot::Docs::Group is a group of documentation items.

SYNOPSIS

use Parrot::Docs::Group;

A documentation group is a number of items with some optional descriptive text.

Parrot::Docs::Group is a subclass of Parrot::Docs::Item.

Class Methods

new_group($name, $text, @items)

Returns a new group.

Use this when creating groups within a Parrot::Docs::Section subclasss new() method.
new($name, $text, @contents)

Returns a new group.

$name and $text are required, though the text can be an empty string. @contents is one or more Parrot::Docs::Item instances, or relative paths.

Instance Methods

name()

Returns the name of the group.

html_link()

Groups have no HTML link. This method returns an empty string which will be discarded when building the navigation bar.

write_html($source, $target, $silent)

write_html() is called on each item in the group.

Some HTML-formatted text describing the files linked to is returned.

write_contents_html($source, $target, $silent)

Iterates over the groups contents and calls write_html() on each one.

Some HTML-formatted text describing the files linked to is returned.

contents_relative_to_source($source)

Returns the contents of the group interpreted relative to the source directory.

WWW::Yahoo::Groups::Utils is a Perl module with Sundry utility routines for WYG.

This module provides miscellaneous routines to make WYG work nicely.

EXPORTS

One: get_unmangling_table

FUNCTIONS

get_unmangling_table

Returns a reference to an array comprising the address decoding table.