---
name: "Set::Infinite::Basic"
section: "3pm"
platform: "linux"
package: "perl-set-infinite"
version: "0.65-7"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/Set::Infinite::Basic"
---

# Set::Infinite::Basic(3pm)

Sets of intervals 6 =head1 SYNOPSIS

## NAME

Set::Infinite::Basic - Sets of intervals 6 =head1 SYNOPSIS

```
  use Set::Infinite::Basic;
  $set = Set::Infinite::Basic->new(1,2);    # [1..2]
  print $set->union(5,6);            # [1..2],[5..6]
```

## DESCRIPTION

Set::Infinite::Basic is a Set Theory module for infinite sets.

It works on reals, integers, and objects.

This module does not support recurrences. Recurrences are implemented in Set::Infinite.

## METHODS

### empty\_set

Creates an empty\_set.

If called from an existing set, the empty set inherits the "type" and "density" characteristics.

### universal\_set

Creates a set containing "all" possible elements.

If called from an existing set, the universal set inherits the "type" and "density" characteristics.

### until

Extends a set until another:

```
    0,5,7 -> until 2,6,10
```

gives

```
    [0..2), [5..6), [7..10)
```

Note: this function is still experimental.

### copy

### clone

Makes a new object from the object's data.

### Mode functions:

```
    $set = $set->real;
    $set = $set->integer;
```

### Logic functions:

```
    $logic = $set->intersects($b);
    $logic = $set->contains($b);
    $logic = $set->is_null;  # also called "is_empty"
```

### Set functions:

```
    $set = $set->union($b);
    $set = $set->intersection($b);
    $set = $set->complement;
    $set = $set->complement($b);   # can also be called "minus" or "difference"
    $set = $set->symmetric_difference( $b );
    $set = $set->span;
        result is (min .. max)
```

### Scalar functions:

```
    $i = $set->min;
    $i = $set->max;
    $i = $set->size;
    $i = $set->count;  # number of spans
```

### Overloaded Perl functions:

```
    print
    sort, <=>
```

### Global functions:

```
    separators(@i)
        chooses the interval separators.
        default are [ ] ( ) '..' ','.
    INFINITY
        returns an 'Infinity' number.
    NEG_INFINITY
        returns a '-Infinity' number.
    iterate ( sub { } )
        Iterates over a subroutine.
        Returns the union of partial results.
    first
        In scalar context returns the first interval of a set.
        In list context returns the first interval of a set, and the
        'tail'.
        Works in unbounded sets
    type($i)
        chooses an object data type.
        default is none (a normal perl SCALAR).
        examples:
        type('Math::BigFloat');
        type('Math::BigInt');
        type('Set::Infinite::Date');
            See notes on Set::Infinite::Date below.
    tolerance(0)    defaults to real sets (default)
    tolerance(1)    defaults to integer sets
    real            defaults to real sets (default)
    integer         defaults to integer sets
```

### Internal functions:

```
    $set->fixtype;
    $set->numeric;
```

## CAVEATS

```
    $set = Set::Infinite->new(10,1);
        Will be interpreted as [1..10]
    $set = Set::Infinite->new(1,2,3,4);
        Will be interpreted as [1..2],[3..4] instead of [1,2,3,4].
        You probably want ->new([1],[2],[3],[4]) instead,
        or maybe ->new(1,4)
    $set = Set::Infinite->new(1..3);
        Will be interpreted as [1..2],3 instead of [1,2,3].
        You probably want ->new(1,3) instead.
```

## INTERNALS

The internal representation of a *span* is a hash:

```
    { a =>   start of span,
      b =>   end of span,
      open_begin =>   '0' the span starts in 'a'
                      '1' the span starts after 'a'
      open_end =>     '0' the span ends in 'b'
                      '1' the span ends before 'b'
    }
```

For example, this set:

```
    [100..200),300,(400..infinity)
```

is represented by the array of hashes:

```
    list => [
        { a => 100, b => 200, open_begin => 0, open_end => 1 },
        { a => 300, b => 300, open_begin => 0, open_end => 0 },
        { a => 400, b => infinity, open_begin => 0, open_end => 1 },
    ]
```

The *density* of a set is stored in the `"tolerance"` variable:

```
    tolerance => 0;  # the set is made of real numbers.
    tolerance => 1;  # the set is made of integers.
```

The `"type"` variable stores the *class* of objects that will be stored in the set.

```
    type => 'DateTime';   # this is a set of DateTime objects
```

The *infinity* value is generated by Perl, when it finds a numerical overflow:

```
    $inf = 100**100**100;
```

## SEE ALSO

```
    Set::Infinite
```

## AUTHOR

```
    Flavio S. Glock <fglock@gmail.com>
```