Free data from census software for linux

Data::CGIForm is a Perl module with form data interface.

Data::CGIForm is yet another way to parse and handle CGI form data. The main motivation behind this module was a simple specification based validator that could handle multiple values.
You probably dont want to use this module. CGI::Validate is a much more feature complete take on getting this sort of work done. You may then ask why this is on the CPAN, I ask that of myself from time to time....

SYNOPSIS

my %spec = (
username => qr/^([a-z0-9]+)$/,
password => {
regexp => qr/^([a-z0-9+])$/,
filter => [qw(strip_leading_ws, strip_trailing_ws)],
},
email => {
regexp => qr/^([a-z0-9@.]+)$/,
filter => &qualify_domain,
optional => 1,
errors => {
empty => You didnt enter an email address.,
invalid => Bad [% key %]: "[% value %]",
},
extra_test => &check_email_addr,
},
email2 => {
equal_to => email,
errors => {
unequal => Both email addresses must be the same.,
},
},
);

my $r = $ENV{MOD_PERL} ? Apache::Request->instance : CGI->new;

my $form = Data::CGIForm->new(datasource => $r, spec => %spec);


my @params = $form->params;
foreach $param (@params) {
next unless my $error_string = $form->error($param);

print STDERR $error_string;
}

if ($form->error(username)) {
handle_error($form->username, $form->error(username));
}

my $email = $form->param(email);
my $password = $form->password;

Data::Locations - magic insertion points in your data
Did you already encounter the problem that you had to produce some data in a particular order, but that some piece of the data was still unavailable at the point in the sequence where it belonged and where it should have been produced?
Did you also have to resort to cumbersome and tedious measures such as storing the first and the last part of your data separately, then producing the missing middle part, and finally putting it all together?
In this simple case, involving only one deferred insertion, you might still put up with this solution.
But if there is more than one deferred insertion, requiring the handling of many fragments of data, you will probably get annoyed and frustrated.
You might even have to struggle with limitations of the file system of your operating system, or handling so many files might considerably slow down your application due to excessive file input/output.
And if you dont know exactly beforehand how many deferred insertions there will be (if this depends dynamically on the data being processed), and/or if the pieces of data you need to insert need additional (nested) insertions themselves, things will get really tricky, messy and troublesome.
In such a case you might wonder if there wasnt an elegant solution to this problem.
This is where the "Data::Locations" module comes in: It handles such insertion points automatically for you, no matter how many and how deeply nested, purely in memory, requiring no (inherently slower) file input/output operations.
(The underlying operating system will automatically take care if the amount of data becomes too large to be handled fully in memory, though, by swapping out unneeded parts.)
Moreover, it also allows you to insert the same fragment of data into SEVERAL different places.
This increases space efficiency because the same data is stored in memory only once, but used multiple times.
Potential infinite recursion loops are detected automatically and refused.
In order to better understand the underlying concept, think of "Data::Locations" as virtual files with almost random access: You can write data to them, you can say "reserve some space here which I will fill in later", and continue writing data.
And you can of course also read from these virtual files, at any time, in order to see the data that a given virtual file currently contains.
When you are finished filling in all the different parts of your virtual file, you can write out its contents in flattened form to a physical, real file this time, or process it otherwise (purely in memory, if you wish).
You can also think of "Data::Locations" as bubbles and bubbles inside of other bubbles. You can inflate these bubbles in any arbitrary order you like through a straw (i.e., the bubbles object reference).
Note that this module handles your data completely transparently, which means that you can use it equally well for text AND binary data.
You might also be interested in knowing that this module and its concept have already been heavily used in the automatic code generation of large software projects.
Enhancements:
- Fixed test file "02___refcount.t" to auto-adjust the offset dealing with self-ties not incrementing
- the refcount in some Perl versions.
- Added a warning to "Makefile.PL" that Perl versions including and between v5.6.1 and v5.7.0 are not fully supported (test file "11_______dump.t" dumps core).

Data::BenchmarkResults is a Perl extension for averaging and comparing multiple benchmark runs.

SYNOPSIS

use Data::BenchmarkResults;
$conditionA_results = new Data::BenchmarkResults;
$conditionB_results = new Data::BenchmarkResults;

#Load test result runs for the first condition
$conditionA_results->add_result_set("test1","run1",@data1);
$conditionA_results->add_result_set("test2","run1",@data2);
$conditionA_results->add_result_set("test1","run2",@data3);
$conditionA_results->add_result_set("test2","run2",@data4);

#Load test result runs for the second condition
$conditionB_results->add_result_set("test1","run1",@data5);
$conditionB_results->add_result_set("test2","run2",@data6);
$conditionB_results->add_result_set("test1","run1",@data7);
$conditionB_results->add_result_set("test2","run2",@data8);

#Average (mean average) the results of all the the runs of test1
# w/o tossing the highest and lowest values (replace the 0 with 1to
# toss the highest and lowest values

my $computed = $conditionA_results->process_result_set("test1","mean",0);
my $computed2 = $conditionB_results->process_result_set("test1","mean",0);

#OR process all of the tests at once (tossing the highest and lowest value) :

$conditionA_results->process_all_result_sets("mean",1);
$conditionB_results->process_all_result_sets("mean",1);


#Print out all of the processed test results
print "Condition A results.... nn"
$conditionA_results->print_calculated_sets;
print "Condition B results.... nn"
$conditionB_results->print_calculated_sets;


#Compare results of test1 of condition B against those with condition A
# as a percentage change from A to B

my $compared = $conditionB_results->compare_result_set($conditionA_results,"test1");

#OR compare all the processed test results from one condition to those of another
my $total_comparison = $conditionB_results->compare_all_result_sets($conditionA_results);

Data::Str2Num - int str to int; float str to float, else undef.

SYNOPSIS

#####
# Subroutine interface
#
use Data::Str2Num qw(config str2float str2int str2integer);

$float = str2float($string, [@options]);
(@strings, @floats) = str2float(@strings, [@options]);

$integer = $secspack->str2int($string);

$integer = str2integer($string, [@options]);
(@strings, @integers) = str2int(@strings, [@options]);


#####
# Class, Object interface
#
# For class interface, use Data::SecsPack instead of $self
#
use Data::Str2Num;

$str2num = Data::Str2Num;
$str2num = new Data::Str2Num;

$float = $secspack->str2float($string, [@options]);
(@strings, @floats) = $secspack->str2float(@strings, [@options]);

$integer = $secspack->str2int($string);

$integer = $secspack->str2integer($string, [@options])
(@strings, @integers) = $secspack->str2int(@strings, [@options]);

Generally, if a subroutine will process a list of options, @options, that subroutine will also process an array reference, @options, [@options], or hash reference, %options, {@options}. If a subroutine will process an array reference, @options, [@options], that subroutine will also process a hash reference, %options, {@options}. See the description for a subroutine for details and exceptions.

Fast Data Transfer is an application for efficient data transfers that is capable of reading and writing at disk speed over wide area networks (with standard TCP).
It can be used to stream a large set of files across the network, so a large dataset composed of thousands of files can be sent or received at full speed, without the network transfer restarting between files.
The project is written in Java, runs an all major platforms, and is easy to use.
Main features:
- Streams a dataset (list of files) continuously, using a managed pool of buffers through one or more TCP sockets.
- Uses independent threads to read and write on each physical device
- Transfers data in parallel on multiple TCP streams, when necessary
- Uses appropriate-sized buffers for disk I/O and for the network
- Restores the files from buffers asynchronously
- Resumes a file transfer session without loss, when needed

Google Data Objective-C Client provides a framework and source code that make it easy to access data through Google Data APIs.
The Google data APIs provide a simple protocol for reading and writing data on the web. Many Google services provide a Google data API.
Each of the following Google services provides a Google data API:
- Base
- Blogger
- Calendar
- Spreadsheets
- Picasa Web Albums
- Notebook
Additional services with Google data APIs that are not yet supported by the Objective-C Client Library:
- Code Search
- Google Apps Provisioning

Data::Secs2 is a Perl module to pack, unpack, format, transform from Perl data SEMI E5-94 nested data.

SYNOPSIS

#####
# Subroutine interface
#
use Data::Secs2 qw(arrayify config listify neuterify numberify perlify
perl_typify secsify secs_elementify stringify textify transify);

@array = arrayify($ref, @options);

$old_value = config( $option );
$old_value = config( $option => $new_value);

$body = secs_elementify($format, $cells, @options);

@secs_obj = listify(@vars);

@secs_obj = neuterify($binary_secs, @options);

@vars = perlify(@secs_obj, @options);

$ref = perl_typify(@array, @options);

$ascii_secs = secsify( @secs_obj, @options);
$binary_secs = secsify( @secs_obj, type => binary);

$string = stringify(@arg, [@options]);

@secs_obj = transify($acsii_secs, @options);

#####
# Class, Object interface
#
# For class interface, use Data::Secs2 instead of $self
# use Data::Secs2;
#
$secs2 = Data::Secs2 # uses built-in config object

$secs2 = new Data::Secs2( @options );

@array = secs2->arrayify( $ref, @options );

$old_value = secs2->secs_config( $option);
$old_value = secs2->secs_config( $option => $new_value);

$body = secs2->secs_elementify($format, $cells, @options);

@secs_obj = secs2->listify(@vars, @options);

@secs_obj = secs2->neuterify($binary_secs, @options);

@vars = secs2->perlify(@secs_obj, @options);

$ref = secs2->perl_typify(@array, @options);

$ascii_secs = secs2->secsify( @secs_obj, @options);
$binary_secs = secs2->secsify( @secs_obj, type => binary);

$body = secs2->stringify( @arg );

@secs_obj = secs2->transify($acsii_secs, @options);

Generally, if a subroutine will process a list of options, @options, that subroutine will also process an array reference, @options, [@options], or hash reference, %options, {@options}. If a subroutine will process an array reference, @options, [@options], that subroutine will also process a hash reference, %options, {@options}. See the description for a subroutine for details and exceptions.

The Virtual Data Center (VDC) is a digital library system "in a box" for numeric data.

The VDC is a web application which provides everything necessary to maintain and disseminate collections of research studies: including facilities for the storage, archiving, cataloging, translation, and dissemination of each collection.

It includes on-line analysis, powered by the R Statistical environment. It also provides extensive support for distributed and federated collections including: location-independent naming of objects, distributed authentication and access control, federated metadata harvesting, remote repository caching, and distributed virtual