NAME

Set::IntSpan::Island - extension for Set::IntSpan to handle islands and covers

SYNOPSIS

use Set::IntSpan::Island

# inherits normal behaviour from Set::IntSpan
$set = Set::IntSpan::Enhanced->new( $set_spec );
# special two-value input creates a range a-b
$set = Set::IntSpan::Enhanced->new( $a,$b );

# equivalent to $set->cardinality($another_set)->size;
if ($set->overlap( $another_set )) { ... }

# negative if overlap, positive if no overlap
$distance = $set->distance( $another_set );

# remove islands shorter than $minlength
$set = $set->remove_short( $minlength );

# fill holes up to $maxholesize
$set = $set->fill( $maxholesize );

# return a set composed of islands of $set that overlap $another_set
$set = $set->find_island( $another_set );

# return a set comopsed of the nearest non-overlapping island(s) to $another_set
$set = $set->nearest_island( $another_set );

# construct a list of covers by exhaustively intersecting all sets
@covers = Set::IntSpan::Island->extract_cover( { id1=>$set1, id2=>set2, ... } );
for $cover (@covers) {
  ($coverset,@ids) = ($cover->[0], @{$cover->[1]});
  print "cover",$coverset->run_list,"contains sets",join(",",@ids);
}

DESCRIPTION

Data Structure

This module extends the Set::IntSpan module. It adds a number of methods to Set::IntSpan that are specific to islands and covers. An integer set, as represented by Set::IntSpan, is a collection of covers on the integer line

...-----xxxx----xxxxxxxx---xxxxxxxx---xx---x----....

Terminology

An integer set may be composed of one or more contiguous spans. In this module, spans are called islands. Regions not in the set that fall between adjacent spans are termed holes. For example, this set

...-----xxxxx----xx---x-----...

has three islands and two holes. Since this is a finite set, the two infinite regions on either side of the set are not counted as holes within the context of this module.

Operations

This module permits the following operations, here shown graphically. Each method is described fully in the METHODS section.

METHODS

$set = Set::IntSpan::Enhanced->new( $set_spec )

Constructs a set using the set specification as supported by Set::IntSpan.

$set = Set::IntSpan::Enhanced->new( $a, $b )

Extension to Set::IntSpan new method, this double-argument version creates a set formed by the range a-b. This is equivalent to

$set = Set::IntSpan::Enhanced->new("$a-$b")

but permits initialization from a list instead of a string.

$set_copy = $set->duplicate()

Creates a copy of $set.

$overlap_amount = $set->overlap( $another_set );

Returns the size of intersection of two sets. Equivalent to

$set->intersect( $another_set )->size;

$d = $set->distance( $another_set )

Returns the distance between sets, measured as follows. If the sets overlap, then the distance is negative and given by

$d = - $set->overlap( $another_set )

If the sets do not overlap, $d is positive and given by the distance on the integer line between the two closest islands of the sets.

$d = $set->sets()

Returns all spans in $set as Set::IntSpan::Island objects.

$set = $set->excise( $minlength)

Removes all islands within $set smaller than $minlength.

$set = $set->fill( $maxlength)

Fills in all holes in $set smaller than $maxlength.

$set = $set->find_islands( $integer )

Returns a set containing the island in $set containing $integer. If $integer is not in $set, an empty set is returned.

$set = $set->find_islands( $another_set )

Returns a set containing all islands in $set intersecting $another_set. If $set and $another_set have an empty intersection, an empty set is returned.

$set = $set->nearest_island( $integer )

Returns the nearest island(s) in $set that contains, but does not overlap with, $integer. If $integer lies exactly between two islands, then the returned set contains these two islands.

$set = $set->nearest_island( $another_set );

Returns the nearest island(s) in $set that intersects, but does not overlap with, $another_set. If $another_set lies exactly between two islands, then the returned set contains these two islands.

$cover_data = extract_covers( $set_hash_ref )

Given a $set_hash reference

{ id1=>$set1, id2=>$set2, ..., idn=>$setn}

where $setj is a finite Set::IntSpan::Enhanced object and idj is a unique key, extract_covers performs an exhaustive intersection of all sets and returns a list of all covers and set memberships. For example, given the id/runlist combination

a  10-15
b  12
c  14-20
d  25

The covers are

10-11 a
12    a b
13    a
14-15 a c
16-20 c
21-24 -
25    d

The cover data is returned as an array reference and its structure is

[ [ $cover_set1, [ id11, id12, id13, ... ] ],
  [ $cover_set2, [ id21, id22, id23, ... ] ],
  ...
]

If a cover contains no elements, then its entry is

[ $cover_set, [ ] ]

AUTHOR

Martin Krzywinski <martink@bcgsc.ca>

ACKNOWLEDGMENTS

• Steve McDougall <swmcd@theworld.com>

HISTORY

v0.01 5 Mar 2007

SEE ALSO

Set::IntSpan by Steven McDougall

COPYRIGHT

Copyright (c) 2007 by Martin Krzywinski. This module is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

cpanm Set::IntSpan::Island

perl -MCPAN -e shell
install Set::IntSpan::Island