data in
Sponsored Links
Sponsored Links
Secleted [ 0 ] software to compare
Results 1 - 15 of about 4904
Data::Region 1.0
Data::Region Perl module can define hierarchical areas with behaviors. more>>
Data::Region Perl module can define hierarchical areas with behaviors.
SYNOPSIS
use Data::Region;
$r = Data::Region->new( 8.5, 11, { data => PageObj->new() } );
$r->data( PageObj->new() );
foreach my $c ( $r->subdivide(2.5,3) ) {
$a = $c->area(0.25,0.25, 2.25,2.75);
$a2 = $c->area(0.25,0.25, -0.25,-0.25); # as offset from lower right
($t,$m,$b) = $a->split_vertical(2,5,1); # sequential heights
($t,$m,$b) = $a->split_vertical_abs(0,2,7); # absolute offsets
($l,$r) = $a->split_horizontal(2); # $l gets width of 2, $r gets the rest
my($x1,$y1,$x2,$y2) = $a->coords();
my $data = $a->data(); # data inherits from parent, if not set
$a->action( sub { $data->setfont("Times-Bold", 10);
$data->text($x1,$y1, "Some Text");
$data->line( $_[0]->coords() ); # the non-closure way
} );
}
$r->render(); # heirarchically perform all the actions
# Get some info about a region:
($w,$h) = ( $a->width(), $a->height() );
($x1,$y1, $x2,$y2) = $a->coords();
($x1,$y1) = $a->top_left();
($x2,$y1) = $a->top_right();
($x1,$y2) = $a->bottom_left();
($x2,$y2) = $a->bottom_right();
Data::Region allows you to easily define a set of nested (2-dimensional) areas, defined by related coordinates, and to associate actions with them. The actions can then be performed hierarchically from any root of the tree.
Data::Region was written to provide an easy way to do simple page layout, but has, perhaps, more general uses.
<<lessSYNOPSIS
use Data::Region;
$r = Data::Region->new( 8.5, 11, { data => PageObj->new() } );
$r->data( PageObj->new() );
foreach my $c ( $r->subdivide(2.5,3) ) {
$a = $c->area(0.25,0.25, 2.25,2.75);
$a2 = $c->area(0.25,0.25, -0.25,-0.25); # as offset from lower right
($t,$m,$b) = $a->split_vertical(2,5,1); # sequential heights
($t,$m,$b) = $a->split_vertical_abs(0,2,7); # absolute offsets
($l,$r) = $a->split_horizontal(2); # $l gets width of 2, $r gets the rest
my($x1,$y1,$x2,$y2) = $a->coords();
my $data = $a->data(); # data inherits from parent, if not set
$a->action( sub { $data->setfont("Times-Bold", 10);
$data->text($x1,$y1, "Some Text");
$data->line( $_[0]->coords() ); # the non-closure way
} );
}
$r->render(); # heirarchically perform all the actions
# Get some info about a region:
($w,$h) = ( $a->width(), $a->height() );
($x1,$y1, $x2,$y2) = $a->coords();
($x1,$y1) = $a->top_left();
($x2,$y1) = $a->top_right();
($x1,$y2) = $a->bottom_left();
($x2,$y2) = $a->bottom_right();
Data::Region allows you to easily define a set of nested (2-dimensional) areas, defined by related coordinates, and to associate actions with them. The actions can then be performed hierarchically from any root of the tree.
Data::Region was written to provide an easy way to do simple page layout, but has, perhaps, more general uses.
Download (0.008MB)
Added: 2007-08-03 License: Perl Artistic License Price:
812 downloads
Data::Locations 5.4
Data::Locations is a virtual file manager which allows to read/write data to and from virtual files. more>>
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).
<<lessDid 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).
Download (0.043MB)
Added: 2005-04-29 License: Artistic License Price:
1638 downloads
Test::Data 1.20
Test::Data is a Perl module to test functions for particular variable types. more>>
Test::Data is a Perl module to test functions for particular variable types.
SYNOPSIS
use Test::Data qw(Scalar Array Hash Function);
Test::Data provides utility functions to check properties and values of data and variables.
Functions
Plug-in modules define functions for each data type. See the appropriate module.
How it works
The Test::Data module simply emports functions from Test::Data::* modules. Each module defines a self-contained function, and puts that function name into @EXPORT. Test::Data defines its own import function, but that does not matter to the plug-in modules.
If you want to write a plug-in module, follow the example of one that already exists. Name the module Test::Data::Foo, where you replace Foo with the right name. Test::Data should automatically find it.
<<lessSYNOPSIS
use Test::Data qw(Scalar Array Hash Function);
Test::Data provides utility functions to check properties and values of data and variables.
Functions
Plug-in modules define functions for each data type. See the appropriate module.
How it works
The Test::Data module simply emports functions from Test::Data::* modules. Each module defines a self-contained function, and puts that function name into @EXPORT. Test::Data defines its own import function, but that does not matter to the plug-in modules.
If you want to write a plug-in module, follow the example of one that already exists. Name the module Test::Data::Foo, where you replace Foo with the right name. Test::Data should automatically find it.
Download (0.008MB)
Added: 2007-05-03 License: Perl Artistic License Price:
904 downloads
Data::Stag 0.10
Data::Stag is a Perl module with structured tags datastructures. more>>
Data::Stag is a Perl module with structured tags datastructures.
SYNOPSIS
# PROCEDURAL USAGE
use Data::Stag qw(:all);
$doc = stag_parse($file);
@persons = stag_find($doc, "person");
foreach $p (@persons) {
printf "%s, %s phone: %sn",
stag_sget($p, "family_name"),
stag_sget($p, "given_name"),
stag_sget($p, "phone_no"),
;
}
# OBJECT-ORIENTED USAGE
use Data::Stag;
$doc = Data::Stag->parse($file);
@persons = $doc->find("person");
foreach $p (@person) {
printf "%s, %s phone:%sn",
$p->sget("family_name"),
$p->sget("given_name"),
$p->sget("phone_no"),
;
}
This module is for manipulating data as hierarchical tag/value pairs (Structured TAGs or Simple Tree AGgreggates).
<<lessSYNOPSIS
# PROCEDURAL USAGE
use Data::Stag qw(:all);
$doc = stag_parse($file);
@persons = stag_find($doc, "person");
foreach $p (@persons) {
printf "%s, %s phone: %sn",
stag_sget($p, "family_name"),
stag_sget($p, "given_name"),
stag_sget($p, "phone_no"),
;
}
# OBJECT-ORIENTED USAGE
use Data::Stag;
$doc = Data::Stag->parse($file);
@persons = $doc->find("person");
foreach $p (@person) {
printf "%s, %s phone:%sn",
$p->sget("family_name"),
$p->sget("given_name"),
$p->sget("phone_no"),
;
}
This module is for manipulating data as hierarchical tag/value pairs (Structured TAGs or Simple Tree AGgreggates).
Download (0.43MB)
Added: 2006-10-03 License: Perl Artistic License Price:
1117 downloads
File::Data 1.12
File::Data is a Perl module as a interface to file data. more>>
File::Data is a Perl module as a interface to file data.
Wraps all the accessing of a file into a convenient set of calls for reading and writing data, including a simple regex interface.
Note that the file needs to exist prior to using this module!
See new()
SYNOPSIS
use strict;
use File::Data;
my $o_dat = File::Data->new(./t/example);
$o_dat->write("complete file contentsn");
$o_dat->prepend("first linen"); # line 0
$o_dat->append("original second (last) linen");
$o_dat->insert(2, "new second linen"); # inc. zero!
$o_dat->replace(line, LINE);
print $o_dat->READ;
Or, perhaps more seriously :-}
my $o_sgm = File::Data->new(./sgmlfile);
print "new SGML data: ".$o_sgm->REPLACE(
s*((?s).*)s* ,
qq| key="val" |,
) if $o_sgm;
See METHODS and EXAMPLES.
IMPORTANT
lowercase method calls return the object itself, so you can chain calls.
my $o_obj = $o_dat->read; # ! READ; # !<<less
Wraps all the accessing of a file into a convenient set of calls for reading and writing data, including a simple regex interface.
Note that the file needs to exist prior to using this module!
See new()
SYNOPSIS
use strict;
use File::Data;
my $o_dat = File::Data->new(./t/example);
$o_dat->write("complete file contentsn");
$o_dat->prepend("first linen"); # line 0
$o_dat->append("original second (last) linen");
$o_dat->insert(2, "new second linen"); # inc. zero!
$o_dat->replace(line, LINE);
print $o_dat->READ;
Or, perhaps more seriously :-}
my $o_sgm = File::Data->new(./sgmlfile);
print "new SGML data: ".$o_sgm->REPLACE(
s*((?s).*)s* ,
qq| key="val" |,
) if $o_sgm;
See METHODS and EXAMPLES.
IMPORTANT
lowercase method calls return the object itself, so you can chain calls.
my $o_obj = $o_dat->read; # ! READ; # !<<less
Download (0.013MB)
Added: 2007-04-26 License: Perl Artistic License Price:
914 downloads
Data::Diff 0.01
Data::Diff is a data structure comparison module. more>>
Data::Diff is a data structure comparison module.
SYNOPSIS
use Data::Diff qw(diff);
# simple procedural interface to raw difference output
$out = diff( $a, $b );
# OO usage
$diff = Data::Diff->new( $a, $b );
$new = $diff->apply();
$changes = $diff->diff_a();
Data::Diff computes the differences between two abirtray complex data structures.
METHODS
Creation
new Data::Diff( $a, $b, $options )
Creates and retruns a new Data::Diff object with the differences between $a and $b.
Access
apply( $options )
Returns the result of applying one side over the other.
raw()
Returns the internal data structure that describes the differences at all levels within.
Functions
Diff( $a, $b, $options )
Compares the two arguments $a and $b and returns the raw comparison between the two.
EXPORT
Nothing by default but you can choose to export the non-OO function Diff().
<<lessSYNOPSIS
use Data::Diff qw(diff);
# simple procedural interface to raw difference output
$out = diff( $a, $b );
# OO usage
$diff = Data::Diff->new( $a, $b );
$new = $diff->apply();
$changes = $diff->diff_a();
Data::Diff computes the differences between two abirtray complex data structures.
METHODS
Creation
new Data::Diff( $a, $b, $options )
Creates and retruns a new Data::Diff object with the differences between $a and $b.
Access
apply( $options )
Returns the result of applying one side over the other.
raw()
Returns the internal data structure that describes the differences at all levels within.
Functions
Diff( $a, $b, $options )
Compares the two arguments $a and $b and returns the raw comparison between the two.
EXPORT
Nothing by default but you can choose to export the non-OO function Diff().
Download (0.006MB)
Added: 2007-07-13 License: Perl Artistic License Price:
833 downloads
Data::ICal 0.11
Data::ICal is a Perl module that generates iCalendar (RFC 2445) calendar files. more>>
Data::ICal is a Perl module that generates iCalendar (RFC 2445) calendar files.
SYNOPSIS
use Data::ICal;
my $calendar = Data::ICal->new();
my $vtodo = Data::ICal::Entry::Todo->new();
$vtodo->add_properties(
# ... see Data::ICal::Entry::Todo documentation
);
# ... or
$calendar = Data::ICal->new(filename => foo.ics); # parse existing file
$calendar = Data::ICal->new(data => BEGIN:VCALENDAR...); # parse existing file
$calendar->add_entry($vtodo);
print $calendar->as_string;
# Or, if youre printing to something you want google to read:
print $calendar->as_string(fold => 0);
A Data::ICal object represents a VCALENDAR object as defined in the iCalendar protocol (RFC 2445, MIME type "text/calendar"), as implemented in many popular calendaring programs such as Apples iCal.
Each Data::ICal object is a collection of "entries", which are objects of a subclass of Data::ICal::Entry. The types of entries defined by iCalendar (which refers to them as "components") include events, to-do items, journal entries, free/busy time indicators, and time zone descriptors; in addition, events and to-do items can contain alarm entries. (Currently, Data::ICal only implements to-do items and events.)
Data::ICal is a subclass of Data::ICal::Entry; see its manpage for more methods applicable to Data::ICal.
<<lessSYNOPSIS
use Data::ICal;
my $calendar = Data::ICal->new();
my $vtodo = Data::ICal::Entry::Todo->new();
$vtodo->add_properties(
# ... see Data::ICal::Entry::Todo documentation
);
# ... or
$calendar = Data::ICal->new(filename => foo.ics); # parse existing file
$calendar = Data::ICal->new(data => BEGIN:VCALENDAR...); # parse existing file
$calendar->add_entry($vtodo);
print $calendar->as_string;
# Or, if youre printing to something you want google to read:
print $calendar->as_string(fold => 0);
A Data::ICal object represents a VCALENDAR object as defined in the iCalendar protocol (RFC 2445, MIME type "text/calendar"), as implemented in many popular calendaring programs such as Apples iCal.
Each Data::ICal object is a collection of "entries", which are objects of a subclass of Data::ICal::Entry. The types of entries defined by iCalendar (which refers to them as "components") include events, to-do items, journal entries, free/busy time indicators, and time zone descriptors; in addition, events and to-do items can contain alarm entries. (Currently, Data::ICal only implements to-do items and events.)
Data::ICal is a subclass of Data::ICal::Entry; see its manpage for more methods applicable to Data::ICal.
Download (0.10MB)
Added: 2006-12-01 License: Perl Artistic License Price:
1059 downloads
Gimp::Data 1.211
Gimp::Data is a Perl module to set and get state data. more>>
Gimp::Data is a Perl module to set and get state data.
SYNOPSIS
use Gimp::Data;
$Gimp::Data{value1} = "Hello";
print $Gimp::Data{value1},", World!!n";
With this module, you can access plugin-specific (or global) data in Gimp, i.e. you can store and retrieve values that are stored in the main Gimp application.
An example would be to save parameter values in Gimp, so that on subsequent invocations of your plug-in, the user does not have to set all parameter values again (Gimp::Fu does this already).
<<lessSYNOPSIS
use Gimp::Data;
$Gimp::Data{value1} = "Hello";
print $Gimp::Data{value1},", World!!n";
With this module, you can access plugin-specific (or global) data in Gimp, i.e. you can store and retrieve values that are stored in the main Gimp application.
An example would be to save parameter values in Gimp, so that on subsequent invocations of your plug-in, the user does not have to set all parameter values again (Gimp::Fu does this already).
Download (0.26MB)
Added: 2006-10-26 License: Perl Artistic License Price:
1093 downloads
Data::ENAML 0.03
Data::ENAML is a Perl extension for ENAML data representation. more>>
Data::ENAML is a Perl extension for ENAML data representation.
SYNOPSIS
use Data::ENAML qw (serialize deserialize);
print serialize(login => {nick => Schop,
email => ariel@atheist.org.il,
tagline => If I had no modem I would not lose Regina});
$struct = deserialize(bad-nick: {nick: "c00l dewd" text: "spaces not allowed"});
ENAML stands for ENAML is Not A Markup Language. (And as we all know, Gnu is Not UNIX, Pine Is Not Email, Wine Is Not Emulator, Lame Aint Mp3 Encoder and so on).
ENAML was defined by Robey Pointer for use in Say2, check http://www.lag.net/say2.
<<lessSYNOPSIS
use Data::ENAML qw (serialize deserialize);
print serialize(login => {nick => Schop,
email => ariel@atheist.org.il,
tagline => If I had no modem I would not lose Regina});
$struct = deserialize(bad-nick: {nick: "c00l dewd" text: "spaces not allowed"});
ENAML stands for ENAML is Not A Markup Language. (And as we all know, Gnu is Not UNIX, Pine Is Not Email, Wine Is Not Emulator, Lame Aint Mp3 Encoder and so on).
ENAML was defined by Robey Pointer for use in Say2, check http://www.lag.net/say2.
Download (0.004MB)
Added: 2006-11-15 License: Perl Artistic License Price:
1073 downloads
Data::Secs2 0.09
Data::Secs2 is a Perl module to pack, unpack, format, transform from Perl data SEMI E5-94 nested data. more>>
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.
<<lessSYNOPSIS
#####
# 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.
Download (0.096MB)
Added: 2007-02-15 License: Perl Artistic License Price:
981 downloads
Data::CTable 1.03
Data::CTable is a Perl module that helps you read, write, manipulate tabular data. more>>
Data::CTable is a Perl module that helps you read, write, manipulate tabular data.
SYNOPSIS
## Read some data files in various tabular formats
use Data::CTable;
my $People = Data::CTable->new("people.merge.mac.txt");
my $Stats = Data::CTable->new("stats.tabs.unix.txt");
## Clean stray whitespace in fields
$People->clean_ws();
$Stats ->clean_ws();
## Retrieve columns
my $First = $People->col(FirstName);
my $Last = $People->col(LastName );
## Calculate a new column based on two others
my $Full = [map {"$First->[$_] $Last->[$_]"} @{$People->all()}];
## Add new column to the table
$People->col(FullName => $Full);
## Another way to calculate a new column
$People->col(Key);
$People->calc(sub {no strict vars; $Key = "$Last,$First";});
## "Left join" records matching Stats:PersonID to People:Key
$Stats->join($People, PersonID => Key);
## Find certain records
$Stats->select_all();
$Stats->select(Department => sub {/Sale/i }); ## Sales depts
$Stats->omit (Department => sub {/Resale/i}); ## not Resales
$Stats->select(UsageIndex => sub {$_ > 20.0}); ## high usage
## Sort the found records
$Stats->sortspec(DeptNum , {SortType => Integer});
$Stats->sortspec(UsageIndex, {SortType => Number });
$Stats->sort([qw(DeptNum UsageIndex Last First)]);
## Make copy of table with only found/sorted data, in order
my $Report = $Stats->snapshot();
## Write an output file
$Report->write(_FileName => "Rept.txt", _LineEnding => "mac");
## Print a final progress message.
$Stats->progress("Done!");
## Dozens more methods and parameters available...
OVERVIEW
Data::CTable is a comprehensive utility for reading, writing, manipulating, cleaning and otherwise transforming tabular data. The distribution includes several illustrative subclasses and utility scripts.
A Columnar Table represents a table as a hash of data columns, making it easy to do data cleanup, formatting, searching, calculations, joins, or other complex operations.
The objects hash keys are the field names and the hash values hold the data columns (as array references).
Tables also store a "selection" -- a list of selected / sorted record numbers, and a "field list" -- an ordered list of all or some fields to be operated on. Select() and sort() methods manipulate the selection list. Later, you can optionally rewrite the table in memory or on disk to reflect changes in the selection list or field list.
Data::CTable reads and writes any tabular text file format including Merge, CSV, Tab-delimited, and variants. It transparently detects, reads, and preserves Unix, Mac, and/or DOS line endings and tab or comma field delimiters -- regardless of the runtime platform.
In addition to reading data files, CTable is a good way to gather, store, and operate on tabular data in memory, and to export data to delimited text files to be read by other programs or interactive productivity applications.
To achieve extremely fast data loading, CTable caches data file contents using the Storable module. This can be helpful in CGI environments or when operating on very large data files. CTable can read an entire cached table of about 120 megabytes into memory in about 10 seconds on an average mid-range computer.
For simple data-driven applications needing to store and quickly retrieve simple tabular data sets, CTable provides a credible alternative to DBM files or SQL.
For data hygiene applications, CTable forms the foundation for writing utility scripts or compilers to transfer data from external sources, such as FileMaker, Excel, Access, personal organizers, etc. into compiled or validated formats -- or even as a gateway to loading data into SQL databases or other destinations. You can easily write short, repeatable scripts in Perl to do reporting, error checking, analysis, or validation that would be hard to duplicate in less-flexible application environments.
The data representation is simple and open so you can directly access the data in the object if you feel like it -- or you can use accessors to request "clean" structures containing only the data or copies of it. Or you can build your own columns in memory and then when youre ready, turn them into a table object using the very flexible new() method.
The highly factored interface and implementation allow fine-grained subclassing so you can easily create useful lightweight subclasses. Several subclasses are included with the distribution.
Most defaults and parameters can be customized by subclassing, overridden at the instance level (avoiding the need to subclass too often), and further overridden via optional named-parameter arguments to most major method calls.
<<lessSYNOPSIS
## Read some data files in various tabular formats
use Data::CTable;
my $People = Data::CTable->new("people.merge.mac.txt");
my $Stats = Data::CTable->new("stats.tabs.unix.txt");
## Clean stray whitespace in fields
$People->clean_ws();
$Stats ->clean_ws();
## Retrieve columns
my $First = $People->col(FirstName);
my $Last = $People->col(LastName );
## Calculate a new column based on two others
my $Full = [map {"$First->[$_] $Last->[$_]"} @{$People->all()}];
## Add new column to the table
$People->col(FullName => $Full);
## Another way to calculate a new column
$People->col(Key);
$People->calc(sub {no strict vars; $Key = "$Last,$First";});
## "Left join" records matching Stats:PersonID to People:Key
$Stats->join($People, PersonID => Key);
## Find certain records
$Stats->select_all();
$Stats->select(Department => sub {/Sale/i }); ## Sales depts
$Stats->omit (Department => sub {/Resale/i}); ## not Resales
$Stats->select(UsageIndex => sub {$_ > 20.0}); ## high usage
## Sort the found records
$Stats->sortspec(DeptNum , {SortType => Integer});
$Stats->sortspec(UsageIndex, {SortType => Number });
$Stats->sort([qw(DeptNum UsageIndex Last First)]);
## Make copy of table with only found/sorted data, in order
my $Report = $Stats->snapshot();
## Write an output file
$Report->write(_FileName => "Rept.txt", _LineEnding => "mac");
## Print a final progress message.
$Stats->progress("Done!");
## Dozens more methods and parameters available...
OVERVIEW
Data::CTable is a comprehensive utility for reading, writing, manipulating, cleaning and otherwise transforming tabular data. The distribution includes several illustrative subclasses and utility scripts.
A Columnar Table represents a table as a hash of data columns, making it easy to do data cleanup, formatting, searching, calculations, joins, or other complex operations.
The objects hash keys are the field names and the hash values hold the data columns (as array references).
Tables also store a "selection" -- a list of selected / sorted record numbers, and a "field list" -- an ordered list of all or some fields to be operated on. Select() and sort() methods manipulate the selection list. Later, you can optionally rewrite the table in memory or on disk to reflect changes in the selection list or field list.
Data::CTable reads and writes any tabular text file format including Merge, CSV, Tab-delimited, and variants. It transparently detects, reads, and preserves Unix, Mac, and/or DOS line endings and tab or comma field delimiters -- regardless of the runtime platform.
In addition to reading data files, CTable is a good way to gather, store, and operate on tabular data in memory, and to export data to delimited text files to be read by other programs or interactive productivity applications.
To achieve extremely fast data loading, CTable caches data file contents using the Storable module. This can be helpful in CGI environments or when operating on very large data files. CTable can read an entire cached table of about 120 megabytes into memory in about 10 seconds on an average mid-range computer.
For simple data-driven applications needing to store and quickly retrieve simple tabular data sets, CTable provides a credible alternative to DBM files or SQL.
For data hygiene applications, CTable forms the foundation for writing utility scripts or compilers to transfer data from external sources, such as FileMaker, Excel, Access, personal organizers, etc. into compiled or validated formats -- or even as a gateway to loading data into SQL databases or other destinations. You can easily write short, repeatable scripts in Perl to do reporting, error checking, analysis, or validation that would be hard to duplicate in less-flexible application environments.
The data representation is simple and open so you can directly access the data in the object if you feel like it -- or you can use accessors to request "clean" structures containing only the data or copies of it. Or you can build your own columns in memory and then when youre ready, turn them into a table object using the very flexible new() method.
The highly factored interface and implementation allow fine-grained subclassing so you can easily create useful lightweight subclasses. Several subclasses are included with the distribution.
Most defaults and parameters can be customized by subclassing, overridden at the instance level (avoiding the need to subclass too often), and further overridden via optional named-parameter arguments to most major method calls.
Download (0.15MB)
Added: 2007-07-13 License: Perl Artistic License Price:
833 downloads
Audio::Data 1.029
Audio::Data is a module for representing audio data to perl. more>>
Audio::Data is a module for representing audio data to perl.
SYNOPSIS
use Audio::Data;
my $audio = Audio::Data->new(rate => , ...);
$audio->method(...)
$audio OP ...
Audio::Data represents audio data to perl in a fairly compact and efficient manner using C via XS to hold data as a C array of float values. The use of float avoids many issues with dynamic range, and typical float has 24-bit mantissa so quantization noise should be acceptable. Many machines have floating point hardware these days, and in such cases operations on float should be as fast or faster than some kind of "scaled integer".
Nominally data is expected to be between +1.0 and -1.0 - although only code which interacts with outside world (reading/writing files or devices) really cares.
It can also represent elements (samples) which are "complex numbers" which simplifies many Digital Signal Processing methods.
Methods
The interface is object-oriented, and provides the methods below.
$audio = Audio::Data->new([method => value ...])
The "constructor" - takes a list of method/value pairs and calls $audio->method(value) on the object in order. Typically first "method" will be rate to set sampling rate of the object.
$rate = $audio->rate
Get sampling rate of object.
$audio->rate($newrate)
Set sampling rate of the object. If object contains existing data it is re-sampled to the new rate. (Code to do this was derived from a now dated version of sox.)
$audio->comment($string)
Sets simple string comment associated with data.
$string = $audio->comment
Get the comment
$time = $audio->duration
Return duration of object (in seconds).
$time = $audio->samples
Return number of samples in the object.
@data = $audio->data
Return data as list of values - not recommended for large data.
$audio->data(@data)
Sets elements from @data.
$audio->length($N)
Set number of samples to $N - tuncating or padding with zeros (silence).
($max,$min) = $audio->bounds([$start_time[,$end_time]])
Returns a list of two values representing the limits of the values between the two times if $end_time isnt specified it defaults to the duration of the object, and if start time isnt specified it defaults to zero.
$copy = $audio->clone
Creates copy of data carrying over sample rate and complex-ness of data.
$slice = $audio->timerange($start_time,$end_time);
Returns a time-slice between specified times.
$audio->Load($fh)
Reads Sun/NeXT .au data from the perl file handle (which should have binmode() applied to it.)
This will eventually change - to allow it to load other formats and perhaps to return list of Audio::Data objects to represnt multiple channels (e.g. stereo).
$audio->Save($fh[,$comment])
Write a Sun/NeXT .au file to perl file handle. $comment if specified is used as the comment.
$audio->tone($freq,$dur,$amp);
Append a sinusoidal tone of specified freqency (in Hz) and duration (in seconds), and peak amplitude $amp.
$audio->silence($dur);
Append a period of 0 value of specified duration.
$audio->noise($dur,$amp);
Append burst of (white) noise of specified duration and peak amplitude.
$window = $audio->hamming($SIZE,$start_sample[,$k])
Returns a "raised cosine window" sample of $SIZE samples starting at specified sample. If $k is specified it overrides the default value of 0.46 (e.g. a value of 0.5 would give a Hanning window as opposed to a Hamming window.)
windowed = ((1.0-k)+k*cos(x*PI))
$freq = $audio->fft($SIZE)
$time = $freq->ifft($SIZE);
Perform a Fast Fourier Transform (or its inverse). (Note that in general result of these methods have complex numbers as the elements. $SIZE should be a power-of-two (if it isnt next larger power of two is used). Data is padded with zeros as necessary to get to $SIZE samples.
@values = $audio->amplitude([$N[,$count]])
Return values of amplitude for sample $N..$N+$count inclusive. if $N is not specified it defaults to zero. If $count is not specified it defaults to 1 for scalar context and rest-of-data in array context.
@values = $audio->dB([$N[,$count]])
Return amplitude - in deci-Bells. (0dB is 1/2**15 i.e. least detectable value to 16-bit device.) Defaults as for amplitude.
@values = $audio->phase([$N [,$count]])
Return Phase - (if data are real returns 0). Defaults as for amplitude.
$diff = $audio->difference
Returns the first difference between successive elements of the data - so result is one sample shorter. This is a simple high-pass filter and is much used to remove DC offsets.
$Avalues = $audio->lpc($NUM_POLES,[$auto [,$refl]])
Perform Linear Predictive Coding analysis of $audio and return coefficents of resulting All-Pole filter. 0th Element is not a filter coefficent (there is no A[0] in such a filter) - but is a measure of the "error" in the matching process. $auto is an output argument and returns computed autocorrelation. $refl is also output and are so-called reflection coefficents used in "lattice" realization of the filter. (Code for this lifted from "Festival" speech systems speech_tools.)
$auto = $audio->autocorrelation($LENGTH)
Returns an (unscaled) autocorrelation function - can be used to cause peaks when data is periodic - and is used as a precursor to LPC analysis.
<<lessSYNOPSIS
use Audio::Data;
my $audio = Audio::Data->new(rate => , ...);
$audio->method(...)
$audio OP ...
Audio::Data represents audio data to perl in a fairly compact and efficient manner using C via XS to hold data as a C array of float values. The use of float avoids many issues with dynamic range, and typical float has 24-bit mantissa so quantization noise should be acceptable. Many machines have floating point hardware these days, and in such cases operations on float should be as fast or faster than some kind of "scaled integer".
Nominally data is expected to be between +1.0 and -1.0 - although only code which interacts with outside world (reading/writing files or devices) really cares.
It can also represent elements (samples) which are "complex numbers" which simplifies many Digital Signal Processing methods.
Methods
The interface is object-oriented, and provides the methods below.
$audio = Audio::Data->new([method => value ...])
The "constructor" - takes a list of method/value pairs and calls $audio->method(value) on the object in order. Typically first "method" will be rate to set sampling rate of the object.
$rate = $audio->rate
Get sampling rate of object.
$audio->rate($newrate)
Set sampling rate of the object. If object contains existing data it is re-sampled to the new rate. (Code to do this was derived from a now dated version of sox.)
$audio->comment($string)
Sets simple string comment associated with data.
$string = $audio->comment
Get the comment
$time = $audio->duration
Return duration of object (in seconds).
$time = $audio->samples
Return number of samples in the object.
@data = $audio->data
Return data as list of values - not recommended for large data.
$audio->data(@data)
Sets elements from @data.
$audio->length($N)
Set number of samples to $N - tuncating or padding with zeros (silence).
($max,$min) = $audio->bounds([$start_time[,$end_time]])
Returns a list of two values representing the limits of the values between the two times if $end_time isnt specified it defaults to the duration of the object, and if start time isnt specified it defaults to zero.
$copy = $audio->clone
Creates copy of data carrying over sample rate and complex-ness of data.
$slice = $audio->timerange($start_time,$end_time);
Returns a time-slice between specified times.
$audio->Load($fh)
Reads Sun/NeXT .au data from the perl file handle (which should have binmode() applied to it.)
This will eventually change - to allow it to load other formats and perhaps to return list of Audio::Data objects to represnt multiple channels (e.g. stereo).
$audio->Save($fh[,$comment])
Write a Sun/NeXT .au file to perl file handle. $comment if specified is used as the comment.
$audio->tone($freq,$dur,$amp);
Append a sinusoidal tone of specified freqency (in Hz) and duration (in seconds), and peak amplitude $amp.
$audio->silence($dur);
Append a period of 0 value of specified duration.
$audio->noise($dur,$amp);
Append burst of (white) noise of specified duration and peak amplitude.
$window = $audio->hamming($SIZE,$start_sample[,$k])
Returns a "raised cosine window" sample of $SIZE samples starting at specified sample. If $k is specified it overrides the default value of 0.46 (e.g. a value of 0.5 would give a Hanning window as opposed to a Hamming window.)
windowed = ((1.0-k)+k*cos(x*PI))
$freq = $audio->fft($SIZE)
$time = $freq->ifft($SIZE);
Perform a Fast Fourier Transform (or its inverse). (Note that in general result of these methods have complex numbers as the elements. $SIZE should be a power-of-two (if it isnt next larger power of two is used). Data is padded with zeros as necessary to get to $SIZE samples.
@values = $audio->amplitude([$N[,$count]])
Return values of amplitude for sample $N..$N+$count inclusive. if $N is not specified it defaults to zero. If $count is not specified it defaults to 1 for scalar context and rest-of-data in array context.
@values = $audio->dB([$N[,$count]])
Return amplitude - in deci-Bells. (0dB is 1/2**15 i.e. least detectable value to 16-bit device.) Defaults as for amplitude.
@values = $audio->phase([$N [,$count]])
Return Phase - (if data are real returns 0). Defaults as for amplitude.
$diff = $audio->difference
Returns the first difference between successive elements of the data - so result is one sample shorter. This is a simple high-pass filter and is much used to remove DC offsets.
$Avalues = $audio->lpc($NUM_POLES,[$auto [,$refl]])
Perform Linear Predictive Coding analysis of $audio and return coefficents of resulting All-Pole filter. 0th Element is not a filter coefficent (there is no A[0] in such a filter) - but is a measure of the "error" in the matching process. $auto is an output argument and returns computed autocorrelation. $refl is also output and are so-called reflection coefficents used in "lattice" realization of the filter. (Code for this lifted from "Festival" speech systems speech_tools.)
$auto = $audio->autocorrelation($LENGTH)
Returns an (unscaled) autocorrelation function - can be used to cause peaks when data is periodic - and is used as a precursor to LPC analysis.
Download (0.086MB)
Added: 2006-06-19 License: GPL (GNU General Public License) Price:
1222 downloads
Data::Report 0.06
Data::Report provides a framework for flexible reporting. more>>
Data::Report provides a framework for flexible reporting.
Data::Report is a flexible, plugin-driven reporting framework. It makes it easy to define reports that can be produced in text, HTML and CSV. Textual ornaments like extra empty lines, dashed lines, and cell lines can be added in a way similar to HTML style sheets.
The Data::Report framework consists of three parts:
The plugins
Plugins implement a specific type of report. Standard plugins provided are Data::Report::Plugin::Text for textual reports, Data::Report::Plugin::Html for HTML reports, and Data::Report::Plugin::Csv for CSV (comma-separated) files.
Users can, and are encouraged, to develop their own plugins to handle different styles and types of reports.
The base class
The base class Data::Report::Base implements the functionality common to all reporters, plus a number of utility functions the plugins can use.
The factory
The actual Data::Report module is a factory that creates a reporter for a given report type by selecting the appropriate plugin and returning an instance thereof.
<<lessData::Report is a flexible, plugin-driven reporting framework. It makes it easy to define reports that can be produced in text, HTML and CSV. Textual ornaments like extra empty lines, dashed lines, and cell lines can be added in a way similar to HTML style sheets.
The Data::Report framework consists of three parts:
The plugins
Plugins implement a specific type of report. Standard plugins provided are Data::Report::Plugin::Text for textual reports, Data::Report::Plugin::Html for HTML reports, and Data::Report::Plugin::Csv for CSV (comma-separated) files.
Users can, and are encouraged, to develop their own plugins to handle different styles and types of reports.
The base class
The base class Data::Report::Base implements the functionality common to all reporters, plus a number of utility functions the plugins can use.
The factory
The actual Data::Report module is a factory that creates a reporter for a given report type by selecting the appropriate plugin and returning an instance thereof.
Download (0.016MB)
Added: 2007-03-31 License: Perl Artistic License Price:
937 downloads
Data::Walker 1.05
Data::Walker is a tool for navigating through Perl data structures. more>>
Data::Walker is a tool for navigating through Perl data structures.
SYNOPSIS
Without any explicit objects:
use Data::Walker;
Data::Walker->cli( $data_structure );
Object-style invocation:
use Data::Walker;
my $w = new Data::Walker;
$w->walk( $data_structure );
$w->ls("-al");
$w->pwd;
$w->cli;
Importing methods into the current package:
use Data::Walker qw(:direct);
walk $data_structure;
ls "-al";
pwd;
cli;
This module allows you to "walk" an arbitrary Perl data structure in the same way that you can walk a directory tree from a UNIX command line. It reuses familiar unix commands (such as "ls", "cd", "pwd") and applies these to data structures.
It has a command-line interface which behaves like a UNIX shell. You can also use object-style sytax to invoke the CLI commands from outside the CLI. Data::Walker objects are encapsulated, so that you can hop into and out of a CLI without losing state, and you can have several Data::Walker objects pointing at different structures.
The main functions can also be imported and used directly from within the Perl debuggers CLI.
<<lessSYNOPSIS
Without any explicit objects:
use Data::Walker;
Data::Walker->cli( $data_structure );
Object-style invocation:
use Data::Walker;
my $w = new Data::Walker;
$w->walk( $data_structure );
$w->ls("-al");
$w->pwd;
$w->cli;
Importing methods into the current package:
use Data::Walker qw(:direct);
walk $data_structure;
ls "-al";
pwd;
cli;
This module allows you to "walk" an arbitrary Perl data structure in the same way that you can walk a directory tree from a UNIX command line. It reuses familiar unix commands (such as "ls", "cd", "pwd") and applies these to data structures.
It has a command-line interface which behaves like a UNIX shell. You can also use object-style sytax to invoke the CLI commands from outside the CLI. Data::Walker objects are encapsulated, so that you can hop into and out of a CLI without losing state, and you can have several Data::Walker objects pointing at different structures.
The main functions can also be imported and used directly from within the Perl debuggers CLI.
Download (0.020MB)
Added: 2007-06-30 License: Perl Artistic License Price:
846 downloads
Data::CGIForm 0.4
Data::CGIForm is a Perl module with form data interface. more>>
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;
<<lessData::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;
Download (0.012MB)
Added: 2006-10-04 License: Perl Artistic License Price:
1115 downloads
Secleted [ 0 ] software to compare
Copyright Notice:
Software piracy is theft, Using crack, password, serial numbers, registration codes, key generators is illegal and prevent future software development. The above data in search only lists software in full, demo and trial versions for free download. Download links are directly from our mirror sites or publisher sites, torrent files or links from rapidshare.com, yousendit.com or megaupload.com are not allowed
