Merge pull request #23 from Whathecode/develop

Release 1.0.0-alpha.4

Author: Whathecode

build.gradle.kts

@@ -16,7 +16,7 @@ if (publishPropertiesFile.exists()) {
     publishProperties.load(java.io.FileInputStream(publishPropertiesFile))
 }
 group = "io.github.whathecode.kotlinx.interval"
-version = "1.0.0-alpha.3"
+version = "1.0.0-alpha.4"
 nexusPublishing {
     repositories {
         sonatype {

gradle.properties

@@ -1,5 +1,3 @@
-kotlin.mpp.enableGranularSourceSetsMetadata=true
-kotlin.native.enableDependencyPropagation=false
 kotlin.js.generate.executable.default=false
 
 # Prevent out of memory errors.

kotlinx.interval.test/src/commonMain/kotlin/IntervalTest.kt

@@ -26,6 +26,11 @@ abstract class IntervalTest<T : Comparable<T>, TSize : Comparable<TSize>>(
     private val valueOperations = operations.valueOperations
     private val sizeOperations = operations.sizeOperations
 
+    /**
+     * Value which lies as far beyond [c] as [b] lies beyond [a].
+     */
+    private val d = valueOperations.unsafeAdd( c, valueOperations.unsafeSubtract( b, a ) )
+
     private fun createInterval( start: T, isStartIncluded: Boolean, end: T, isEndIncluded: Boolean ) =
         Interval( start, isStartIncluded, end, isEndIncluded, operations )
     private fun createClosedInterval( start: T, end: T ): Interval<T, TSize> = createInterval( start, true, end, true )
@@ -138,4 +143,104 @@ abstract class IntervalTest<T : Comparable<T>, TSize : Comparable<TSize>>(
         val openIntervals = listOf( createOpenInterval( a, b ), createOpenInterval( b, a ) )
         openIntervals.forEach { assertTrue( a !in it && b !in it ) }
     }
+
+    @Test
+    fun intersects_for_fully_contained_intervals()
+    {
+        val ad = createClosedInterval( a, d )
+
+        val withinIntervals = createAllInclusionTypeIntervals( b, c )
+        val onEndPointIntervals = createAllInclusionTypeIntervals( a, b ) + createAllInclusionTypeIntervals( c, d )
+        (withinIntervals + onEndPointIntervals).forEach { assertIntersects( ad, it, true ) }
+    }
+
+    @Test
+    fun intersects_for_partial_overlapping_interval()
+    {
+        val acIntervals = createAllInclusionTypeIntervals( a, c )
+        val bdIntervals = createAllInclusionTypeIntervals( b, d )
+
+        for ( ac in acIntervals ) for ( bd in bdIntervals )
+            assertIntersects( ac, bd, true )
+    }
+
+    @Test
+    fun intersects_for_nonoverlapping_intervals()
+    {
+        val abIntervals = createAllInclusionTypeIntervals( a, b )
+        val cdIntervals = createAllInclusionTypeIntervals( c, d )
+
+        for ( ab in abIntervals ) for ( cd in cdIntervals )
+            assertIntersects( ab, cd, false )
+    }
+
+    @Test
+    fun intersects_for_touching_endpoints()
+    {
+        val abWithB = createClosedInterval( a, b )
+        val bcWithB = createClosedInterval( b, c )
+        assertIntersects( abWithB, bcWithB, true )
+
+        val abWithoutB = createOpenInterval( a, b )
+        val bcWithoutB = createOpenInterval( b, c )
+        assertIntersects( abWithoutB, bcWithoutB, false )
+
+        assertIntersects( abWithB, bcWithoutB, false )
+        assertIntersects( abWithoutB, bcWithB, false )
+    }
+
+    @Test
+    fun nonReversed_reversed_when_isReversed()
+    {
+        val reversed = createAllInclusionTypeIntervals( b, a )
+        for ( original in reversed )
+        {
+            val normal = original.nonReversed()
+            assertEquals( original.reverse(), normal )
+        }
+    }
+
+    @Test
+    fun nonReversed_unchanged_when_not_isReversed()
+    {
+        val normal = createAllInclusionTypeIntervals( a, b )
+        for ( original in normal )
+        {
+            val unchanged = original.nonReversed()
+            assertEquals( original, unchanged )
+        }
+    }
+
+    @Test
+    fun reverse_succeeds()
+    {
+        val toReverse = createAllInclusionTypeIntervals( a, b )
+        for ( original in toReverse )
+        {
+            val reversed = original.reverse()
+            assertEquals( original.start, reversed.end )
+            assertEquals( original.isStartIncluded, reversed.isEndIncluded )
+            assertEquals( original.end, reversed.start )
+            assertEquals( original.isEndIncluded, reversed.isStartIncluded )
+        }
+    }
+
+    private fun assertIntersects( interval1: Interval<T, TSize>, interval2: Interval<T, TSize>, intersects: Boolean )
+    {
+        assertEquals( intersects, interval1.intersects( interval2 ) )
+        assertEquals( intersects, interval2.intersects( interval1 ) )
+
+        // Reversing intervals should have no effect on whether they intersect or not.
+        val interval1Reversed = interval1.reverse()
+        val interval2Reversed = interval2.reverse()
+
+        assertEquals( intersects, interval1.intersects( interval2Reversed ) )
+        assertEquals( intersects, interval2Reversed.intersects( interval1 ) )
+
+        assertEquals( intersects, interval1Reversed.intersects( interval2 ) )
+        assertEquals( intersects, interval2.intersects( interval1Reversed ) )
+
+        assertEquals( intersects, interval1Reversed.intersects( interval2Reversed ) )
+        assertEquals( intersects, interval2Reversed.intersects( interval1Reversed ) )
+    }
 }

kotlinx.interval/src/commonMain/kotlin/Interval.kt

@@ -86,6 +86,37 @@ open class Interval<T : Comparable<T>, TSize : Comparable<TSize>>(
             && ( greatestComp < 0 || (greatestComp == 0 && greatest.isIncluded) )
     }
 
+    /**
+     * Determines whether [interval] has at least one value in common with this interval.
+     */
+    fun intersects( interval: Interval<T, TSize> ): Boolean
+    {
+        val interval1 = nonReversed()
+        val interval2 = interval.nonReversed()
+
+        val rightOfCompare: Int = interval2.start.compareTo( interval1.end )
+        val leftOfCompare: Int = interval2.end.compareTo( interval1.start )
+        val liesRightOf =
+            rightOfCompare > 0 || ( rightOfCompare == 0 && !(interval2.isStartIncluded && interval1.isEndIncluded) )
+        val liesLeftOf =
+            leftOfCompare < 0 || ( leftOfCompare == 0 && !(interval2.isEndIncluded && interval1.isStartIncluded) )
+        return !( liesRightOf || liesLeftOf )
+    }
+
+    /**
+     * [reverse] the interval in case [start] is greater than [end] (the interval [isReversed]),
+     * or return the interval unchanged otherwise.
+     * Either way, the returned interval represents the same set of all [T] values.
+     */
+    fun nonReversed(): Interval<T, TSize> = if ( isReversed ) reverse() else this
+
+    /**
+     * Return an interval representing the same set of all [T] values,
+     * but swap [start] and [isStartIncluded] with [end] and [isEndIncluded].
+     */
+    fun reverse(): Interval<T, TSize> =
+        Interval( this.end, this.isEndIncluded, this.start, this.isStartIncluded, operations )
+
     /**
      * Determines whether this interval equals [other]'s constructor parameters exactly,
      * i.e., not whether they represent the same set of [T] values, such as matching inverse intervals.

kotlinx.interval/src/commonMain/kotlin/IntervalUnion.kt

@@ -0,0 +1,33 @@
+package io.github.whathecode.kotlinx.interval
+
+
+/**
+ * Represents a set of all [T] values contained in a collection of non-overlapping [Interval]s,
+ * stored in normalized form and ordered by their start values.
+ */
+sealed interface IntervalUnion<T : Comparable<T>, TSize : Comparable<TSize>> : Iterable<Interval<T, TSize>>
+
+
+/**
+ * An [IntervalUnion] which new intervals can be added to,
+ * as long as they are in normalized form, lie after, and don't overlap with previously added intervals.
+ */
+internal class MutableIntervalUnion<T : Comparable<T>, TSize : Comparable<TSize>> : IntervalUnion<T, TSize>
+{
+    private val intervals: MutableList<Interval<T, TSize>> = mutableListOf()
+
+    override fun iterator(): Iterator<Interval<T, TSize>> = intervals.iterator()
+
+    fun add( interval: Interval<T, TSize> )
+    {
+        require( !interval.isReversed )
+            { "The interval is reversed. Normalized form is required." }
+        require( intervals.all { it.start < interval.start } )
+            { "The interval lies before a previously added interval." }
+        val last = intervals.lastOrNull()
+        require( last == null || !interval.intersects( last ) )
+            { "The interval overlaps with a previously added interval." }
+
+        intervals.add( interval )
+    }
+}

kotlinx.interval/src/commonTest/kotlin/MutableIntervalUnionTest.kt

@@ -0,0 +1,78 @@
+package io.github.whathecode.kotlinx.interval
+
+import kotlin.test.*
+
+
+/**
+ * Tests for [IntervalUnion].
+ */
+class MutableIntervalUnionTest
+{
+    // There is no reason to believe interval unions of different types behave differently.
+    // Testing one type should suffice.
+    private fun createEmptyUnion() = MutableIntervalUnion<Int, UInt>()
+
+    @Test
+    fun add_to_empty_succeeds()
+    {
+        val union = createEmptyUnion()
+
+        val toAdd = interval( 0, 10 )
+        union.add( toAdd )
+
+        assertEquals( toAdd, union.single() )
+    }
+
+    @Test
+    fun add_to_previous_succeeds()
+    {
+        val union = createEmptyUnion()
+        union.add( interval( 0, 10 ) )
+
+        val liesAfter = interval( 20, 30 )
+        union.add( liesAfter )
+
+        assertEquals( liesAfter, union.last() )
+    }
+
+    @Test
+    fun add_non_normalized_fails()
+    {
+        val union = createEmptyUnion()
+
+        val nonNormalized = interval( 10, 0 )
+        assertFailsWith<IllegalArgumentException> { union.add( nonNormalized ) }
+    }
+
+    @Test
+    fun add_preceding_interval_fails()
+    {
+        val union = createEmptyUnion()
+        union.add( interval( 5, 10 ) )
+
+        val liesBefore = interval( 0, 4 )
+        assertFailsWith<IllegalArgumentException> { union.add( liesBefore ) }
+    }
+
+    @Test
+    fun add_overlapping_interval_fails()
+    {
+        val union = createEmptyUnion()
+        union.add( interval( 0, 10 ) )
+
+        val overlaps = interval( 5, 15 )
+        assertFailsWith<IllegalArgumentException> { union.add( overlaps ) }
+        val endPointOverlaps = interval( 10, 20 )
+        assertFailsWith<IllegalArgumentException> { union.add( endPointOverlaps ) }
+    }
+
+    @Test
+    fun add_non_overlapping_endpoint_succeeds()
+    {
+        val union = createEmptyUnion()
+        union.add( interval( 0, 10 ) )
+
+        val nonOverlappingEndPoint = interval( 10, 20, isStartIncluded = false )
+        union.add( nonOverlappingEndPoint )
+    }
+}