Skip to content

continuous_timeseries.timeseries_continuous#

Definition of a continuous timeseries (TimeseriesContinuous)

This class defines our representation of continuous time series. It is designed to be compatible with the Timeseries and TimeseriesDiscrete. classes. The idea is that we have a units-aware container for handling continuous timeseries. This allows us to implement interpolation, integration and differentiation in a relatively trivial way. We include straight-forward methods to convert to TimeseriesDiscrete as this is what most people are more used to.

Classes:

Name Description
ContinuousFunctionLike

Protocol for classes that can be used as continuous functions
ContinuousFunctionScipyPPoly

Wrapper around scipy's piecewise polynomial
TimeseriesContinuous

Continuous time series representation

Functions:

Name Description
get_plot_points

Get points to plot

ContinuousFunctionLike #

Bases: Protocol

Protocol for classes that can be used as continuous functions

Methods:

Name Description
__call__

Evaluate the function at specific points
antidifferentiate

Antidifferentiate
differentiate

Differentiate
integrate

Integrate
Source code in src/continuous_timeseries/timeseries_continuous.py 
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
class ContinuousFunctionLike(Protocol):
    """
    Protocol for classes that can be used as continuous functions
    """

    def __call__(
        self, x: npt.NDArray[NP_FLOAT_OR_INT], allow_extrapolation: bool = False
    ) -> npt.NDArray[NP_FLOAT_OR_INT]:
        """
        Evaluate the function at specific points

        Parameters
        ----------
        x
            Points at which to evaluate the function

        allow_extrapolation
            Should extrapolatino be allowed?

        Returns
        -------
        :
            The function, evaluated at `x`

        Raises
        ------
        ExtrapolationNotAllowedError
            The user attempted to extrapolate when it isn't allowed.

            Raising this has to be managed by the classes
            that implement this interface as only they know
            the domain over which they are defined.
        """

    def integrate(
        self,
        integration_constant: NP_FLOAT_OR_INT,
        domain_start: NP_FLOAT_OR_INT,
    ) -> ContinuousFunctionLike:
        """
        Integrate

        Parameters
        ----------
        integration_constant
            Integration constant

            This is required for the integral to be a definite integral.

        domain_start
            The start of the domain.

            This is required to ensure that we start at the right point
            when evaluating the definite integral.

        Returns
        -------
        :
            Integral of the function
        """

    def antidifferentiate(
        self,
        domain_start: NP_FLOAT_OR_INT,
    ) -> ContinuousFunctionLike:
        """
        Antidifferentiate

        Parameters
        ----------
        domain_start
            The start of the domain.

            This is required to ensure that we start at the right point
            when evaluating the indefinite integral.

        Returns
        -------
        :
            Indefinite integral of the function
        """

    def differentiate(self) -> ContinuousFunctionLike:
        """
        Differentiate

        Returns
        -------
        :
            Derivative of the function
        """

__call__ #

__call__(
    x: NDArray[NP_FLOAT_OR_INT],
    allow_extrapolation: bool = False,
) -> NDArray[NP_FLOAT_OR_INT]

Evaluate the function at specific points

Parameters:

Name Type Description Default
x NDArray[NP_FLOAT_OR_INT]

Points at which to evaluate the function

 required
allow_extrapolation bool

Should extrapolatino be allowed?

 False

Returns:

Type Description
NDArray[NP_FLOAT_OR_INT]

The function, evaluated at x

Raises:

Type Description
ExtrapolationNotAllowedError

The user attempted to extrapolate when it isn't allowed.

Raising this has to be managed by the classes that implement this interface as only they know the domain over which they are defined.
Source code in src/continuous_timeseries/timeseries_continuous.py 
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
def __call__(
    self, x: npt.NDArray[NP_FLOAT_OR_INT], allow_extrapolation: bool = False
) -> npt.NDArray[NP_FLOAT_OR_INT]:
    """
    Evaluate the function at specific points

    Parameters
    ----------
    x
        Points at which to evaluate the function

    allow_extrapolation
        Should extrapolatino be allowed?

    Returns
    -------
    :
        The function, evaluated at `x`

    Raises
    ------
    ExtrapolationNotAllowedError
        The user attempted to extrapolate when it isn't allowed.

        Raising this has to be managed by the classes
        that implement this interface as only they know
        the domain over which they are defined.
    """

antidifferentiate #

antidifferentiate(
    domain_start: NP_FLOAT_OR_INT,
) -> ContinuousFunctionLike

Antidifferentiate

Parameters:

Name Type Description Default
domain_start NP_FLOAT_OR_INT

The start of the domain.

This is required to ensure that we start at the right point when evaluating the indefinite integral.

 required

Returns:

Type Description
ContinuousFunctionLike

Indefinite integral of the function
Source code in src/continuous_timeseries/timeseries_continuous.py 
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
def antidifferentiate(
    self,
    domain_start: NP_FLOAT_OR_INT,
) -> ContinuousFunctionLike:
    """
    Antidifferentiate

    Parameters
    ----------
    domain_start
        The start of the domain.

        This is required to ensure that we start at the right point
        when evaluating the indefinite integral.

    Returns
    -------
    :
        Indefinite integral of the function
    """

differentiate #

differentiate() -> ContinuousFunctionLike

Differentiate

Returns:

Type Description
ContinuousFunctionLike

Derivative of the function
Source code in src/continuous_timeseries/timeseries_continuous.py 
132
133
134
135
136
137
138
139
140
def differentiate(self) -> ContinuousFunctionLike:
    """
    Differentiate

    Returns
    -------
    :
        Derivative of the function
    """

integrate #

integrate(
    integration_constant: NP_FLOAT_OR_INT,
    domain_start: NP_FLOAT_OR_INT,
) -> ContinuousFunctionLike

Integrate

Parameters:

Name Type Description Default
integration_constant NP_FLOAT_OR_INT

Integration constant

This is required for the integral to be a definite integral.

 required
domain_start NP_FLOAT_OR_INT

The start of the domain.

This is required to ensure that we start at the right point when evaluating the definite integral.

 required

Returns:

Type Description
ContinuousFunctionLike

Integral of the function
Source code in src/continuous_timeseries/timeseries_continuous.py 
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
def integrate(
    self,
    integration_constant: NP_FLOAT_OR_INT,
    domain_start: NP_FLOAT_OR_INT,
) -> ContinuousFunctionLike:
    """
    Integrate

    Parameters
    ----------
    integration_constant
        Integration constant

        This is required for the integral to be a definite integral.

    domain_start
        The start of the domain.

        This is required to ensure that we start at the right point
        when evaluating the definite integral.

    Returns
    -------
    :
        Integral of the function
    """

ContinuousFunctionScipyPPoly #

Wrapper around scipy's piecewise polynomial

The wrapper makes scipy.interpolate.PPoly compatible with the interface expected by ContinuousFunctionLike.

Methods:

Name Description
__call__

Evaluate the function at specific points
__str__

Get string representation of self
antidifferentiate

Antidifferentiate
differentiate

Differentiate
integrate

Integrate

Attributes:

Name Type Description
order int

Order of the polynomial used by this instance
order_str str

String name for the order of the polynomial used by this instance
ppoly PPoly

Wrapped scipy.interpolate.PPoly instance
Source code in src/continuous_timeseries/timeseries_continuous.py 
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
@define
class ContinuousFunctionScipyPPoly:
    """
    Wrapper around scipy's piecewise polynomial

    The wrapper makes [`scipy.interpolate.PPoly`][scipy.interpolate.PPoly]
    compatible with the interface expected by
    [`ContinuousFunctionLike`][(m)].
    """

    ppoly: scipy.interpolate.PPoly
    """
    Wrapped [`scipy.interpolate.PPoly`][scipy.interpolate.PPoly] instance
    """

    # Let attrs take care of __repr__

    def __str__(self) -> str:
        """
        Get string representation of self
        """
        type_self = type(self).__name__

        type_ppoly = type(self.ppoly)
        ppoly_display = f"{type_ppoly.__module__}.{type_ppoly.__name__}"

        ppoly_x = self.ppoly.x
        ppoly_c = self.ppoly.c

        order_s = self.order_str

        res = (
            f"{order_s} order {type_self}("
            f"ppoly={ppoly_display}(c={ppoly_c}, x={ppoly_x})"
            ")"
        )

        return res

    def _repr_pretty_(
        self,
        p: IPython.lib.pretty.RepresentationPrinter,
        cycle: bool,
        indent: int = 4,
    ) -> None:
        """
        Get IPython pretty representation of self

        Used by IPython notebooks and other tools
        """
        type_self = type(self).__name__

        type_ppoly = type(self.ppoly)
        ppoly_display = f"{type_ppoly.__module__}.{type_ppoly.__name__}"

        ppoly_x = self.ppoly.x
        ppoly_c = self.ppoly.c

        order_s = self.order_str

        with p.group(indent, f"{order_s} order {type_self}(", ")"):
            p.breakable("")  # type: ignore
            with p.group(indent, f"ppoly={ppoly_display}(", ")"):
                p.breakable("")  # type: ignore

                p.text("c=")  # type: ignore
                p.pretty(ppoly_c)  # type: ignore
                p.text(",")  # type: ignore
                p.breakable()  # type: ignore

                p.text("x=")  # type: ignore
                p.pretty(ppoly_x)  # type: ignore

    def _repr_html_(self) -> str:
        """
        Get html representation of self

        Used by IPython notebooks and other tools
        """
        type_self = type(self)
        header = f"{type_self.__module__}.{type_self.__name__}"

        repr_internal_row = self._repr_html_internal_row_()

        return continuous_timeseries.formatting.apply_ct_html_styling(
            display_name=header, attribute_table=repr_internal_row
        )

    def _repr_html_internal_row_(self) -> str:
        """
        Get html representation of self

        Used by IPython notebooks and other tools
        """
        attribute_rows: list[str] = []
        attribute_rows = continuous_timeseries.formatting.add_html_attribute_row(
            "order",
            continuous_timeseries.formatting.get_html_repr_safe(self.order),
            attribute_rows,
        )
        for attr_to_show in ["c", "x"]:
            attribute_rows = continuous_timeseries.formatting.add_html_attribute_row(
                attr_to_show,
                continuous_timeseries.formatting.get_html_repr_safe(
                    getattr(self.ppoly, attr_to_show)
                ),
                attribute_rows,
            )

        attribute_table = continuous_timeseries.formatting.make_html_attribute_table(
            attribute_rows
        )
        html_l = [
            "<table><tbody>",
            "  <tr>",
            "    <th>ppoly</th>",
            "    <td style='text-align:left;'>",
            textwrap.indent(attribute_table, "      "),
            "    </td>",
            "  </tr>",
            "</tbody></table>",
        ]

        return "\n".join(html_l)

    @property
    def order(self) -> int:
        """
        Order of the polynomial used by this instance
        """
        return self.ppoly.c.shape[0] - 1

    @property
    def order_str(self) -> str:
        """
        String name for the order of the polynomial used by this instance
        """
        order = self.order

        if order == 1:
            order_str = "1st"
        elif order == 2:  # noqa: PLR2004
            order_str = "2nd"
        elif order == 3:  # noqa: PLR2004
            order_str = "3rd"
        else:
            order_str = f"{order}th"

        return order_str

    def __call__(
        self, x: npt.NDArray[NP_FLOAT_OR_INT], allow_extrapolation: bool = False
    ) -> npt.NDArray[NP_FLOAT_OR_INT]:
        """
        Evaluate the function at specific points

        Parameters
        ----------
        x
            Points at which to evaluate the function

        allow_extrapolation
            Should extrapolatino be allowed?

        Returns
        -------
        :
            The function, evaluated at `x`

        Raises
        ------
        ExtrapolationNotAllowedError
            The user attempted to extrapolate when it isn't allowed.
        """
        res = cast(
            npt.NDArray[NP_FLOAT_OR_INT],
            self.ppoly(x=x, extrapolate=allow_extrapolation),
        )

        return res

    def integrate(
        self,
        integration_constant: NP_FLOAT_OR_INT,
        domain_start: NP_FLOAT_OR_INT,
    ) -> ContinuousFunctionLike:
        """
        Integrate

        Parameters
        ----------
        integration_constant
            Integration constant

            This is required for the integral to be a definite integral.

        domain_start
            The start of the domain.

            This is required to ensure that we start at the right point
            when evaluating the definite integral.

        Returns
        -------
        :
            Integral of the function
        """
        try:
            import scipy.interpolate
        except ImportError as exc:
            raise MissingOptionalDependencyError(
                "ContinuousFunctionScipyPPoly.integrate", requirement="scipy"
            ) from exc

        indefinite_integral = self.ppoly.antiderivative()

        c_new = indefinite_integral.c
        c_new[-1, :] = (
            c_new[-1, :]
            + integration_constant
            - indefinite_integral(domain_start, extrapolate=True)  # type: ignore # scipy-stubs expects array
        )

        ppoly_integral = scipy.interpolate.PPoly(
            c=c_new,
            x=indefinite_integral.x,
            extrapolate=False,  # no extrapolation by default
        )

        return type(self)(ppoly_integral)

    def antidifferentiate(
        self,
        domain_start: NP_FLOAT_OR_INT,
    ) -> ContinuousFunctionLike:
        """
        Antidifferentiate

        Parameters
        ----------
        domain_start
            The start of the domain.

            This is not actually used here,
            but is required to match the API expected
            in other places.

        Returns
        -------
        :
            Indefinite integral of the function
        """
        indefinite_integral = self.ppoly.antiderivative()

        return type(self)(indefinite_integral)

    def differentiate(self) -> ContinuousFunctionLike:
        """
        Differentiate

        Returns
        -------
        :
            Derivative of the function
        """
        return type(self)(self.ppoly.derivative())

order property #

order: int

Order of the polynomial used by this instance

order_str property #

order_str: str

String name for the order of the polynomial used by this instance

ppoly instance-attribute #

ppoly: PPoly

Wrapped scipy.interpolate.PPoly instance

__call__ #

__call__(
    x: NDArray[NP_FLOAT_OR_INT],
    allow_extrapolation: bool = False,
) -> NDArray[NP_FLOAT_OR_INT]

Evaluate the function at specific points

Parameters:

Name Type Description Default
x NDArray[NP_FLOAT_OR_INT]

Points at which to evaluate the function

 required
allow_extrapolation bool

Should extrapolatino be allowed?

 False

Returns:

Type Description
NDArray[NP_FLOAT_OR_INT]

The function, evaluated at x

Raises:

Type Description
ExtrapolationNotAllowedError

The user attempted to extrapolate when it isn't allowed.
Source code in src/continuous_timeseries/timeseries_continuous.py 
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
def __call__(
    self, x: npt.NDArray[NP_FLOAT_OR_INT], allow_extrapolation: bool = False
) -> npt.NDArray[NP_FLOAT_OR_INT]:
    """
    Evaluate the function at specific points

    Parameters
    ----------
    x
        Points at which to evaluate the function

    allow_extrapolation
        Should extrapolatino be allowed?

    Returns
    -------
    :
        The function, evaluated at `x`

    Raises
    ------
    ExtrapolationNotAllowedError
        The user attempted to extrapolate when it isn't allowed.
    """
    res = cast(
        npt.NDArray[NP_FLOAT_OR_INT],
        self.ppoly(x=x, extrapolate=allow_extrapolation),
    )

    return res

__str__ #

__str__() -> str

Get string representation of self

Source code in src/continuous_timeseries/timeseries_continuous.py 
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
def __str__(self) -> str:
    """
    Get string representation of self
    """
    type_self = type(self).__name__

    type_ppoly = type(self.ppoly)
    ppoly_display = f"{type_ppoly.__module__}.{type_ppoly.__name__}"

    ppoly_x = self.ppoly.x
    ppoly_c = self.ppoly.c

    order_s = self.order_str

    res = (
        f"{order_s} order {type_self}("
        f"ppoly={ppoly_display}(c={ppoly_c}, x={ppoly_x})"
        ")"
    )

    return res

antidifferentiate #

antidifferentiate(
    domain_start: NP_FLOAT_OR_INT,
) -> ContinuousFunctionLike

Antidifferentiate

Parameters:

Name Type Description Default
domain_start NP_FLOAT_OR_INT

The start of the domain.

This is not actually used here, but is required to match the API expected in other places.

 required

Returns:

Type Description
ContinuousFunctionLike

Indefinite integral of the function
Source code in src/continuous_timeseries/timeseries_continuous.py 
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
def antidifferentiate(
    self,
    domain_start: NP_FLOAT_OR_INT,
) -> ContinuousFunctionLike:
    """
    Antidifferentiate

    Parameters
    ----------
    domain_start
        The start of the domain.

        This is not actually used here,
        but is required to match the API expected
        in other places.

    Returns
    -------
    :
        Indefinite integral of the function
    """
    indefinite_integral = self.ppoly.antiderivative()

    return type(self)(indefinite_integral)

differentiate #

differentiate() -> ContinuousFunctionLike

Differentiate

Returns:

Type Description
ContinuousFunctionLike

Derivative of the function
Source code in src/continuous_timeseries/timeseries_continuous.py 
399
400
401
402
403
404
405
406
407
408
def differentiate(self) -> ContinuousFunctionLike:
    """
    Differentiate

    Returns
    -------
    :
        Derivative of the function
    """
    return type(self)(self.ppoly.derivative())

integrate #

integrate(
    integration_constant: NP_FLOAT_OR_INT,
    domain_start: NP_FLOAT_OR_INT,
) -> ContinuousFunctionLike

Integrate

Parameters:

Name Type Description Default
integration_constant NP_FLOAT_OR_INT

Integration constant

This is required for the integral to be a definite integral.

 required
domain_start NP_FLOAT_OR_INT

The start of the domain.

This is required to ensure that we start at the right point when evaluating the definite integral.

 required

Returns:

Type Description
ContinuousFunctionLike

Integral of the function
Source code in src/continuous_timeseries/timeseries_continuous.py 
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
def integrate(
    self,
    integration_constant: NP_FLOAT_OR_INT,
    domain_start: NP_FLOAT_OR_INT,
) -> ContinuousFunctionLike:
    """
    Integrate

    Parameters
    ----------
    integration_constant
        Integration constant

        This is required for the integral to be a definite integral.

    domain_start
        The start of the domain.

        This is required to ensure that we start at the right point
        when evaluating the definite integral.

    Returns
    -------
    :
        Integral of the function
    """
    try:
        import scipy.interpolate
    except ImportError as exc:
        raise MissingOptionalDependencyError(
            "ContinuousFunctionScipyPPoly.integrate", requirement="scipy"
        ) from exc

    indefinite_integral = self.ppoly.antiderivative()

    c_new = indefinite_integral.c
    c_new[-1, :] = (
        c_new[-1, :]
        + integration_constant
        - indefinite_integral(domain_start, extrapolate=True)  # type: ignore # scipy-stubs expects array
    )

    ppoly_integral = scipy.interpolate.PPoly(
        c=c_new,
        x=indefinite_integral.x,
        extrapolate=False,  # no extrapolation by default
    )

    return type(self)(ppoly_integral)

TimeseriesContinuous #

Continuous time series representation

Methods:

Name Description
__str__

Get string representation of self
antidifferentiate

Antidifferentiate
differentiate

Differentiate
domain_validator

Validate the received values
integrate

Integrate
interpolate

Interpolate values on a given time axis
plot

Plot the function
to_discrete_timeseries

Convert to TimeseriesDiscrete

Attributes:

Name Type Description
domain tuple[PINT_SCALAR, PINT_SCALAR]

Domain over which the function can be evaluated
function ContinuousFunctionLike

The continuous function that represents this timeseries.
name str

Name of the timeseries
time_units PlainUnit

The units of the time axis
values_units PlainUnit

The units of the values
Source code in src/continuous_timeseries/timeseries_continuous.py 
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
@define
class TimeseriesContinuous:
    """
    Continuous time series representation
    """

    name: str
    """Name of the timeseries"""

    time_units: pint.facets.plain.PlainUnit
    """The units of the time axis"""

    values_units: pint.facets.plain.PlainUnit
    """The units of the values"""

    function: ContinuousFunctionLike
    """
    The continuous function that represents this timeseries.
    """

    domain: tuple[PINT_SCALAR, PINT_SCALAR] = field()
    """
    Domain over which the function can be evaluated
    """

    @domain.validator
    def domain_validator(
        self,
        attribute: attr.Attribute[Any],
        value: tuple[PINT_SCALAR, PINT_SCALAR],
    ) -> None:
        """
        Validate the received values
        """
        try:
            validate_domain(value)
        except AssertionError as exc:
            msg = "The value supplied for `domain` failed validation."
            raise ValueError(msg) from exc

    # Let attrs take care of __repr__

    def __str__(self) -> str:
        """
        Get string representation of self
        """
        return continuous_timeseries.formatting.to_str(
            self,
            [a.name for a in self.__attrs_attrs__],
        )

    def _repr_pretty_(
        self,
        p: IPython.lib.pretty.RepresentationPrinter,
        cycle: bool,
        indent: int = 4,
    ) -> None:
        """
        Get IPython pretty representation of self

        Used by IPython notebooks and other tools
        """
        continuous_timeseries.formatting.to_pretty(
            self,
            [a.name for a in self.__attrs_attrs__],
            p=p,
            cycle=cycle,
        )

    def _repr_html_(self) -> str:
        """
        Get html representation of self

        Used by IPython notebooks and other tools
        """
        return continuous_timeseries.formatting.to_html(
            self,
            [a.name for a in self.__attrs_attrs__],
            prefix="continuous_timeseries.",
        )

    def _repr_html_internal_row_(self) -> str:
        """
        Get html representation of self to use as an internal row of another object

        Used to avoid our representations having more information than we'd like.
        """
        return continuous_timeseries.formatting.to_html(
            self,
            [a.name for a in self.__attrs_attrs__],
            include_header=False,
        )

    def to_discrete_timeseries(
        self,
        time_axis: TimeAxis,
        allow_extrapolation: bool = False,
    ) -> TimeseriesDiscrete:
        """
        Convert to [`TimeseriesDiscrete`][(p)]

        Parameters
        ----------
        time_axis
            Time axis to use for the conversion

        allow_extrapolation
            Should extrapolation be allowed during the conversion?

        Returns
        -------
        :
            Discrete representation of `self`
        """
        # Late import to avoid circularity
        from continuous_timeseries.timeseries_discrete import TimeseriesDiscrete

        res = TimeseriesDiscrete(
            name=self.name,
            time_axis=time_axis,
            values_at_bounds=ValuesAtBounds(
                self.interpolate(time_axis, allow_extrapolation=allow_extrapolation)
            ),
        )

        return res

    def interpolate(
        self, time_axis: TimeAxis | PINT_NUMPY_ARRAY, allow_extrapolation: bool = False
    ) -> PINT_NUMPY_ARRAY:
        """
        Interpolate values on a given time axis

        Parameters
        ----------
        time_axis
            Time axis onto which to interpolate values

        allow_extrapolation
            Should extrapolation be allowed while interpolating?

        Returns
        -------
        :
            Interpolated values
        """
        if isinstance(time_axis, TimeAxis):
            time_axis = time_axis.bounds

        if not allow_extrapolation:
            try:
                check_no_times_outside_domain(
                    time_axis,
                    domain=self.domain,
                )
            except ValueError as exc:
                msg = f"Extrapolation is not allowed ({allow_extrapolation=})."
                raise ExtrapolationNotAllowedError(msg) from exc

        times_m = time_axis.to(self.time_units).m
        values_m = self.function(
            times_m,
            # We have already checked the domain above.
            # Hence, we want the function to extrapolate if needed.
            allow_extrapolation=True,
        )

        if np.isnan(values_m).any():  # pragma: no cover
            # This is an escape hatch.
            # In general, we expect `self.function` to handle NaNs
            # before we get to this point.
            msg = (
                "The result of calling `self.function` contains NaNs. "
                f"The result is {values_m!r}."
            )
            raise AssertionError(msg)

        res: PINT_NUMPY_ARRAY = values_m * self.values_units

        return res

    def integrate(
        self, integration_constant: PINT_SCALAR, name_res: str | None = None
    ) -> TimeseriesContinuous:
        """
        Integrate

        Parameters
        ----------
        integration_constant
            Integration constant to use when performing the integration

        name_res
            Name to use for the output.

            If not supplied, we use f"{self.name}_integral".

        Returns
        -------
        :
            Integral of `self`.
        """
        if name_res is None:
            name_res = f"{self.name}_integral"

        integral_values_units = self.values_units * self.time_units

        integral = self.function.integrate(
            integration_constant=integration_constant.to(integral_values_units).m,
            domain_start=self.domain[0].to(self.time_units).m,
        )

        return type(self)(
            name=name_res,
            time_units=self.time_units,
            values_units=integral_values_units,
            function=integral,
            domain=self.domain,
        )

    def antidifferentiate(self, name_res: str | None = None) -> TimeseriesContinuous:
        """
        Antidifferentiate

        Parameters
        ----------
        name_res
            Name to use for the output.

            If not supplied, we use f"{self.name}_antiderivative".

        Returns
        -------
        :
            Antiderivative of `self`.
        """
        if name_res is None:
            name_res = f"{self.name}_antiderivative"

        antiderivative_values_units = self.values_units * self.time_units

        antiderivative = self.function.antidifferentiate(
            domain_start=self.domain[0].to(self.time_units).m,
        )

        return type(self)(
            name=name_res,
            time_units=self.time_units,
            values_units=antiderivative_values_units,
            function=antiderivative,
            domain=self.domain,
        )

    def differentiate(self, name_res: str | None = None) -> TimeseriesContinuous:
        """
        Differentiate

        Parameters
        ----------
        name_res
            Name to use for the output.

            If not supplied, we use f"{self.name}_derivative".

        Returns
        -------
        :
            Integral of `self`.
        """
        if name_res is None:
            name_res = f"{self.name}_derivative"

        derivative_values_units = self.values_units / self.time_units

        derivative = self.function.differentiate()

        return type(self)(
            name=name_res,
            time_units=self.time_units,
            values_units=derivative_values_units,
            function=derivative,
            domain=self.domain,
        )

    def plot(
        self,
        time_axis: TimeAxis | PINT_NUMPY_ARRAY,
        res_increase: int = 500,
        label: str | None = None,
        ax: matplotlib.axes.Axes | None = None,
        warn_if_plotting_magnitudes: bool = True,
        **kwargs: Any,
    ) -> matplotlib.axes.Axes:
        """
        Plot the function

        We can't see an easy way to plot the continuous function exactly,
        so we approximate by interpolating very finely
        then just using a standard linear interpolation between the points.

        Parameters
        ----------
        time_axis
            Time axis to use for plotting.

            All points in `time_axis` will be included as plotting points.

        res_increase
            The amount by which to increase the resolution of the x-axis when plotting.

            If equal to 1, then only the points in `time_axis` will be plotted.
            If equal to 100, then there will be 100 times as many points
            plotted as the number of points in `time_axis`.
            If equal to n, then there will be n times as many points
            plotted as the number of points in `time_axis`.

        label
            Label to use when plotting the data.

            If not supplied, we use the `self.name`.

        ax
            Axes on which to plot.

            If not supplied, a set of axes will be created.

        warn_if_plotting_magnitudes
            Should a warning be raised if the units of the values
            are not considered while plotting?

        **kwargs
            Keyword arguments to pass to `ax.plot`.

        Returns
        -------
        :
            Axes on which the data was plotted
        """
        if isinstance(time_axis, TimeAxis):
            time_axis = time_axis.bounds

        if label is None:
            label = self.name

        if ax is None:
            try:
                import matplotlib.pyplot as plt
            except ImportError as exc:
                raise MissingOptionalDependencyError(
                    "TimeseriesContinuous.plot", requirement="matplotlib"
                ) from exc

            _, ax = plt.subplots()

        # Interpolate based on res_increase.
        # Then plot interpolated using linear joins
        # (as far as I can tell, this is the only general way to do this,
        # although it is slower than using e.g. step for piecewise constant stuff).)
        plot_points = get_plot_points(time_axis, res_increase=res_increase)
        plot_values = self.interpolate(plot_points)

        x_vals = get_plot_vals(
            plot_points,
            "time_axis",
            warn_if_magnitudes=warn_if_plotting_magnitudes,
        )
        y_vals = get_plot_vals(
            plot_values,
            "show_values",
            warn_if_magnitudes=warn_if_plotting_magnitudes,
        )

        ax.plot(x_vals, y_vals, label=label, **kwargs)

        return ax

domain class-attribute instance-attribute #

domain: tuple[PINT_SCALAR, PINT_SCALAR] = field()

Domain over which the function can be evaluated

function instance-attribute #

function: ContinuousFunctionLike

The continuous function that represents this timeseries.

name instance-attribute #

name: str

Name of the timeseries

time_units instance-attribute #

time_units: PlainUnit

The units of the time axis

values_units instance-attribute #

values_units: PlainUnit

The units of the values

__str__ #

__str__() -> str

Get string representation of self

Source code in src/continuous_timeseries/timeseries_continuous.py 
453
454
455
456
457
458
459
460
def __str__(self) -> str:
    """
    Get string representation of self
    """
    return continuous_timeseries.formatting.to_str(
        self,
        [a.name for a in self.__attrs_attrs__],
    )

antidifferentiate #

antidifferentiate(
    name_res: str | None = None,
) -> TimeseriesContinuous

Antidifferentiate

Parameters:

Name Type Description Default
name_res str | None

Name to use for the output.

If not supplied, we use f"{self.name}_antiderivative".

 None

Returns:

Type Description
TimeseriesContinuous

Antiderivative of self.
Source code in src/continuous_timeseries/timeseries_continuous.py 
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
def antidifferentiate(self, name_res: str | None = None) -> TimeseriesContinuous:
    """
    Antidifferentiate

    Parameters
    ----------
    name_res
        Name to use for the output.

        If not supplied, we use f"{self.name}_antiderivative".

    Returns
    -------
    :
        Antiderivative of `self`.
    """
    if name_res is None:
        name_res = f"{self.name}_antiderivative"

    antiderivative_values_units = self.values_units * self.time_units

    antiderivative = self.function.antidifferentiate(
        domain_start=self.domain[0].to(self.time_units).m,
    )

    return type(self)(
        name=name_res,
        time_units=self.time_units,
        values_units=antiderivative_values_units,
        function=antiderivative,
        domain=self.domain,
    )

differentiate #

differentiate(
    name_res: str | None = None,
) -> TimeseriesContinuous

Differentiate

Parameters:

Name Type Description Default
name_res str | None

Name to use for the output.

If not supplied, we use f"{self.name}_derivative".

 None

Returns:

Type Description
TimeseriesContinuous

Integral of self.
Source code in src/continuous_timeseries/timeseries_continuous.py 
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
def differentiate(self, name_res: str | None = None) -> TimeseriesContinuous:
    """
    Differentiate

    Parameters
    ----------
    name_res
        Name to use for the output.

        If not supplied, we use f"{self.name}_derivative".

    Returns
    -------
    :
        Integral of `self`.
    """
    if name_res is None:
        name_res = f"{self.name}_derivative"

    derivative_values_units = self.values_units / self.time_units

    derivative = self.function.differentiate()

    return type(self)(
        name=name_res,
        time_units=self.time_units,
        values_units=derivative_values_units,
        function=derivative,
        domain=self.domain,
    )

domain_validator #

domain_validator(
    attribute: Attribute[Any],
    value: tuple[PINT_SCALAR, PINT_SCALAR],
) -> None

Validate the received values

Source code in src/continuous_timeseries/timeseries_continuous.py 
436
437
438
439
440
441
442
443
444
445
446
447
448
449
@domain.validator
def domain_validator(
    self,
    attribute: attr.Attribute[Any],
    value: tuple[PINT_SCALAR, PINT_SCALAR],
) -> None:
    """
    Validate the received values
    """
    try:
        validate_domain(value)
    except AssertionError as exc:
        msg = "The value supplied for `domain` failed validation."
        raise ValueError(msg) from exc

integrate #

integrate(
    integration_constant: PINT_SCALAR,
    name_res: str | None = None,
) -> TimeseriesContinuous

Integrate

Parameters:

Name Type Description Default
integration_constant PINT_SCALAR

Integration constant to use when performing the integration

 required
name_res str | None

Name to use for the output.

If not supplied, we use f"{self.name}_integral".

 None

Returns:

Type Description
TimeseriesContinuous

Integral of self.
Source code in src/continuous_timeseries/timeseries_continuous.py 
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
def integrate(
    self, integration_constant: PINT_SCALAR, name_res: str | None = None
) -> TimeseriesContinuous:
    """
    Integrate

    Parameters
    ----------
    integration_constant
        Integration constant to use when performing the integration

    name_res
        Name to use for the output.

        If not supplied, we use f"{self.name}_integral".

    Returns
    -------
    :
        Integral of `self`.
    """
    if name_res is None:
        name_res = f"{self.name}_integral"

    integral_values_units = self.values_units * self.time_units

    integral = self.function.integrate(
        integration_constant=integration_constant.to(integral_values_units).m,
        domain_start=self.domain[0].to(self.time_units).m,
    )

    return type(self)(
        name=name_res,
        time_units=self.time_units,
        values_units=integral_values_units,
        function=integral,
        domain=self.domain,
    )

interpolate #

interpolate(
    time_axis: TimeAxis | PINT_NUMPY_ARRAY,
    allow_extrapolation: bool = False,
) -> PINT_NUMPY_ARRAY

Interpolate values on a given time axis

Parameters:

Name Type Description Default
time_axis TimeAxis | PINT_NUMPY_ARRAY

Time axis onto which to interpolate values

 required
allow_extrapolation bool

Should extrapolation be allowed while interpolating?

 False

Returns:

Type Description
PINT_NUMPY_ARRAY

Interpolated values
Source code in src/continuous_timeseries/timeseries_continuous.py 
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
def interpolate(
    self, time_axis: TimeAxis | PINT_NUMPY_ARRAY, allow_extrapolation: bool = False
) -> PINT_NUMPY_ARRAY:
    """
    Interpolate values on a given time axis

    Parameters
    ----------
    time_axis
        Time axis onto which to interpolate values

    allow_extrapolation
        Should extrapolation be allowed while interpolating?

    Returns
    -------
    :
        Interpolated values
    """
    if isinstance(time_axis, TimeAxis):
        time_axis = time_axis.bounds

    if not allow_extrapolation:
        try:
            check_no_times_outside_domain(
                time_axis,
                domain=self.domain,
            )
        except ValueError as exc:
            msg = f"Extrapolation is not allowed ({allow_extrapolation=})."
            raise ExtrapolationNotAllowedError(msg) from exc

    times_m = time_axis.to(self.time_units).m
    values_m = self.function(
        times_m,
        # We have already checked the domain above.
        # Hence, we want the function to extrapolate if needed.
        allow_extrapolation=True,
    )

    if np.isnan(values_m).any():  # pragma: no cover
        # This is an escape hatch.
        # In general, we expect `self.function` to handle NaNs
        # before we get to this point.
        msg = (
            "The result of calling `self.function` contains NaNs. "
            f"The result is {values_m!r}."
        )
        raise AssertionError(msg)

    res: PINT_NUMPY_ARRAY = values_m * self.values_units

    return res

plot #

plot(
    time_axis: TimeAxis | PINT_NUMPY_ARRAY,
    res_increase: int = 500,
    label: str | None = None,
    ax: Axes | None = None,
    warn_if_plotting_magnitudes: bool = True,
    **kwargs: Any,
) -> Axes

Plot the function

We can't see an easy way to plot the continuous function exactly, so we approximate by interpolating very finely then just using a standard linear interpolation between the points.

Parameters:

Name Type Description Default
time_axis TimeAxis | PINT_NUMPY_ARRAY

Time axis to use for plotting.

All points in time_axis will be included as plotting points.

 required
res_increase int

The amount by which to increase the resolution of the x-axis when plotting.

If equal to 1, then only the points in time_axis will be plotted. If equal to 100, then there will be 100 times as many points plotted as the number of points in time_axis. If equal to n, then there will be n times as many points plotted as the number of points in time_axis.

 500
label str | None

Label to use when plotting the data.

If not supplied, we use the self.name.

 None
ax Axes | None

Axes on which to plot.

If not supplied, a set of axes will be created.

 None
warn_if_plotting_magnitudes bool

Should a warning be raised if the units of the values are not considered while plotting?

 True
**kwargs Any

Keyword arguments to pass to ax.plot.

 {}

Returns:

Type Description
Axes

Axes on which the data was plotted
Source code in src/continuous_timeseries/timeseries_continuous.py 
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
def plot(
    self,
    time_axis: TimeAxis | PINT_NUMPY_ARRAY,
    res_increase: int = 500,
    label: str | None = None,
    ax: matplotlib.axes.Axes | None = None,
    warn_if_plotting_magnitudes: bool = True,
    **kwargs: Any,
) -> matplotlib.axes.Axes:
    """
    Plot the function

    We can't see an easy way to plot the continuous function exactly,
    so we approximate by interpolating very finely
    then just using a standard linear interpolation between the points.

    Parameters
    ----------
    time_axis
        Time axis to use for plotting.

        All points in `time_axis` will be included as plotting points.

    res_increase
        The amount by which to increase the resolution of the x-axis when plotting.

        If equal to 1, then only the points in `time_axis` will be plotted.
        If equal to 100, then there will be 100 times as many points
        plotted as the number of points in `time_axis`.
        If equal to n, then there will be n times as many points
        plotted as the number of points in `time_axis`.

    label
        Label to use when plotting the data.

        If not supplied, we use the `self.name`.

    ax
        Axes on which to plot.

        If not supplied, a set of axes will be created.

    warn_if_plotting_magnitudes
        Should a warning be raised if the units of the values
        are not considered while plotting?

    **kwargs
        Keyword arguments to pass to `ax.plot`.

    Returns
    -------
    :
        Axes on which the data was plotted
    """
    if isinstance(time_axis, TimeAxis):
        time_axis = time_axis.bounds

    if label is None:
        label = self.name

    if ax is None:
        try:
            import matplotlib.pyplot as plt
        except ImportError as exc:
            raise MissingOptionalDependencyError(
                "TimeseriesContinuous.plot", requirement="matplotlib"
            ) from exc

        _, ax = plt.subplots()

    # Interpolate based on res_increase.
    # Then plot interpolated using linear joins
    # (as far as I can tell, this is the only general way to do this,
    # although it is slower than using e.g. step for piecewise constant stuff).)
    plot_points = get_plot_points(time_axis, res_increase=res_increase)
    plot_values = self.interpolate(plot_points)

    x_vals = get_plot_vals(
        plot_points,
        "time_axis",
        warn_if_magnitudes=warn_if_plotting_magnitudes,
    )
    y_vals = get_plot_vals(
        plot_values,
        "show_values",
        warn_if_magnitudes=warn_if_plotting_magnitudes,
    )

    ax.plot(x_vals, y_vals, label=label, **kwargs)

    return ax

to_discrete_timeseries #

to_discrete_timeseries(
    time_axis: TimeAxis, allow_extrapolation: bool = False
) -> TimeseriesDiscrete

Convert to TimeseriesDiscrete

Parameters:

Name Type Description Default
time_axis TimeAxis

Time axis to use for the conversion

 required
allow_extrapolation bool

Should extrapolation be allowed during the conversion?

 False

Returns:

Type Description
TimeseriesDiscrete

Discrete representation of self
Source code in src/continuous_timeseries/timeseries_continuous.py 
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
def to_discrete_timeseries(
    self,
    time_axis: TimeAxis,
    allow_extrapolation: bool = False,
) -> TimeseriesDiscrete:
    """
    Convert to [`TimeseriesDiscrete`][(p)]

    Parameters
    ----------
    time_axis
        Time axis to use for the conversion

    allow_extrapolation
        Should extrapolation be allowed during the conversion?

    Returns
    -------
    :
        Discrete representation of `self`
    """
    # Late import to avoid circularity
    from continuous_timeseries.timeseries_discrete import TimeseriesDiscrete

    res = TimeseriesDiscrete(
        name=self.name,
        time_axis=time_axis,
        values_at_bounds=ValuesAtBounds(
            self.interpolate(time_axis, allow_extrapolation=allow_extrapolation)
        ),
    )

    return res

get_plot_points #

get_plot_points(
    time_axis: PINT_NUMPY_ARRAY, res_increase: int
) -> PINT_NUMPY_ARRAY

Get points to plot

Parameters:

Name Type Description Default
time_axis PINT_NUMPY_ARRAY

Time axis to use for plotting

 required
res_increase int

The increase in resolution we want to use when plotting.

In each window defined by time_axis[n] to time_axis[n + 1], res_increase - 1 evenly spaced points between time_axis[n] and time_axis[n + 1] will be generated. The points defined by time_axis are also included. As a result, the total number of plotted points is equal to time_axis.size + (res_increase - 1) * (time_axis.size - 1).

 required

Returns:

Type Description
PINT_NUMPY_ARRAY

Points to plot

Examples:

>>> import pint
>>> UR = pint.get_application_registry()
>>> Q = UR.Quantity
>>>
>>> time_axis = Q([2000, 2010, 2020, 2025], "yr")
>>>
>>> # Passing in res_increase equal to 1 simply returns the input values
>>> get_plot_points(time_axis, res_increase=1)
<Quantity([2000. 2010. 2020. 2025.], 'year')>
>>>
>>> # 'Double' the resolution
>>> get_plot_points(time_axis, res_increase=2)
<Quantity([2000.  2005.  2010.  2015.  2020.  2022.5 2025. ], 'year')>
>>>
>>> # 'Triple' the resolution
>>> get_plot_points(time_axis, res_increase=3)
<Quantity([2000.         2003.33333333 2006.66666667 2010.         2013.33333333
 2016.66666667 2020.         2021.66666667 2023.33333333 2025.        ], 'year')>
Source code in src/continuous_timeseries/timeseries_continuous.py 
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
def get_plot_points(time_axis: PINT_NUMPY_ARRAY, res_increase: int) -> PINT_NUMPY_ARRAY:
    """
    Get points to plot

    Parameters
    ----------
    time_axis
        Time axis to use for plotting

    res_increase
        The increase in resolution we want to use when plotting.

        In each window defined by `time_axis[n]` to `time_axis[n + 1]`,
        `res_increase - 1` evenly spaced points
        between `time_axis[n]` and `time_axis[n + 1]` will be generated.
        The points defined by `time_axis` are also included.
        As a result, the total number of plotted points is equal to
        `time_axis.size + (res_increase - 1) * (time_axis.size - 1)`.

    Returns
    -------
    :
        Points to plot

    Examples
    --------
    >>> import pint
    >>> UR = pint.get_application_registry()
    >>> Q = UR.Quantity
    >>>
    >>> time_axis = Q([2000, 2010, 2020, 2025], "yr")
    >>>
    >>> # Passing in res_increase equal to 1 simply returns the input values
    >>> get_plot_points(time_axis, res_increase=1)
    <Quantity([2000. 2010. 2020. 2025.], 'year')>
    >>>
    >>> # 'Double' the resolution
    >>> get_plot_points(time_axis, res_increase=2)
    <Quantity([2000.  2005.  2010.  2015.  2020.  2022.5 2025. ], 'year')>
    >>>
    >>> # 'Triple' the resolution
    >>> get_plot_points(time_axis, res_increase=3)
    <Quantity([2000.         2003.33333333 2006.66666667 2010.         2013.33333333
     2016.66666667 2020.         2021.66666667 2023.33333333 2025.        ], 'year')>
    """
    time_axis_internal = time_axis[:-1]
    step_fractions = np.linspace(0.0, (res_increase - 1) / res_increase, res_increase)
    time_deltas = time_axis[1:] - time_axis[:-1]

    time_axis_rep = (
        np.repeat(time_axis_internal.m, step_fractions.size) * time_axis_internal.u
    )
    step_fractions_rep = np.tile(step_fractions, time_axis_internal.size)
    time_axis_deltas_rep = np.repeat(time_deltas.m, step_fractions.size) * time_deltas.u

    res: PINT_NUMPY_ARRAY = np.hstack(  # type: ignore # mypy confused by numpy and pint
        [
            time_axis_rep + time_axis_deltas_rep * step_fractions_rep,
            time_axis[-1],
        ]
    )

    return res