Image

head

code

item

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

use v6;
unit class Range::SetOps:ver<0.0.4>:auth<zef:Scimon>;



Range::SetOps - Provides set operators geared to work on ranges.


use Range::SetOps;
say 10 (elem) (1.5 .. 15.2);


The standard Set operators work on Ranges by first converting them to lists and
then applying the set operations to these lists.
But Ranges can also represent a Range of possible values for which this type of
comparison does not work well.
The Range::SetOps module aims to provide operators based on the Set operators
but geared to work on Ranges without list conversion.


The following operators have been implemented for continous numerical ranges and
also tested on string and date range.
They also work on Sets of Ranges like those returned by the (|) or ∪ operators.


The following operators already work for continuous Ranges as expected.


The following Operations will return Sets comprising one or more Ranges.
When the Ranges within the Set overlap they will be combined into one larger
Range.


This library is free software; you can redistribute it and/or modify it under
the Artistic License 2.0.



subset SetOfRanges of Set where { $_.keys.all ~~ Range };

sub num_elem( \a, Range:D \b --> Bool ) is pure {
    a >= b.min && a <= b.max;
}

sub non_num_elem( \a, Range:D \b --> Bool ) is pure {
    a ge b.min && a le b.max;
}

multi sub infix:<(elem)> (
    Int:D \a where * ~~ Int,
    Range:D \b --> Bool
) is export is pure {
    num_elem( a, b );
}

multi sub infix:<(elem)> (
    Rational:D \a where * ~~ Rational,
    Range:D \b --> Bool
) is export is pure {
    num_elem( a, b );
}

multi sub infix:<(elem)> (
    Numeric:D \a,
    Range:D \b --> Bool
) is export is pure {
    num_elem( a, b );
}

multi sub infix:<(elem)> (
    Date:D \a,
    Range:D \b --> Bool
) is export is pure {
    num_elem( a, b);
}

multi sub infix:<(elem)> (
    Str:D \a,
    Range:D \b --> Bool
) is export is pure {
    my \ra = Rat(a);
    if ( defined ra ) {
        num_elem( ra, b )
    } else {
        non_num_elem( a, b );
    }
}
multi sub infix:<(elem)> (
    \a,
    SetOfRanges \b --> Bool
) is export is pure {
    so a (elem) b.keys.any;
}

multi sub infix:<∈> (
    Int:D \a where * ~~ Int,
    Range:D \b --> Bool
) is export is pure {
    num_elem( a, b );
}

multi sub infix:<∈> (
    Rational:D \a where * ~~ Rational,
    Range:D \b --> Bool
) is export is pure {
    num_elem( a, b );
}

multi sub infix:<∈> (
    Numeric:D \a,
    Range:D \b --> Bool
) is export is pure {
    num_elem( a, b );
}

multi sub infix:<∈> (
    Date:D \a,
    Range:D \b --> Bool
) is export is pure {
    num_elem( a, b);
}

multi sub infix:<∈> (
    Str:D \a,
    Range:D \b --> Bool
) is export is pure {
    my \ra = Rat(a);
    if ( defined ra ) {
        num_elem( ra, b );
    } else {
        non_num_elem( a, b );
    }
}

multi sub infix:<∈> (
    \a, SetOfRanges \b --> Bool ) is export is pure {
    so a (elem) b.keys.any;
}


multi sub infix:<∉> (
    Any:D \a,
    Range:D \b --> Bool
) is export is pure {
    a !(elem) b;
}

multi sub infix:<(cont)> (
    Range:D \a,
    Any:D \b --> Bool
) is export is pure  {
    b (elem) a;
}

multi sub infix:<∋> (
    Range:D \a,
    Any:D \b --> Bool
) is export is pure {
    b (elem) a;
}

multi sub infix:<∌> (
    Range:D \a,
    Any:D \b --> Bool
) is export is pure {
    b !(elem) a;
}

multi sub infix:<∉> (
    Any:D \a,
    SetOfRanges:D \b --> Bool
) is export is pure {
    a !(elem) b;
}

multi sub infix:<(cont)> (
    SetOfRanges:D \a,
    Any:D \b --> Bool
) is export is pure  {
    b (elem) a;
}

multi sub infix:<∋> (
    SetOfRanges:D \a,
    Any:D \b --> Bool
) is export is pure {
    b (elem) a;
}

multi sub infix:<∌> (
    SetOfRanges:D \a,
    Any:D \b --> Bool
) is export is pure {
    b !(elem) a;
}

multi sub infix:<(|)>  (
    Range:D $a,
    Range $b where $a (<=) $b --> Set
) is export is pure {
     Set( \($b) );
}

multi sub infix:<(|)> (
    Range:D $a,
    Range $b where $b (<) $a --> Set
) is export is pure {
     Set( \($a) );
}

multi sub infix:<(|)> (
    Range:D $a,
    Range $b --> Set
) is export is pure {
    union-ranges( [ $a, $b ] );
}

multi sub infix:<(|)> (
    **@r where { $_.all ~~ Range } --> Set
) is assoc<list> is export is pure {
    union-ranges( @r );
}

multi sub infix:<∪> (
    **@r where { $_.all ~~ Range } --> Set
) is assoc<list> is export is pure {
     union-ranges( @r );
}

sub union-ranges(
    @r where { $_.all ~~ Range } --> Set
) is pure {
    my &sort = do {
        @r.any.min ~~ Str ?? &infix:<leg> !! &infix:«<=>»;
    };
    
    my @ordered = @r.sort( { &sort( $^a.min, $^b.min ) } );
    my $h = @ordered.shift;

    my $out = Set( [$h] );
    for @ordered -> $range {
        $out = $out (|) $range;
    }
    $out;
}

multi sub infix:<(|)> (
    Range:D $a is copy,
    SetOfRanges:D $b --> Set
) is export is pure {
    my @out;

    my ( &sort, &range-check ) = do {
        $a.min ~~ Str
        ?? ( &infix:<leg>, &infix:<ge> )
        !! ( &infix:«<=>», &infix:«>=» );
    }

    my @check = $b.keys.list.sort( { &sort( $^a.min, $^b.min ) } );
    while @check {
        my $range = @check.pop;
        if (
            &range-check( $range.max, $a.min ) &&
            &range-check( $a.max, $range.min )
        ) {
            $a = minmax($a, $range);
        } else {
            @out.push( $range );
        }
    }
    @out.push( $a );
    Set( @out );
}

multi sub infix:<(|)> (
    SetOfRanges:D $a,
    SetOfRanges:D $b --> Set
) is export is pure {
    [(|)] |$a.keys, |$b.keys;
}

multi sub infix:<∪> (
    SetOfRanges:D $a,
    SetOfRanges:D $b --> Set
) is export is pure {
    [(|)] |$a.keys, |$b.keys;
}


multi sub infix:<(|)> (
    SetOfRanges:D $a,
    Range:D $b --> Set
) is export is pure {
    $b (|) $a;
}

multi sub infix:<∪> (
    Range:D $a,
    Range $b --> Set
) is export is pure {
    $a (|) $b;
}

multi sub infix:<∪> (
    Range:D $a,
    SetOfRanges $b --> Set
) is export is pure {
    $a (|) $b;
}

multi sub infix:<∪> (
    SetOfRanges:D $a,
    Range $b --> Set
) is export is pure {
    $b (|) $a;
}

multi sub infix:<(&)> (
    Range:D $a is copy,
    SetOfRanges:D $b --> Set
) is export is pure {
    my @out;

    my ( &sort, &range-check ) = do {
        $a.min ~~ Str
        ?? ( &infix:<leg>, &infix:<ge> )
        !! ( &infix:«<=>», &infix:«>=» );
    }

    my @check = $b.keys.list.sort( { &sort( $^a.min, $^b.min ) } );
    while @check {
        my $range = @check.pop;
        if ( &range-check( $range.max, $a.min ) && &range-check( $a.max, $range.min ) ) {
            $a = Range.new(max($a.min,$range.min), min($a.max,$range.max));
        } else {
            $a = Inf..-Inf;
        }
    }
    @out.push( $a ) if &range-check( $a.max, $a.min );
    Set( @out );
}

multi sub infix:<∩> (
    Range:D $a is copy,
    SetOfRanges:D $b --> Set
) is export is pure {
    $a (&) $b;
}

sub intersect-ranges(
    @r where { $_.all ~~ Range } --> Set
) is pure {
    my &sort = do {
        @r.any.min ~~ Str ?? &infix:<leg> !! &infix:«<=>»;
    };

    my @ordered = @r.sort( { &sort( $^a.min, $^b.min ) } );
    my $h = @ordered.shift;

    my $out = Set( [$h] );
    for @ordered -> $range {
        $out = $range (&) $out;
    }
    $out;
}

multi sub infix:<(&)> (
    **@r where { $_.all ~~ Range } --> Set
) is assoc<list> is export is pure {
    intersect-ranges(@r);
}

multi sub infix:<(&)> (
    Range $a,
    Range $b --> Set
) is export is pure {
    intersect-ranges([$a,$b]);
}

multi sub infix:<∩> (
    Range $a,
    Range $b --> Set
) is export is pure {
    [(&)] $a, $b;
}

multi sub infix:<∩> (
    **@r where { $_.all ~~ Range } --> Set
) is assoc<list> is export is pure {
    [(&)] @r;
}


SetOps

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

NAME

SYNOPSIS

DESCRIPTION

IMPLEMENTED OPERATORS

AUTHOR

COPYRIGHT AND LICENSE

Range::SetOps v0.0.4

Authors

License

Dependencies

Test Dependencies

Provides

Documentation