use Bio::Location::Fuzzy;
    my $fuzzylocation = new Bio::Location::Fuzzy(-start => '<30',
						 -end   => 90,
						 -loc_type => '.');

    print "location string is ", $fuzzylocation->to_FTstring(), "\n";
    print "location is of the type ", $fuzzylocation->location_type, "\n";

    use vars qw( %FUZZYCODES %FUZZYPOINTENCODE %FUZZYRANGEENCODE 
		 @LOCATIONCODESBSANE );

    @LOCATIONCODESBSANE = (undef, 'EXACT', 'WITHIN', 'BETWEEN',
			'BEFORE', 'AFTER');

    %FUZZYCODES = ( 'EXACT' => '..', # Position is 'exact
   # Exact position is unknown, but is within the range specified, ((1.2)..100)
		    'WITHIN' => '.', 
		    # 1^2
		    'BETWEEN' => '^',
		    # <100
		    'BEFORE'  => '<',
		    # >10
		    'AFTER'   => '>');   
   
    # The following regular expressions map to fuzzy location types. Every
    # expression must match the complete encoded point string, and must
    # contain two groups identifying min and max. Empty matches are automatic.
    # converted to undef, except for 'EXACT', for which max is set to equal
    # min.
    %FUZZYPOINTENCODE = ( 
			  '\>(\d+)(.{0})' => 'AFTER',
			  '\<(.{0})(\d+)' => 'BEFORE',
			  '(\d+)'  => 'EXACT',
			  '(\d+)(.{0})\>' => 'AFTER',
			  '(.{0})(\d+)\<' => 'BEFORE',
			  '(\d+)\.(\d+)' => 'WITHIN',
			  '(\d+)\^(\d+)' => 'BETWEEN',
		     );
    
    %FUZZYRANGEENCODE  = ( '\.' => 'WITHIN',
			   '\.\.' => 'EXACT',
			   '\^' => 'BETWEEN' );

    my ($class, @args) = @_;
    my $self = $class->SUPER::new(@args);
    my ($loc_type, $start_ext, $start_fuz, $end_ext, $end_fuz) = 
	$self->_rearrange([ qw(LOC_TYPE START_EXT START_FUZ 
			       END_EXT END_FUZ )
			    ], @args);

    $loc_type  && $self->location_type($loc_type);
    $start_ext && $self->max_start($self->min_start + $start_ext);
    $end_ext   && $self->max_end($self->min_end + $end_ext);
    $start_fuz && $self->start_pos_type($start_fuz);
    $end_fuz   && $self->end_pos_type($end_fuz);
    
    return $self;

    my ($self,$value) = @_;
    if( defined $value || ! defined $self->{'_location_type'} ) {
	$value = 'EXACT' unless defined $value;
	if(! defined $FUZZYCODES{$value})  {
	    $value = uc($value);
	    if( $value =~ /\.\./ ) {
		$value = 'EXACT';
	    } elsif( $value =~ /^\.$/ ) {
		$value = 'WITHIN';
	    } elsif( $value =~ /\^/ ) {
		$value = 'BETWEEN';
	    } elsif( $value ne 'EXACT' && $value ne 'WITHIN' && 
		     $value ne 'BETWEEN' ) {
		$self->throw("Did not specify a valid location type");
	    }
	}
	$self->{'_location_type'} = $value;
    }
    return $self->{'_location_type'};

    my($self,$value) = @_;
    if( defined $value ) {
	my ($encode,$min,$max) = $self->_fuzzypointdecode($value);	
	$self->start_pos_type($encode);
	$self->min_start($min);
	$self->max_start($max);
    }
    return $self->SUPER::start();

    my($self,$value) = @_;
    if( defined $value ) {
	my ($encode,$min,$max) = $self->_fuzzypointdecode($value);
	$self->end_pos_type($encode);
	$self->min_end($min);
	$self->max_end($max);
    }
    return $self->SUPER::end();

    my ($self,@args) = @_;

    if(@args) {
	$self->{'_min_start'} = $args[0]; # the value may be undef!
    }
    return $self->{'_min_start'};

    my ($self,@args) = @_;

    if(@args) {
	$self->{'_max_start'} = $args[0]; # the value may be undef!
    }
    return $self->{'_max_start'};

    my ($self,$value) = @_;
    if(defined $value &&  $value =~ /^\d+$/ ) {
	if( $value == 0 ) { $value = 'EXACT'; }
	else { 
	    my $v = $LOCATIONCODESBSANE[$value];
	    if( ! defined $v ) {
		$self->warn("Provided value $value which I don't understand, reverting to 'EXACT'");
		$v = 'EXACT';
	    }
	    $value = $v;
	}
    }
    if(defined($value)) {
	$self->{'_start_pos_type'} = $value;
    }
    return $self->{'_start_pos_type'};

    my ($self,@args) = @_;

    if(@args) {
	$self->{'_min_end'} = $args[0]; # the value may be undef!
    }
    return $self->{'_min_end'};

    my ($self,@args) = @_;

    if(@args) {
	$self->{'_max_end'} = $args[0]; # the value may be undef!
    }
    return $self->{'_max_end'};

    my ($self,$value) = @_;
    if( defined $value && $value =~ /^\d+$/ ) {
	if( $value == 0 ) { $value = 'EXACT'; }
	else { 
	    my $v = $LOCATIONCODESBSANE[$value];
	    if( ! defined $v ) {
		$self->warn("Provided value $value which I don't understand, reverting to 'EXACT'");
		$v = 'EXACT';
	    }
	    $value = $v;
	}
    }

    if(defined($value)) {
	$self->{'_end_pos_type'} = $value;
    }
    return $self->{'_end_pos_type'};

    my ($self) = @_;
    my (%vals) = ( 'start' => $self->start,
		   'min_start' => $self->min_start,
		   'max_start' => $self->max_start,
		   'start_code' => $self->start_pos_type,
		   'end' => $self->end,
		   'min_end' => $self->min_end,
		   'max_end' => $self->max_end,
		   'end_code' => $self->end_pos_type );
    
    my (%strs) = ( 'start' => '',
		   'end'   => '');
    my ($delimiter) = $FUZZYCODES{$self->location_type};
    # I'm lazy, lets do this in a loop since behaviour will be the same for 
    # start and end
    foreach my $point ( qw(start end) ) {
	if( $vals{$point."_code"} ne 'EXACT' ) {
	    
	    if( (!defined $vals{"min_$point"} ||
		 !defined $vals{"max_$point"})
		&& ( $vals{$point."_code"} eq 'WITHIN' || 
		     $vals{$point."_code"} eq 'BETWEEN')
		     ) {
		$vals{"min_$point"} = '' unless defined $vals{"min_$point"};
		$vals{"max_$point"} = '' unless defined $vals{"max_$point"};
		
		$self->warn("Fuzzy codes for start are in a strange state, (".
			    join(",", ($vals{"min_$point"}, 
				       $vals{"max_$point"},
				       $vals{$point."_code"})). ")");
		return '';
	    }
	    if( defined $vals{$point."_code"} && 
		($vals{$point."_code"} eq 'BEFORE' ||
		 $vals{$point."_code"} eq 'AFTER')
		) {
		$strs{$point} .= $FUZZYCODES{$vals{$point."_code"}};
	    } 
	    if( defined $vals{"min_$point"} ) {
		$strs{$point} .= $vals{"min_$point"};
	    }
	    if( defined $vals{$point."_code"} && 
		($vals{$point."_code"} eq 'WITHIN' ||
		 $vals{$point."_code"} eq 'BETWEEN')
		) {
		$strs{$point} .= $FUZZYCODES{$vals{$point."_code"}};
	    }
	    if( defined $vals{"max_$point"} ) {
		$strs{$point} .= $vals{"max_$point"};
	    }
	} else { 
	    $strs{$point} = $vals{$point};
	}
    }
    my $str = $strs{'start'} . $delimiter . $strs{'end'};
    if( $self->strand == -1 ) {
	$str = sprintf("complement(%s)", $str);
    }
    return $str;

    my ($self, $string) = @_;
    return () if( !defined $string);
    # strip off leading and trailing space
    $string =~ s/^\s*(\S+)\s*/$1/;
    foreach my $pattern ( keys %FUZZYPOINTENCODE ) {
	if( $string =~ /^$pattern$/ ) {
	    my ($min,$max) = ($1,$2);
	    if($FUZZYPOINTENCODE{$pattern} eq 'EXACT') {
		$max = $min;
	    } else {
		$max = undef if(length($max) == 0);
		$min = undef if(length($min) == 0);
	    }
	    return ($FUZZYPOINTENCODE{$pattern},$min,$max);
	}
    }
    if( $self->verbose >= 1 ) {
	$self->warn("could not find a valid fuzzy encoding for $string");
    }
    return ();

  bioperl-l@bioperl.org             - General discussion
  http://bio.perl.org/MailList.html - About the mailing lists

  bioperl-bugs@bio.perl.org
  http://bio.perl.org/bioperl-bugs/

  Title   : length
  Usage   : $length = $fuzzy_loc->length();
  Function: Get the length of this location.

            Note that the length of a fuzzy location will always depend
            on the currently active interpretation of start and end. The
            result will therefore vary for different CoordinatePolicy objects.

  Returns : an integer
  Args    : none

  Title   : seq_id
  Usage   : my $seqid = $location->seq_id();
  Function: Get/Set seq_id that location refers to
  Returns : seq_id
  Args    : [optional] seq_id value to set

  Title   : coordinate_policy
  Usage   : $policy = $location->coordinate_policy();
            $location->coordinate_policy($mypolicy); # set may not be possible
  Function: Get the coordinate computing policy employed by this object.

            See Bio::Location::CoordinatePolicyI for documentation about
            the policy object and its use.

            The interface *does not* require implementing classes to accept
            setting of a different policy. The implementation provided here
            does, however, allow to do so.

            Implementors of this interface are expected to initialize every
            new instance with a CoordinatePolicyI object. The implementation
            provided here will return a default policy object if none has
            been set yet. To change this default policy object call this
            method as a class method with an appropriate argument. Note that
            in this case only subsequently created Location objects will be
            affected.

  Returns : A Bio::Location::CoordinatePolicyI implementing object.
  Args    : On set, a Bio::Location::CoordinatePolicyI implementing object.