Skip to content

Commit daccdeb

Browse files
dan-ondan-on
committed
Integer interval change to numeric interval
1 parent 714e942 commit daccdeb

File tree

6 files changed

+81
-75
lines changed

6 files changed

+81
-75
lines changed

src/Interval/IntegerInterval.php renamed to src/Interval/NumericInterval.php

Lines changed: 22 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -6,22 +6,22 @@
66
use InvalidArgumentException;
77
use function count;
88

9-
final class IntegerInterval implements IntervalInterface
9+
final class NumericInterval implements IntervalInterface
1010
{
1111
/**
12-
* @var int
12+
* @var int|float
1313
*/
1414
private $low;
1515

1616
/**
17-
* @var int
17+
* @var int|float
1818
*/
1919
private $high;
2020

2121
/**
2222
* IntegerInterval constructor
23-
* @param int $low
24-
* @param int $high
23+
* @param int|float $low
24+
* @param int|float $high
2525
*/
2626
public function __construct($low, $high)
2727
{
@@ -35,28 +35,34 @@ public function __construct($low, $high)
3535

3636
/**
3737
* @param int[] $interval
38-
* @return IntegerInterval
38+
* @return NumericInterval
3939
*/
40-
public static function fromArray($interval): IntegerInterval
40+
public static function fromArray($interval): NumericInterval
4141
{
4242
if (count($interval) !== 2) {
4343
throw new InvalidArgumentException('Wrong interval array');
4444
}
4545
return new self($interval[0], $interval[1]);
4646
}
4747

48-
public function getLow(): int
48+
/**
49+
* @return int|float
50+
*/
51+
public function getLow()
4952
{
5053
return $this->low;
5154
}
5255

53-
public function getHigh(): int
56+
/**
57+
* @return int|float
58+
*/
59+
public function getHigh()
5460
{
5561
return $this->high;
5662
}
5763

5864
/**
59-
* @param IntegerInterval $otherInterval
65+
* @param NumericInterval $otherInterval
6066
* @return bool
6167
*/
6268
public function equalTo($otherInterval): bool
@@ -65,7 +71,7 @@ public function equalTo($otherInterval): bool
6571
}
6672

6773
/**
68-
* @param IntegerInterval $otherInterval
74+
* @param NumericInterval $otherInterval
6975
* @return bool
7076
*/
7177
public function lessThan($otherInterval): bool
@@ -75,7 +81,7 @@ public function lessThan($otherInterval): bool
7581
}
7682

7783
/**
78-
* @param IntegerInterval $otherInterval
84+
* @param NumericInterval $otherInterval
7985
* @return bool
8086
*/
8187
public function intersect($otherInterval): bool
@@ -84,12 +90,12 @@ public function intersect($otherInterval): bool
8490
}
8591

8692
/**
87-
* @param IntegerInterval $otherInterval
88-
* @return IntegerInterval
93+
* @param NumericInterval $otherInterval
94+
* @return NumericInterval
8995
*/
90-
public function merge($otherInterval): IntegerInterval
96+
public function merge($otherInterval): NumericInterval
9197
{
92-
return new IntegerInterval(
98+
return new NumericInterval(
9399
min($this->getLow(), $otherInterval->getLow()),
94100
max($this->getHigh(), $otherInterval->getHigh())
95101
);

‎tests/Benchmark/CountIntersectionsBench.php‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@
33

44
namespace Danon\IntervalTree\Tests\Benchmark;
55

6-
use Danon\IntervalTree\Interval\IntegerInterval;
6+
use Danon\IntervalTree\Interval\NumericInterval;
77
use Danon\IntervalTree\IntervalTree;
88
use PhpBench\Benchmark\Metadata\Annotations\Revs;
99

@@ -24,7 +24,7 @@ class CountIntersectionsBench
2424
private $tree;
2525

2626
/**
27-
* @var IntegerInterval[]
27+
* @var NumericInterval[]
2828
*/
2929
private $bruteForceList;
3030

‎tests/Benchmark/GenerateIntervalTrait.php‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -3,15 +3,15 @@
33

44
namespace Danon\IntervalTree\Tests\Benchmark;
55

6-
use Danon\IntervalTree\Interval\IntegerInterval;
6+
use Danon\IntervalTree\Interval\NumericInterval;
77
use Exception;
88

99
trait GenerateIntervalTrait
1010
{
1111
/**
12-
* @return IntegerInterval
12+
* @return NumericInterval
1313
*/
14-
private function generateInterval(): IntegerInterval
14+
private function generateInterval(): NumericInterval
1515
{
1616
try {
1717
$low = random_int(0, self::MAX_INTERVAL_HIGH);
@@ -20,6 +20,6 @@ private function generateInterval(): IntegerInterval
2020
echo 'Cannot generate interval: ' . $exception->getMessage();
2121
exit;
2222
}
23-
return new IntegerInterval($low, $high);
23+
return new NumericInterval($low, $high);
2424
}
2525
}

‎tests/Benchmark/HasIntersectionBench.php‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@
33

44
namespace Danon\IntervalTree\Tests\Benchmark;
55

6-
use Danon\IntervalTree\Interval\IntegerInterval;
6+
use Danon\IntervalTree\Interval\NumericInterval;
77
use Danon\IntervalTree\IntervalTree;
88
use Exception;
99
use PhpBench\Benchmark\Metadata\Annotations\Revs;
@@ -25,7 +25,7 @@ class HasIntersectionBench
2525
private $tree;
2626

2727
/**
28-
* @var IntegerInterval[]
28+
* @var NumericInterval[]
2929
*/
3030
private $bruteForceList;
3131

@@ -64,9 +64,9 @@ public function benchBruteForce(): void
6464
}
6565

6666
/**
67-
* @return IntegerInterval
67+
* @return NumericInterval
6868
*/
69-
private function generateInterval(): IntegerInterval
69+
private function generateInterval(): NumericInterval
7070
{
7171
try {
7272
$low = random_int(0, self::MAX_INTERVAL_HIGH);
@@ -75,6 +75,6 @@ private function generateInterval(): IntegerInterval
7575
echo 'Cannot generate interval: ' . $exception->getMessage();
7676
exit;
7777
}
78-
return new IntegerInterval($low, $high);
78+
return new NumericInterval($low, $high);
7979
}
8080
}

‎tests/Interval/IntegerIntervalTest.php‎

Lines changed: 23 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -5,64 +5,64 @@
55

66
use InvalidArgumentException;
77
use PHPUnit\Framework\TestCase;
8-
use Danon\IntervalTree\Interval\IntegerInterval;
8+
use Danon\IntervalTree\Interval\NumericInterval;
99

1010
final class IntegerIntervalTest extends TestCase
1111
{
1212
public function testConstruct(): void
1313
{
14-
$interval = new IntegerInterval(1, 2);
15-
self::assertInstanceOf(IntegerInterval::class, $interval);
14+
$interval = new NumericInterval(1, 2);
15+
self::assertInstanceOf(NumericInterval::class, $interval);
1616
self::assertSame(1, $interval->getLow());
1717
self::assertSame(2, $interval->getHigh());
1818

1919
// Cannot be created when low greater than high
2020
$this->expectException(InvalidArgumentException::class);
21-
new IntegerInterval(2, 1);
21+
new NumericInterval(2, 1);
2222
}
2323

2424
public function testFromArray(): void
2525
{
26-
$interval = IntegerInterval::fromArray([20, 25]);
26+
$interval = NumericInterval::fromArray([20, 25]);
2727
self::assertSame(20, $interval->getLow());
2828
self::assertSame(25, $interval->getHigh());
2929

3030
// Passed more arguments than needed
3131
$this->expectException(InvalidArgumentException::class);
32-
IntegerInterval::fromArray([1, 2, 3]);
32+
NumericInterval::fromArray([1, 2, 3]);
3333
}
3434

3535
public function testEqualTo(): void
3636
{
37-
$interval = IntegerInterval::fromArray([1, 2]);
38-
$sameInterval = IntegerInterval::fromArray([1, 2]);
39-
$differentInterval = IntegerInterval::fromArray([1, 3]);
37+
$interval = NumericInterval::fromArray([1, 2]);
38+
$sameInterval = NumericInterval::fromArray([1, 2]);
39+
$differentInterval = NumericInterval::fromArray([1, 3]);
4040
self::assertTrue($interval->equalTo($sameInterval));
4141
self::assertFalse($interval->equalTo($differentInterval));
4242
self::assertFalse($sameInterval->equalTo($differentInterval));
4343
}
4444

4545
public function testLessThan(): void
4646
{
47-
$interval = IntegerInterval::fromArray([1, 2]);
48-
$lessInterval = IntegerInterval::fromArray([1, 1]);
49-
$sameInterval = IntegerInterval::fromArray([1, 2]);
50-
$greaterInterval = IntegerInterval::fromArray([1, 3]);
47+
$interval = NumericInterval::fromArray([1, 2]);
48+
$lessInterval = NumericInterval::fromArray([1, 1]);
49+
$sameInterval = NumericInterval::fromArray([1, 2]);
50+
$greaterInterval = NumericInterval::fromArray([1, 3]);
5151
self::assertFalse($interval->lessThan($lessInterval));
5252
self::assertFalse($interval->lessThan($sameInterval));
5353
self::assertTrue($interval->lessThan($greaterInterval));
5454
}
5555

5656
public function testIntersect(): void
5757
{
58-
$interval = IntegerInterval::fromArray([5, 10]);
59-
$sameInterval = IntegerInterval::fromArray([5, 10]);
60-
$intersectingFromLeftInterval = IntegerInterval::fromArray([4, 6]);
61-
$intersectingFromRightInterval = IntegerInterval::fromArray([10, 11]);
62-
$leftPointInterval = IntegerInterval::fromArray([5, 5]);
63-
$rightPointInterval = IntegerInterval::fromArray([10, 10]);
64-
$notIntersectingInterval1 = IntegerInterval::fromArray([12, 14]);
65-
$notIntersectingInterval2 = IntegerInterval::fromArray([0, 4]);
58+
$interval = NumericInterval::fromArray([5, 10]);
59+
$sameInterval = NumericInterval::fromArray([5, 10]);
60+
$intersectingFromLeftInterval = NumericInterval::fromArray([4, 6]);
61+
$intersectingFromRightInterval = NumericInterval::fromArray([10, 11]);
62+
$leftPointInterval = NumericInterval::fromArray([5, 5]);
63+
$rightPointInterval = NumericInterval::fromArray([10, 10]);
64+
$notIntersectingInterval1 = NumericInterval::fromArray([12, 14]);
65+
$notIntersectingInterval2 = NumericInterval::fromArray([0, 4]);
6666
self::assertTrue($interval->intersect($sameInterval));
6767
self::assertTrue($interval->intersect($intersectingFromLeftInterval));
6868
self::assertTrue($interval->intersect($intersectingFromRightInterval));
@@ -74,8 +74,8 @@ public function testIntersect(): void
7474

7575
public function testMerge(): void
7676
{
77-
$interval1 = IntegerInterval::fromArray([1, 3]);
78-
$interval2 = IntegerInterval::fromArray([3, 5]);
77+
$interval1 = NumericInterval::fromArray([1, 3]);
78+
$interval2 = NumericInterval::fromArray([3, 5]);
7979
$mergedInterval = $interval1->merge($interval2);
8080
self::assertSame(1, $mergedInterval->getLow());
8181
self::assertSame(5, $mergedInterval->getHigh());

‎tests/IntervalTreeTest.php‎

Lines changed: 25 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@
33

44
namespace Danon\IntervalTree\Tests;
55

6-
use Danon\IntervalTree\Interval\IntegerInterval;
6+
use Danon\IntervalTree\Interval\NumericInterval;
77
use Danon\IntervalTree\IntervalTree;
88
use PHPUnit\Framework\TestCase;
99

@@ -21,7 +21,7 @@ public function setUp(): void
2121
foreach ($this->intervals as $interval) {
2222
$value = implode('-', $interval);
2323
$this->tree->insert(
24-
IntegerInterval::fromArray($interval),
24+
NumericInterval::fromArray($interval),
2525
$value
2626
);
2727
}
@@ -32,11 +32,11 @@ public function testFindAllIntersections(): void
3232
{
3333
$checkInterval = [2, 3];
3434
$overlappingIntervals = [[0, 2], [0, 2], [0, 3], [1, 4], [2, 3], [3, 4]];
35-
$intersections = $this->tree->findIntersections(IntegerInterval::fromArray($checkInterval));
35+
$intersections = $this->tree->findIntersections(NumericInterval::fromArray($checkInterval));
3636
foreach ($intersections as $index => $node) {
37-
$overlappingInterval = IntegerInterval::fromArray($overlappingIntervals[$index]);
37+
$overlappingInterval = NumericInterval::fromArray($overlappingIntervals[$index]);
3838
$overlappingValue = implode('-', $overlappingIntervals[$index]);
39-
self::assertTrue($overlappingInterval->equalTo(IntegerInterval::fromArray([
39+
self::assertTrue($overlappingInterval->equalTo(NumericInterval::fromArray([
4040
$node->getPair()->getInterval()->getLow(),
4141
$node->getPair()->getInterval()->getHigh(),
4242
])));
@@ -46,40 +46,40 @@ public function testFindAllIntersections(): void
4646

4747
public function testFindAnyIntersection(): void
4848
{
49-
self::assertTrue($this->tree->hasIntersection(IntegerInterval::fromArray([2, 3])));
50-
self::assertTrue($this->tree->hasIntersection(IntegerInterval::fromArray([0, 1])));
51-
self::assertTrue($this->tree->hasIntersection(IntegerInterval::fromArray([0, 12])));
52-
self::assertTrue($this->tree->hasIntersection(IntegerInterval::fromArray([0, 0])));
53-
self::assertTrue($this->tree->hasIntersection(IntegerInterval::fromArray([0, 99])));
54-
self::assertTrue($this->tree->hasIntersection(IntegerInterval::fromArray([5, 7])));
55-
self::assertTrue($this->tree->hasIntersection(IntegerInterval::fromArray([6, 7])));
56-
self::assertFalse($this->tree->hasIntersection(IntegerInterval::fromArray([13, 14])));
57-
self::assertFalse($this->tree->hasIntersection(IntegerInterval::fromArray([5, 5])));
58-
self::assertFalse($this->tree->hasIntersection(IntegerInterval::fromArray([5, 6])));
59-
self::assertFalse($this->tree->hasIntersection(IntegerInterval::fromArray([6, 6])));
49+
self::assertTrue($this->tree->hasIntersection(NumericInterval::fromArray([2, 3])));
50+
self::assertTrue($this->tree->hasIntersection(NumericInterval::fromArray([0, 1])));
51+
self::assertTrue($this->tree->hasIntersection(NumericInterval::fromArray([0, 12])));
52+
self::assertTrue($this->tree->hasIntersection(NumericInterval::fromArray([0, 0])));
53+
self::assertTrue($this->tree->hasIntersection(NumericInterval::fromArray([0, 99])));
54+
self::assertTrue($this->tree->hasIntersection(NumericInterval::fromArray([5, 7])));
55+
self::assertTrue($this->tree->hasIntersection(NumericInterval::fromArray([6, 7])));
56+
self::assertFalse($this->tree->hasIntersection(NumericInterval::fromArray([13, 14])));
57+
self::assertFalse($this->tree->hasIntersection(NumericInterval::fromArray([5, 5])));
58+
self::assertFalse($this->tree->hasIntersection(NumericInterval::fromArray([5, 6])));
59+
self::assertFalse($this->tree->hasIntersection(NumericInterval::fromArray([6, 6])));
6060
}
6161

6262
public function testRemove(): void
6363
{
6464
$initialSize = $this->tree->getSize();
6565
self::assertEquals(count($this->intervals), $initialSize);
66-
self::assertTrue($this->tree->remove(IntegerInterval::fromArray([7, 8]), '7-8'));
66+
self::assertTrue($this->tree->remove(NumericInterval::fromArray([7, 8]), '7-8'));
6767
self::assertEquals($this->tree->getSize(), --$initialSize);
68-
self::assertFalse($this->tree->remove(IntegerInterval::fromArray([1, 4]), '1-3'));
68+
self::assertFalse($this->tree->remove(NumericInterval::fromArray([1, 4]), '1-3'));
6969
self::assertEquals($this->tree->getSize(), $initialSize);
70-
self::assertTrue($this->tree->remove(IntegerInterval::fromArray([1, 4]), '1-4'));
70+
self::assertTrue($this->tree->remove(NumericInterval::fromArray([1, 4]), '1-4'));
7171
self::assertEquals($this->tree->getSize(), --$initialSize);
72-
self::assertTrue($this->tree->remove(IntegerInterval::fromArray([1, 1]), '1-1'));
72+
self::assertTrue($this->tree->remove(NumericInterval::fromArray([1, 1]), '1-1'));
7373
self::assertEquals($this->tree->getSize(), --$initialSize);
74-
self::assertTrue($this->tree->remove(IntegerInterval::fromArray([0, 2]), '0-2'));
74+
self::assertTrue($this->tree->remove(NumericInterval::fromArray([0, 2]), '0-2'));
7575
self::assertEquals($this->tree->getSize(), --$initialSize);
76-
self::assertFalse($this->tree->remove(IntegerInterval::fromArray([0, 0]), '0-0'));
76+
self::assertFalse($this->tree->remove(NumericInterval::fromArray([0, 0]), '0-0'));
7777
self::assertEquals($this->tree->getSize(), $initialSize);
78-
self::assertTrue($this->tree->remove(IntegerInterval::fromArray([7, 12]), '7-12'));
78+
self::assertTrue($this->tree->remove(NumericInterval::fromArray([7, 12]), '7-12'));
7979
self::assertEquals($this->tree->getSize(), --$initialSize);
80-
self::assertFalse($this->tree->remove(IntegerInterval::fromArray([7, 12]), '7-90'));
80+
self::assertFalse($this->tree->remove(NumericInterval::fromArray([7, 12]), '7-90'));
8181
self::assertEquals($this->tree->getSize(), $initialSize);
82-
self::assertFalse($this->tree->remove(IntegerInterval::fromArray([7, 12]), '7-12'));
82+
self::assertFalse($this->tree->remove(NumericInterval::fromArray([7, 12]), '7-12'));
8383
self::assertEquals($this->tree->getSize(), $initialSize);
8484
}
8585

0 commit comments

Comments
 (0)