Free wordfast group software for linux

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.

TAO project is a standards-compliant, real-time implementation of CORBA that provides efficient, predictable, and scalable quality of service (QoS) end-to-end.

Unlike conventional implementations of CORBA, which are inefficient, unpredictable, non-scalable, and often non-portable, TAO applies the best software practices and patterns to automate the delivery of high-performance and real-time QoS to distributed applications.

Over the past decade, my research group has worked with many collaborators on large-scale distributed application R&D projects in diverse domains, including command and control systems, telecom, datacom, medical engineering, distributed interactive simulations, and financial services. Regardless of the domain and application requirements, weve found that software developers wrestle with the same core infrastructure challenges. Key challenges focus on OS platform portability, connection management and service initialization, event demultiplexing and event handler dispatching, multi-threading and synchronization, fault detection and fault tolerance, and various quality-of-service (QoS) issues, such as controlling latency, throughput, and jitter end-to-end.

Unfortunately, its very costly, time consuming, and error-prone for researchers and developers companies to independently rediscover and reinvent ad hoc solutions to these core distributed application software development challenges. Fortunately, we have identified a relatively concise set of patterns and framework components that can be applied systematically to eliminate many tedious, error-prone, and non-portable aspects of developing and maintaining distributed applications.

A decade of intense R&D on these topics has yielded ACE, which is an object-oriented framework that implements many core patterns for concurrent communication software. We have applied the patterns and components in the ACE framework to develop The ACE ORB (TAO), which is our standards-based, CORBA middleware framework that allows clients to invoke operations on distributed objects without concern for object location, programming language, OS platform, communication protocols and interconnects, and hardware. TAO is designed using the best software practices and patterns that we have discovered in our work on ACE in order to automate the delivery of high-performance and real-time QoS to distributed applications.

Google::Adwords::AdGroupEstimate is a Google Adwords AdGroupEstimate Object.

This object is a read-only object used in calls from Google Adwords API.

More info is available here -

http://www.google.com/apis/adwords/developer/AdGroupEstimate.html

METHODS

Accessors (read-only)

* id - The existing ad group id, if any, to which this estimate corresponds. If the ad group is new (meaning that all the estimated keywords are new), the id is -1.
* keywordEstimates - The keyword estimates for this ad group. Each Google::Adwords::KeywordEstimate contains the estimation results, such as estimated clicks per day, for that keyword.

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.

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.

Net::NIS::Listgroup is a Perl module to list hosts/users in a netgroup group.

SYNOPSIS

use Listgroup;

$array_ref_groups = listgroup();
$array_ref_groups = listgroups();

$array_ref_users_or_groups = listgroup({groupname});

$array_ref_users_or_groups = listgroup_user({groupname1},
[ [-]{groupname2}, [-]{gropuname3} ]);

$array_ref_users_or_groups = listgroup_host({groupname1},
[ [-]{groupname2}, [-]{gropuname3} ]);

A library used to get groups or members of a netgroup NIS map. listgroup() without any parameters or listgroups() lists all the available netgroup groups.

With groupname parameters listgroup, listgroup_user, listgroup_host will recusively list the members of the named groups. If the groupname is preceded with a - members of that group will be excluded from the returned list. Each member in a group is a triplet of (host,user,domain). The host portion or user portion of the members is returned by listgroup_host() and listgroup(), the user portion of the members is returned by listgroup_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.

Mass Rotate is a program that quickly and losslessly rotates JPEGs.

Its useful for rotating images from digital cameras. Uses jpegtran from from the Independent JPEG Group. Written in gtk2-perl.

Usage:

mass_rotate.pl dir_with_images/

or:

mass_rotate.pl image1.jpg image2.jpg image3.jpg ...

or:

mass_rotate.pl dir/ img.jpg other_dir/ whatever.jpg you_get_the_idea/