NAME

       Bio::Search::Tiling::MapTileUtils - utilities for manipulating closed intervals for an HSP
       tiling algorithm

SYNOPSIS

       Not used directly.

DESCRIPTION

       Not used directly.

NOTE

       An "interval" in this module is defined as an arrayref "[$a0, $a1]", where "$a0, $a1" are
       scalar numbers satisfying "$a0 <= $a1".

AUTHOR

       Mark A. Jensen - maj -at- fortinbras -dot- us

APPENDIX

   interval_tiling
        Title   : interval_tiling()
        Usage   : @tiling = interval_tiling( \@array_of_intervals )
        Function: Find minimal set of intervals covering the input set
        Returns : array of arrayrefs of the form
         ( [$interval => [ @indices_of_collapsed_input_intervals ]], ...)
        Args    : arrayref of intervals

   decompose_interval
        Title   : decompose_interval
        Usage   : @decomposition = decompose_interval( \@overlappers )
        Function: Calculate the disjoint decomposition of a set of
                  overlapping intervals, each annotated with a list of
                  covering intervals
        Returns : array of arrayrefs of the form
                  ( [[@interval] => [@indices_of_coverers]], ... )
        Args    : arrayref of intervals (arrayrefs like [$a0, $a1], with
        Note    : Each returned interval is associated with a list of indices of the
                  original intervals that cover that decomposition component
                  (scalar size of this list could be called the 'coverage coefficient')
        Note    : Coverage: each component of the decomp is completely contained
                  in the input intervals that overlap it, by construction.
        Caveat  : This routine expects the members of @overlappers to overlap,
                  but doesn't check this.

   are_disjoint
        Title   : are_disjoint
        Usage   : are_disjoint( [$a0, $a1], [$b0, $b1] )
        Function: Determine if two intervals are disjoint
        Returns : True if the intervals are disjoint, false if they overlap
        Args    : array of two intervals

   min_covering_interval
        Title   : min_covering_interval
        Usage   : $interval = min_covering_interval( [$a0,$a1],[$b0,$b1] )
        Function: Determine the minimal covering interval for two intervals
        Returns : an interval
        Args    : two intervals

   get_intervals_from_hsps
        Title   : get_intervals_from_hsps
        Usage   : @intervals = get_intervals_from_hsps($type, @hsp_objects)
        Function: Return array of intervals of the form [ $start, $end ],
                  from an array of hsp objects
        Returns : an array of intervals
        Args    : scalar $type, array of HSPI objects; where $type is one of 'hit',
                  'subject', 'query'

   _allowable_filters
        Title   : _allowable_filters
        Usage   : _allowable_filters($Bio_Search_Hit_HitI, $type)
        Function: Return the HSP filters (strand, frame) allowed,
                  based on the reported algorithm
        Returns : String encoding allowable filters:
                  s = strand, f = frame
                  Empty string if no filters allowed
                  undef if algorithm unrecognized
        Args    : A Bio::Search::Hit::HitI object,
                  scalar $type, one of 'hit', 'subject', 'query';
                  default is 'query'

   _set_attributes
        Title   : _set_attributes
        Usage   : $tiling->_set_attributes()
        Function: Sets attributes for invocant
                  that depend on algorithm name
        Returns : True on success
        Args    : none
        Note    : setting based on the configuration table
                  %alg_lookup

   containing_hsps()
        Title   : containing_hsps
        Usage   : @hsps = containing_hsps($interval, @hsps_to_search)
        Function: Return a list of hsps whose coordinates completely contain the
                  given $interval
        Returns : Array of HSP objects
        Args    : $interval : [$int1, $int2],
                  array of HSP objects

   covering_groups()
        Title   : covering_groups
        Usage   :
        Function: divide a list of **ordered,disjoint** intervals (as from a
                  coverage map) into a set of disjoint covering groups
        Returns : array of arrayrefs, each arrayref a covering set of
                  intervals
        Args    : array of intervals

   matches_MT
        Title   : matches_MT
        Usage   : $hsp->matches($type, $action, $start, $end)
        Purpose   : Get the total number of identical or conserved matches
                    in the query or sbjct sequence for the given HSP. Optionally can
                    report data within a defined interval along the seq.
        Returns   : scalar int
        Args      :
        Comments  : Relies on seq_str('match') to get the string of alignment symbols
                    between the query and sbjct lines which are used for determining
                    the number of identical and conservative matches.
        Note      : Modeled on Bio::Search::HSP::HSPI::matches

   get_SeqFeatures
        Title   : get_SeqFeatures
        Usage   :
        Function: Get the feature objects held by this feature holder.

                  Features which are not top-level are subfeatures of one or
                  more of the returned feature objects, which means that you
                  must traverse the subfeature arrays of each top-level
                  feature object in order to traverse all features associated
                  with this sequence.

                  Top-level features can be obtained by tag, specified in
                  the argument.

                  Use get_all_SeqFeatures() if you want the feature tree
                  flattened into one single array.

        Example :
        Returns : an array of Bio::SeqFeatureI implementing objects
        Args    : [optional] scalar string (feature tag)

   feature_count
        Title   : feature_count
        Usage   : $seq->feature_count()
        Function: Return the number of SeqFeatures attached to a sequence
        Returns : integer representing the number of SeqFeatures
        Args    : None

   add_SeqFeature
        Title   : add_SeqFeature
        Usage   : $seq->add_SeqFeature($feat);
                  $seq->add_SeqFeature(@feat);
        Function: Adds the given feature object (or each of an array of feature
                  objects to the feature array of this
                  sequence. The object passed is required to implement the
                  Bio::SeqFeatureI interface.
        Returns : 1 on success
        Args    : A Bio::SeqFeatureI implementing object, or an array of such objects.

   remove_SeqFeatures
        Title   : remove_SeqFeatures
        Usage   : $seq->remove_SeqFeatures();
        Function: Flushes all attached SeqFeatureI objects.

                  To remove individual feature objects, delete those from the returned
                  array and re-add the rest.
        Example :
        Returns : The array of Bio::SeqFeatureI objects removed from this seq.
        Args    : None