Local date range

core/common/src/DateTimePeriod.kt

@@ -583,6 +583,19 @@ public operator fun DateTimePeriod.plus(other: DateTimePeriod): DateTimePeriod =
     safeAdd(totalNanoseconds, other.totalNanoseconds),
 )
 
+/**
+ * Subtracts one [DateTimePeriod] instance from another.
+ *
+ * @throws DateTimeArithmeticException if arithmetic overflow happens.
+ */
+public operator fun DateTimePeriod.minus(other: DateTimePeriod) : DateTimePeriod = buildDateTimePeriod(
+    safeAdd(totalMonths, -other.totalMonths),
+    safeAdd(days, -other.days),
+    safeAdd(totalNanoseconds, -other.totalNanoseconds)
+)
+
+public operator fun DateTimePeriod.unaryMinus(): DateTimePeriod = buildDateTimePeriod(-totalMonths, -days, -totalNanoseconds)
+
 /**
  * Adds two [DatePeriod] instances.
  *
@@ -595,3 +608,15 @@ public operator fun DatePeriod.plus(other: DatePeriod): DatePeriod = DatePeriod(
     safeAdd(totalMonths, other.totalMonths),
     safeAdd(days, other.days),
 )
+
+/**
+ * Subtracts one [DatePeriod] instance from another.
+ *
+ * @throws DateTimeArithmeticException if arithmetic overflow happens.
+ */
+public operator fun DatePeriod.minus(other: DatePeriod): DatePeriod = DatePeriod(
+    safeAdd(totalMonths, -other.totalMonths),
+    safeAdd(days, -other.days)
+)
+
+public operator fun DatePeriod.unaryMinus(): DatePeriod = DatePeriod(-totalMonths, -days)

core/common/src/LocalDateRange.kt

@@ -0,0 +1,118 @@
+/*
+ * Copyright 2019-2022 JetBrains s.r.o.
+ * Use of this source code is governed by the Apache 2.0 License that can be found in the LICENSE.txt file.
+ */
+
+package kotlinx.datetime
+
+import kotlin.random.Random
+import kotlin.random.nextInt
+
+internal class LocalDateProgressionIterator(private val iterator: IntIterator) : Iterator<LocalDate> {
+    override fun hasNext(): Boolean = iterator.hasNext()
+    override fun next(): LocalDate = LocalDate.fromEpochDays(iterator.next())
+}
+
+public open class LocalDateProgression
+internal constructor(internal val intProgression: IntProgression) : Iterable<LocalDate> {
+
+    internal constructor(
+        start: LocalDate,
+        endInclusive: LocalDate,
+        step: Int
+    ) : this(IntProgression.fromClosedRange(start.toEpochDays(), endInclusive.toEpochDays(), step))
+
+    public val first: LocalDate = LocalDate.fromEpochDays(intProgression.first)
+    public val last: LocalDate = LocalDate.fromEpochDays(intProgression.last)
+
+    override fun iterator(): Iterator<LocalDate> = LocalDateProgressionIterator(intProgression.iterator())
+
+    public open fun isEmpty(): Boolean = intProgression.isEmpty()
+
+    override fun toString(): String = if (intProgression.step > 0) "$first..$last step ${intProgression.step}" else "$first downTo $last step ${intProgression.step}"
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || this::class != other::class) return false
+
+        other as LocalDateProgression
+
+        return intProgression == other.intProgression
+    }
+
+    override fun hashCode(): Int {
+        return intProgression.hashCode()
+    }
+
+
+    public companion object {
+        public fun fromClosedRange(
+            rangeStart: LocalDate,
+            rangeEnd: LocalDate,
+            stepValue: Int,
+            stepUnit: DateTimeUnit.DayBased
+        ): LocalDateProgression = LocalDateProgression(rangeStart, rangeEnd, stepValue * stepUnit.days)
+    }
+}
+
+public class LocalDateRange(start: LocalDate, endInclusive: LocalDate) : LocalDateProgression(start, endInclusive, 1), ClosedRange<LocalDate>, OpenEndRange<LocalDate> {
+    override val start: LocalDate get() = first
+    override val endInclusive: LocalDate get() = last
+    override val endExclusive: LocalDate get() = endInclusive.plus(1, DateTimeUnit.DAY)
+
+    @Suppress("ConvertTwoComparisonsToRangeCheck")
+    override fun contains(value: LocalDate): Boolean = first <= value && value <= last
+
+    override fun isEmpty(): Boolean = first > last
+
+    override fun toString(): String = "$first..$last"
+
+    public companion object {
+        private val DATE_ONE = LocalDate(1, 1, 1)
+        private val DATE_TWO = LocalDate(1, 1, 2)
+        public val EMPTY: LocalDateRange = LocalDateRange(DATE_TWO, DATE_ONE)
+    }
+}
+
+public fun LocalDateProgression.first(): LocalDate {
+    if (isEmpty())
+        throw NoSuchElementException("Progression $this is empty.")
+    return this.first
+}
+public fun LocalDateProgression.last(): LocalDate {
+    if (isEmpty())
+        throw NoSuchElementException("Progression $this is empty.")
+    return this.last
+}
+public fun LocalDateProgression.firstOrNull(): LocalDate? = if (isEmpty()) null else this.first
+public fun LocalDateProgression.lastOrNull(): LocalDate? = if (isEmpty()) null else this.last
+
+public fun LocalDateProgression.reversed(): LocalDateProgression = LocalDateProgression(intProgression.reversed())
+
+public fun LocalDateProgression.step(value: Int, unit: DateTimeUnit.DayBased) : LocalDateProgression = LocalDateProgression(intProgression.step(value * unit.days))
+public fun LocalDateProgression.step(value: Long, unit: DateTimeUnit.DayBased) : LocalDateProgression = step(value.toInt(), unit)
+
+public infix fun LocalDate.downTo(that: LocalDate) : LocalDateProgression = LocalDateProgression.fromClosedRange(this, that, -1, DateTimeUnit.DAY)
+public infix fun LocalDate.downUntil(that: LocalDate) : LocalDateProgression = downTo(that.plus(1, DateTimeUnit.DAY))
+
+public operator fun LocalDate.rangeTo(that: LocalDate): LocalDateRange = LocalDateRange(this, that)
+public operator fun LocalDate.rangeUntil(that: LocalDate) : LocalDateRange = rangeTo(that.minus(1, DateTimeUnit.DAY))
+
+public fun LocalDateProgression.random(randomIntFunction: (IntRange) -> Int) : LocalDate = intProgression.random(randomIntFunction)
+    .let(LocalDate.Companion::fromEpochDays)
+
+public fun LocalDateProgression.random(random: Random = Random) : LocalDate = intProgression.random(random).let(LocalDate.Companion::fromEpochDays)
+
+public fun LocalDateProgression.randomOrNull(randomIntFunction: (range: IntRange) -> Int) : LocalDate? = intProgression.randomOrNull(randomIntFunction)
+    ?.let(LocalDate.Companion::fromEpochDays)
+
+public fun LocalDateProgression.randomOrNull(random: Random = Random) : LocalDate? = intProgression.randomOrNull(random)
+    ?.let(LocalDate.Companion::fromEpochDays)
+
+public inline fun IntProgression.random(func: (IntRange) -> Int) : Int = func(0..(last - first) / step) * step + first
+
+public fun IntProgression.random(random: Random = Random) : Int = random(random::nextInt)
+
+public inline fun IntProgression.randomOrNull(randomIntFunction: (range: IntRange) -> Int) : Int? = if (isEmpty()) null else random(randomIntFunction)
+
+public fun IntProgression.randomOrNull(random: Random = Random) : Int? = if (isEmpty()) null else random(random)

core/common/test/DateTimePeriodTest.kt

@@ -149,9 +149,19 @@ class DateTimePeriodTest {
         assertEquals(DatePeriod(years = 2, months = 12), dp1 + dp1)
         assertEquals(DateTimePeriod(years = 1, months = 6, days = 3), p2 + dp1)
 
+        assertEquals(p1, DateTimePeriod(years=10, days=3, hours=2) - p2 -p3)
+        assertEquals(p1, DatePeriod(years = 11, months = 6) - dp1)
+        assertEquals(dp1, DatePeriod(years = 2, months = 12) - dp1)
+        assertEquals(p2, DateTimePeriod(years = 1, months = 6, days = 3) - dp1)
+
         val dp2 = dp1 + p3 + p4
+        val dp3 = dp2 - p3 -p4
         assertEquals(dp1, dp2)
+        assertEquals(dp1, dp3)
         assertTrue(dp2 is DatePeriod)
+        assertTrue(dp3 is DatePeriod)
+        assertEquals(DateTimePeriod(years = -10, days=-3, hours = -2), -(p1 + p2 + p3))
+        assertEquals(DatePeriod(years = -11, months = -6), -(dp1 + p1))
     }
 
     @Test

core/common/test/LocalDateRangeTest.kt

@@ -0,0 +1,165 @@
+/*
+ * Copyright 2019-2022 JetBrains s.r.o.
+ * Use of this source code is governed by the Apache 2.0 License that can be found in the LICENSE.txt file.
+ */
+
+package kotlinx.datetime.test
+
+import kotlinx.datetime.*
+import kotlin.random.Random
+import kotlin.random.nextInt
+import kotlin.test.*
+
+class LocalDateRangeTest {
+    val Dec_24_1900 = LocalDate(1900, 12, 24)
+    val Dec_30_1999 = LocalDate(1999, 12, 30)
+    val Jan_01_2000 = LocalDate(2000, 1, 1)
+    val Jan_02_2000 = LocalDate(2000, 1, 2)
+    val Jan_05_2000 = LocalDate(2000, 1, 5)
+    val Jan_24_2000 = LocalDate(2000, 1, 24)
+    val Dec_24_2000 = LocalDate(2000, 12, 24)
+
+    @Test
+    fun emptyRange() {
+        assertTrue { (Jan_05_2000..Jan_01_2000).isEmpty() }
+        assertTrue { (Jan_01_2000 downTo Jan_05_2000).isEmpty() }
+        assertTrue { LocalDateRange.EMPTY.isEmpty() }
+    }
+
+    @Test
+    fun forwardRange() {
+        assertContentEquals(
+            (1..5).map { LocalDate(2000, 1, it) },
+            Jan_01_2000..Jan_05_2000
+        )
+        assertContentEquals(
+            (1..<5).map { LocalDate(2000, 1, it) },
+            Jan_01_2000..<Jan_05_2000
+        )
+        assertContentEquals(
+            listOf(Jan_01_2000),
+            Jan_01_2000..Jan_01_2000
+        )
+        assertContentEquals(
+            listOf(
+                LocalDate(1999, 12, 30),
+                LocalDate(1999, 12, 31),
+                LocalDate(2000, 1, 1),
+                LocalDate(2000, 1, 2)
+            ),
+            Dec_30_1999..Jan_02_2000
+        )
+    }
+
+    @Test
+    fun backwardRange() {
+        assertContentEquals(
+            (5 downTo 1).map { LocalDate(2000, 1, it) },
+            Jan_05_2000 downTo Jan_01_2000
+        )
+        assertContentEquals(
+            (5 downTo 2).map { LocalDate(2000, 1, it) },
+            Jan_05_2000 downUntil Jan_01_2000
+        )
+        assertContentEquals(
+            listOf(Jan_01_2000),
+            Jan_01_2000 downTo Jan_01_2000
+        )
+        assertContentEquals(
+            listOf(
+                LocalDate(2000, 1, 2),
+                LocalDate(2000, 1, 1),
+                LocalDate(1999, 12, 31),
+                LocalDate(1999, 12, 30),
+            ),
+            Jan_02_2000 downTo Dec_30_1999
+        )
+    }
+
+    @Test
+    fun step() {
+        assertContentEquals(
+            (1..24 step 2).map { LocalDate(2000, 1, it) },
+            (Jan_01_2000..Jan_24_2000).step(2, DateTimeUnit.DAY)
+        )
+        assertContentEquals(
+            (24 downTo 1  step 2).map { LocalDate(2000, 1, it) },
+            (Jan_24_2000 downTo Jan_01_2000).step(2, DateTimeUnit.DAY)
+        )
+    }
+
+    @Test
+    fun string() {
+        assertEquals(
+            "2000-01-01..2000-01-05",
+            (Jan_01_2000..Jan_05_2000).toString()
+        )
+        assertEquals(
+            "2000-01-05 downTo 2000-01-01 step -1",
+            (Jan_05_2000 downTo Jan_01_2000).toString()
+        )
+        assertEquals(
+            "2000-01-01..2000-01-05 step 1",
+            LocalDateProgression.fromClosedRange(Jan_01_2000, Jan_05_2000, 1, DateTimeUnit.DAY).toString()
+        )
+        assertEquals(
+            "2000-01-05 downTo 2000-01-01 step -1",
+            LocalDateProgression.fromClosedRange(Jan_05_2000, Jan_01_2000, -1, DateTimeUnit.DAY).toString()
+        )
+    }
+
+    @Test
+    fun random() {
+        assertEquals(
+            Jan_01_2000,
+            (Jan_01_2000..Jan_01_2000).random()
+        )
+
+        assertEquals(
+            Jan_01_2000,
+            (Jan_01_2000 downTo Jan_01_2000).random()
+        )
+
+        assertFails {
+            (Jan_02_2000..Jan_01_2000).random()
+        }
+
+        assertNull((Jan_02_2000..Jan_01_2000).randomOrNull())
+
+        val seed = 123456
+        val expectedRand = Random(seed)
+        val actualRand = Random(seed)
+
+        repeat(20) {
+            assertEquals(
+                expectedRand.nextInt(0..23).let { Jan_01_2000.plus(it, DateTimeUnit.DAY) },
+                (Jan_01_2000..Jan_24_2000).random(actualRand)
+            )
+        }
+
+        repeat(20) {
+            assertEquals(
+                expectedRand.nextInt(0..23).let { Jan_24_2000.minus(it, DateTimeUnit.DAY) },
+                (Jan_24_2000 downTo Jan_01_2000).random(actualRand)
+            )
+        }
+
+        listOf(1, 2, 5, 30).forEach { step ->
+            repeat(20) {
+                val range = (0..23 step step)
+                assertEquals(
+                    expectedRand.nextInt(0..range.last / step).let { Jan_01_2000.plus(it * step, DateTimeUnit.DAY) },
+                    (Jan_01_2000..Jan_24_2000).step(step, DateTimeUnit.DAY).random(actualRand)
+                )
+            }
+
+            repeat(20) {
+                val range = (0..23 step step)
+                assertEquals(
+                    expectedRand.nextInt(0..range.last / step).let { Jan_24_2000.minus(it * step, DateTimeUnit.DAY) },
+                    (Jan_24_2000 downTo Jan_01_2000).step(step, DateTimeUnit.DAY).random(actualRand)
+                )
+            }
+        }
+    }
+}