Narrowing a days and time duration

Narrowing › days and time duration. The names in the examples are those of section 2.

A days and time duration alternative is the bare kind or {:days_and_time_duration, set}: a Feel.Type.NumberSet of the image of the values, their number of seconds, with a fraction (Feel.Type.Image, D-109). The image is one-to-one and keeps the order, and for a duration it keeps the operations too: the image of a + b is the sum of the images, and of a * n the image of a times n. A days and time duration is a different kind from a years and months duration, and they are never compared.

Comparisons

The null rules are those of every kind (the rule). dd < ym is never true: the kinds have no order between them.

Properties

The components (Table 67) are worked out from the magnitude of the amount and take its sign, as Feel.Runtime.Path does:

A fact about a property is a fact about the duration (D-194): the amounts whose component is what the fact leaves. The days and the value are in a row and leave one interval; the hours, minutes and seconds come back every day, hour or minute, and leave a piece for each. So days and value are exact on any set, and the others need a bounded one:

dd.days = 0 is symmetric around zero because the sign is put back. dd.days >= 1 and dd.hours = 0 keeps the days and drops the hours: the hours would need a piece for each day of an unbounded set.

With allowed values the set is bounded and the components have pieces to keep (dds is in [PT0S..P3D]):

• A piece for each day is what dds.hours >= 18 leaves, and the exact set is a union of three intervals. P3D on its own is the one amount of the last day that is not below the end.
• dds.minutes = 30 has a piece for each hour, which is more than 16 for three days: the set is the hull, from the first half hour to the end, a superset.
• The second row of the table is the and of two comparisons of the value, which meet exactly.

Arithmetic in a comparison

A days and time duration is added, subtracted, multiplied and divided by a number as a number is, so an operation in a comparison narrows the operand by the preimage (number):

The number that multiplies is narrowed too (@"PT1H" * x > @"PT2H" needs x above 2). dd * x > @"PT1H" cannot be true for a zero in either operand, so both lose it.

The else is read as it is for numbers (number): the durations the comparison is false for, and those for which the operation is null (Feel.Analysis.Failure, the seconds being a number). A sum with a constant cannot be (dd + @"PT1H" > … has no more than the first), a product or a quotient can: dd * 2 < @"PT1H" is not true of a duration of more than half of the largest number of seconds, for which the product is null. A duration of 10^30 seconds or more is written as its seconds, in scientific notation (PT4.999999999999999999999999999999999E+6144S), and not as thousands of digits of days. A duration next to a duration or a number that is not known is null for some (and every) duration, and the else says nothing of it.

The types of the arithmetic itself are Feel.Analysis.Inference's:

Full analysis recognizes the repeated read in the last two rows (D-170, D-207). A non-null duration subtracts from itself to zero; it divides by itself to one unless it is zero, which gives null. The core tier keeps independent-operand types for repeated reads.

Limits

• A set of more than 16 pieces is replaced by the one interval that holds them all.
• A property of an unbounded set (dd.hours, dd.minutes, dd.seconds) says nothing: every value of the remainder is in a long enough interval (hours in a day, minutes in an hour).
• The amounts are as fine as a number goes, so the ends of a duration have up to 34 digits.
• Repeated addition still sums independent intervals. If a duration is either one or six seconds, dd + dd has a type containing seven seconds, although only two or twelve seconds can be returned.

See also: years and months duration, date and time, number.