diff --git a/.JuliaFormatter.toml b/.JuliaFormatter.toml
new file mode 100644
index 0000000..6f2d942
--- /dev/null
+++ b/.JuliaFormatter.toml
@@ -0,0 +1,9 @@
+# .JuliaFormatter.toml
+
+margin = 92 # The maximum line length for code
+short_to_long_function_def = true # Whether to use short or long function definitions
+always_use_return = true # Whether to always use the return keyword in functions
+separate_kwargs_with_semicolon = false # Whether to separate keyword arguments with semicolons instead of commas
+join_lines_based_on_source = false # Whether to join lines based on source code instead of formatting rules
+whitespace_in_kwargs = true # Whether to include whitespace around keyword argument separators
+remove_extra_newlines = true # Whether to remove extra newlines in code
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..4ce54a6
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1 @@
+assets/* linguist-generated=true
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
new file mode 100644
index 0000000..6f01dae
--- /dev/null
+++ b/.github/CODEOWNERS
@@ -0,0 +1,7 @@
+/.github/ @gryumov
+/src/ @gryumov
+/test/ @gryumov
+/.JuliaFormatter.toml @gryumov
+/.gitignore @gryumov
+/LICENSE @gryumov
+/Project.toml @gryumov
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 0000000..9398e23
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,41 @@
+---
+name: 'Bug report'
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+Describe the bug
+---
+> A clear and concise description of what the bug is.
+
+
+
+To Reproduce
+---
+> Add a Minimal, Complete, and Verifiable example (for more details, see e.g. https://stackoverflow.com/help/mcve)
+>
+> If the code is too long, feel free to put it in a public gist and link
+it in the issue: https://gist.github.com
+
+```julia
+# Past your code here.
+```
+
+
+
+Expected behavior
+---
+> A clear and concise description of what you expected to happen.
+
+
+
+Additional context
+---
+> Add any other context about the problem here.\
+> Please include the output of\
+> `julia> versioninfo()`\
+> and\
+> `pkg> st`
\ No newline at end of file
diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 0000000..730a65b
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,32 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: 'feature'
+assignees: ''
+
+---
+
+Is your feature request related to a problem? Please describe.
+---
+> A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+
+
+Describe the solution you'd like
+---
+> A clear and concise description of what you want to happen.
+
+
+
+Describe alternatives you've considered
+---
+> A clear and concise description of any alternative solutions or features you've considered.
+
+
+
+Additional context
+---
+> Add any other context or screenshots about the feature request here.
+
+
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
new file mode 100644
index 0000000..fd44682
--- /dev/null
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -0,0 +1,6 @@
+### Pull request checklist
+
+- [ ] Did you bump the project version?
+- [ ] Did you add a description to the Pull Request?
+- [ ] Did you add new tests?
+- [ ] Did you add reviewers?
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000..d4109f8
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,8 @@
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+version: 2
+updates:
+ - package-ecosystem: "github-actions"
+ directory: "/" # Location of package manifests
+ schedule:
+ interval: "weekly"
+
\ No newline at end of file
diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
new file mode 100644
index 0000000..e962c65
--- /dev/null
+++ b/.github/workflows/CI.yml
@@ -0,0 +1,81 @@
+name: CI
+
+on:
+ push:
+ branches:
+ - master
+ tags: ['*']
+ pull_request:
+ workflow_dispatch:
+
+concurrency:
+ group: ${{ github.workflow }}-${{ github.ref }}
+ cancel-in-progress: ${{ startsWith(github.ref, 'refs/pull/') }}
+
+jobs:
+ test:
+ name: Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ matrix.arch }} - ${{ github.event_name }}
+ runs-on: ${{ matrix.os }}
+ timeout-minutes: 60
+ permissions:
+ actions: write
+ contents: read
+ strategy:
+ fail-fast: false
+ matrix:
+ version:
+ - '1'
+ - '1.8'
+ - '1.9'
+ - '1.10'
+ os:
+ - ubuntu-latest
+ arch:
+ - x64
+ steps:
+ - uses: actions/checkout@v4
+ - uses: julia-actions/setup-julia@v2
+ with:
+ version: ${{ matrix.version }}
+ arch: ${{ matrix.arch }}
+ - uses: julia-actions/cache@v2
+ - uses: julia-actions/julia-buildpkg@v1
+ - uses: julia-actions/julia-runtest@v1
+ - uses: julia-actions/julia-processcoverage@v1
+ - uses: codecov/codecov-action@v4
+ env:
+ CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+ with:
+ files: lcov.info
+
+ docs:
+ permissions:
+ contents: write
+ statuses: write
+ actions: write
+ pull-requests: write
+ name: Documentation
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - uses: julia-actions/setup-julia@latest
+ - uses: julia-actions/cache@v2
+ - name: Install dependencies
+ run: julia --project=docs/ -e 'using Pkg; Pkg.develop(PackageSpec(; path = pwd())); Pkg.instantiate();'
+ - name: Build and deploy
+ env:
+ GITHUB_TOKEN: ${{ github.token }}
+ run: julia --project=docs/ docs/make.jl
+ - name: Make comment with preview link
+ if: ${{ github.event_name == 'pull_request' && github.event.action == 'opened'}}
+ uses: actions/github-script@v7
+ with:
+ script: |
+ github.rest.issues.createComment({
+ issue_number: context.issue.number,
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ body: ':blue_book: A preview of the documentation will be [here](${{env.preview_url}}) soon'
+ })
+ env:
+ preview_url: https://${{ github.repository_owner }}.github.io/${{ github.event.repository.name }}/previews/PR${{ github.event.number }}/
diff --git a/.github/workflows/CompatHelper.yml b/.github/workflows/CompatHelper.yml
new file mode 100644
index 0000000..062291a
--- /dev/null
+++ b/.github/workflows/CompatHelper.yml
@@ -0,0 +1,18 @@
+name: CompatHelper
+
+on:
+ schedule:
+ - cron: 0 0 * * *
+ workflow_dispatch:
+
+jobs:
+ CompatHelper:
+ runs-on: ubuntu-latest
+ steps:
+ - name: Pkg.add("CompatHelper")
+ run: julia -e 'using Pkg; Pkg.add("CompatHelper")'
+ - name: CompatHelper.main()
+ env:
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+ COMPATHELPER_PRIV: ${{ secrets.DOCUMENTER_KEY }}
+ run: julia -e 'using CompatHelper; CompatHelper.main()'
diff --git a/.github/workflows/TagBot.yml b/.github/workflows/TagBot.yml
new file mode 100644
index 0000000..e948a35
--- /dev/null
+++ b/.github/workflows/TagBot.yml
@@ -0,0 +1,31 @@
+name: TagBot
+on:
+ issue_comment:
+ types:
+ - created
+ workflow_dispatch:
+ inputs:
+ lookback:
+ default: 3
+permissions:
+ actions: read
+ checks: read
+ contents: write
+ deployments: read
+ issues: read
+ discussions: read
+ packages: read
+ pages: read
+ pull-requests: read
+ repository-projects: read
+ security-events: read
+ statuses: read
+jobs:
+ TagBot:
+ if: github.event_name == 'workflow_dispatch' || github.actor == 'JuliaTagBot'
+ runs-on: ubuntu-latest
+ steps:
+ - uses: JuliaRegistries/TagBot@v1
+ with:
+ token: ${{ secrets.GITHUB_TOKEN }}
+ ssh: ${{ secrets.DOCUMENTER_KEY }}
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..cc84253
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,30 @@
+# MacOS
+.DS_Store
+
+# Visual Studio Code
+.vscode
+
+# Files generated by invoking Julia with --code-coverage
+*.jl.cov
+*.jl.*.cov
+
+# Files generated by invoking Julia with --track-allocation
+*.jl.mem
+
+# System-specific files and directories generated by the BinaryProvider and BinDeps packages
+# They contain absolute paths specific to the host computer, and so should not be committed
+deps/deps.jl
+deps/build.log
+deps/downloads/
+deps/usr/
+deps/src/
+
+# Build artifacts for creating documentation generated by the Documenter package
+docs/build/
+docs/site/
+
+# File generated by Pkg, the package manager, based on a corresponding Project.toml
+# It records a fixed state of all packages used by the project. As such, it should not be
+# committed for packages, but should be committed for applications that require a static
+# environment.
+Manifest.toml
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..d5e93a9
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,3 @@
+# TimeArrays.jl Changelog
+
+The latest version of this file can be found at the master branch of the [TimeArrays.jl repository](https://github.com/bhftbootcamp/TimeArrays.jl).
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..fda1be7
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Betterhand AG
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Project.toml b/Project.toml
new file mode 100644
index 0000000..4539f0c
--- /dev/null
+++ b/Project.toml
@@ -0,0 +1,11 @@
+name = "TimeArrays"
+uuid = "058eeebf-2231-41de-8410-62311c15f51e"
+version = "1.0.0"
+
+[deps]
+Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
+Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
+
+[compat]
+Statistics = "1"
+julia = "1.8"
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..9f61bf4
--- /dev/null
+++ b/README.md
@@ -0,0 +1,216 @@
+
+
+
+
+
+# TimeArrays.jl
+
+[](https://bhftbootcamp.github.io/TimeArrays.jl/stable/)
+[](https://bhftbootcamp.github.io/TimeArrays.jl/dev/)
+[](https://github.com/bhftbootcamp/TimeArrays.jl/actions/workflows/CI.yml?query=branch%3Amaster)
+[](https://codecov.io/gh/bhftbootcamp/TimeArrays.jl)
+[](https://github.com/JuliaRegistries/General)
+
+TimeArrays simplifies working with time series data. It offers features like basic math operations, sliding window techniques, data resampling, and handling of missing values.
+
+## Installation
+To install TimeArrays, simply use the Julia package manager:
+
+```julia
+] add TimeArrays
+```
+
+## Usage
+
+In this example we perform math operations on several sets of time series.
+
+```julia
+using Dates
+using TimeArrays
+
+a = TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01"), 1.0),
+ TimeTick(DateTime("2024-01-02"), 4.0),
+ TimeTick(DateTime("2024-01-05"), 2.0),
+ TimeTick(DateTime("2024-01-07"), 5.0),
+])
+
+b = TimeArray{DateTime,Float64}([
+ (DateTime("2024-01-02"), 4.0),
+ (DateTime("2024-01-06"), 2.0),
+ (DateTime("2024-01-10"), 1.0),
+])
+
+c = TimeArray{DateTime,Float64}([
+ DateTime("2024-01-01") => 2.0,
+ DateTime("2024-01-09") => 5.0,
+ DateTime("2024-01-11") => 4.0,
+])
+
+julia> 2(a * b) + b / c
+8-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-01T00:00:00, NaN)
+ TimeTick(2024-01-02T00:00:00, 34.0)
+ ⋮
+ TimeTick(2024-01-11T00:00:00, 10.25)
+```
+
+> [!NOTE]
+> Since our implementation of arithmetic operations between elements of two TimeArray's is somewhat different from the usual work with arrays, a diagram is provided below that shows how exactly the elements of the time series are related to each other. For more information see [arithmetic section](https://bhftbootcamp.github.io/TimeArrays.jl/stable/pages/arithmetic/) in documentation.
+
+
+time: - - - 1 - - - - 2 - - - - 3 - - - - 4 - - - - 5 - - - - 6 - - - - 7 - - - >
+
+ 2.0 4.0﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉⤵ 6.0
+t_array1: ● - - - - - - - - - ● - - - - - - - - - - - - - - - - - - - ● - - - >
+ ┊ ┊ ┊ ┊
+ + [2.0 + NaN] [4.0 + 3.0] [4.0 + 5.0] [6.0 + 5.0]
+ ┊ ┊ ┊ ┊
+t_array2: X ● - - - - - - - - - ● - - - - - - - - - - - - - >
+ NaN 3.0 5.0 ﹍﹍﹍﹍﹍﹍﹍﹍﹍﹍⤴
+
+result: ● - - - - - - - - - ● - - - - - - - - - ● - - - - - - - - - ● - - - >
+ NaN 7.0 9.0 11.0
+
+
+
+TimeArrays can also deal with missing values.
+
+```julia
+using Dates
+using TimeArrays
+
+nan_values = TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-02"), 2.0),
+ TimeTick(DateTime("2024-01-04"), NaN),
+ TimeTick(DateTime("2024-01-06"), NaN),
+ TimeTick(DateTime("2024-01-08"), 8.0),
+])
+
+julia> ta_forward_fill(nan_values)
+4-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-02T00:00:00, 2.0)
+ TimeTick(2024-01-04T00:00:00, 8.0)
+ TimeTick(2024-01-06T00:00:00, 8.0)
+ TimeTick(2024-01-08T00:00:00, 8.0)
+
+julia> ta_linear_fill(nan_values)
+4-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-02T00:00:00, 2.0)
+ TimeTick(2024-01-04T00:00:00, 4.0)
+ TimeTick(2024-01-06T00:00:00, 6.0)
+ TimeTick(2024-01-08T00:00:00, 8.0)
+```
+
+Here we calculate the average price between two time series of high and low prices.
+
+```julia
+using TimeArrays
+
+julia> high_prices = ta_high_price_sample_data()
+2416-element TimeArray{DateTime, Float64}:
+ TimeTick(2023-01-01T00:00:08.998, 0.2457)
+ TimeTick(2023-01-01T00:00:43.315, 0.2458)
+ ⋮
+ TimeTick(2023-01-01T23:59:43.246, 0.25)
+
+julia> low_prices = ta_low_price_sample_data()
+2396-element TimeArray{DateTime, Float64}:
+ TimeTick(2023-01-01T00:00:08.995, 0.2456)
+ TimeTick(2023-01-01T00:00:43.319, 0.2457)
+ ⋮
+ TimeTick(2023-01-01T23:59:43.252, 0.2499)
+
+julia> (low_prices + high_prices) / 2
+3930-element TimeArray{DateTime, Float64}:
+ TimeTick(2023-01-01T00:00:08.995, NaN)
+ TimeTick(2023-01-01T00:00:08.998, 0.24565)
+ ⋮
+ TimeTick(2023-01-01T23:59:43.252, 0.24995)
+```
+
+
+
+
+Visualized with [LightweightCharts.jl](https://github.com/bhftbootcamp/LightweightCharts.jl).
+
+
+
+Visualized with [LightweightCharts.jl](https://github.com/bhftbootcamp/LightweightCharts.jl).
+
+
+
+Visualized with [LightweightCharts.jl](https://github.com/bhftbootcamp/LightweightCharts.jl).
+
+
+ time: - - - 1 - - - - 2 - - - - 3 - - - - 4 - - - - 5 - - - - 6 - - - - 7 - - - >
+
+ 2.0 4.0﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉⤵ 6.0
+ t_array1: ● - - - - - - - - - ● - - - - - - - - - - - - - - - - - - - ● - - - >
+ ┊ ┊ ┊ ┊
+ + [2.0 + NaN] [4.0 + 3.0] [4.0 + 5.0] [6.0 + 5.0]
+ ┊ ┊ ┊ ┊
+ t_array2: X ● - - - - - - - - - ● - - - - - - - - - - - - - >
+ NaN 3.0 5.0 ﹍﹍﹍﹍﹍﹍﹍﹍﹍﹍﹍﹍﹍﹍﹍﹍﹍⤴
+
+ result: ● - - - - - - - - - ● - - - - - - - - - ● - - - - - - - - - ● - - - >
+ NaN 7.0 9.0 11.0
+
+
+```
+
+TimeArrays can also deal with missing values.
+
+```julia
+using Dates
+using TimeArrays
+
+nan_values = TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-02"), 2.0),
+ TimeTick(DateTime("2024-01-04"), NaN),
+ TimeTick(DateTime("2024-01-06"), NaN),
+ TimeTick(DateTime("2024-01-08"), 8.0),
+])
+
+julia> ta_forward_fill(nan_values)
+4-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-02T00:00:00, 2.0)
+ TimeTick(2024-01-04T00:00:00, 8.0)
+ TimeTick(2024-01-06T00:00:00, 8.0)
+ TimeTick(2024-01-08T00:00:00, 8.0)
+
+julia> ta_linear_fill(nan_values)
+4-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-02T00:00:00, 2.0)
+ TimeTick(2024-01-04T00:00:00, 4.0)
+ TimeTick(2024-01-06T00:00:00, 6.0)
+ TimeTick(2024-01-08T00:00:00, 8.0)
+```
+
+Here we calculate the average price between two time series of high and low prices.
+
+```julia
+using TimeArrays
+
+julia> high_prices = ta_high_price_sample_data()
+2416-element TimeArray{DateTime, Float64}:
+ TimeTick(2023-01-01T00:00:08.998, 0.2457)
+ TimeTick(2023-01-01T00:00:43.315, 0.2458)
+ ⋮
+ TimeTick(2023-01-01T23:59:43.246, 0.25)
+
+julia> low_prices = ta_low_price_sample_data()
+2396-element TimeArray{DateTime, Float64}:
+ TimeTick(2023-01-01T00:00:08.995, 0.2456)
+ TimeTick(2023-01-01T00:00:43.319, 0.2457)
+ ⋮
+ TimeTick(2023-01-01T23:59:43.252, 0.2499)
+
+julia> (low_prices + high_prices) / 2
+3930-element TimeArray{DateTime, Float64}:
+ TimeTick(2023-01-01T00:00:08.995, NaN)
+ TimeTick(2023-01-01T00:00:08.998, 0.24565)
+ ⋮
+ TimeTick(2023-01-01T23:59:43.252, 0.24995)
+```
+
+```@raw html
+
+
+
+
+ time: - - - 1 - - - - 2 - - - - 3 - - - - 4 - - - - 5 - - - - 6 - - - - 7 - - - >
+
+ 2.0 4.0 6.0
+ t_array1: ● - - - - - - - - - ● - - - - - - - - - - - - - - - - - - - ● - - - >
+
+ t_array2: ● - - - - - - - - - ● - - - - - - - - - - - - - >
+ 3.0 5.0
+
+
+```
+
+Let's apply the addition operation to them.
+
+```julia-repl
+julia> t_array1 + t_array2
+4-element TimeArray{Int64, Float64}:
+ TimeTick(1, NaN)
+ TimeTick(3, 7.0)
+ TimeTick(5, 9.0)
+ TimeTick(7, 11.0)
+```
+
+The expected behavior will be as follows:
+- For the first timestamp `1` from the `t_array1` there is no time value from the `t_array2` one, so the resulting value of this timestamp will be `2.0 + NaN = NaN`.
+- Then for timestamp `3` in both arrays there are values (`4.0` and `3.0`), so as a result of addition we get `7.0`.
+- At timestamp `5` in the `t_array2` a new value appears `5.0` for which in the `t_array1` the current value will be `4.0`. As a result we get `9.0`.
+- Finally, at timestamp `7` happens the opposite of the previous case.
+
+```@raw html
+
+
+ time: - - - 1 - - - - 2 - - - - 3 - - - - 4 - - - - 5 - - - - 6 - - - - 7 - - - >
+
+ 2.0 4.0﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉⤵ 6.0
+ t_array1: ● - - - - - - - - - ● - - - - - - - - - - - - - - - - - - - ● - - - >
+ ┊ ┊ ┊ ┊
+ + [2.0 + NaN] [4.0 + 3.0] [4.0 + 5.0] [6.0 + 5.0]
+ ┊ ┊ ┊ ┊
+ t_array2: X ● - - - - - - - - - ● - - - - - - - - - - - - - >
+ NaN 3.0 5.0 ﹍﹍﹍﹍﹍﹍﹍﹍﹍﹍﹍﹍﹍﹍﹍﹍﹍⤴
+
+ result: ● - - - - - - - - - ● - - - - - - - - - ● - - - - - - - - - ● - - - >
+ NaN 7.0 9.0 11.0
+
+
+```
+
+Supported mathematical operations on time series:
+- between two TimeArrays:
+ - `+`: addition
+ - `-`: subtraction
+ - `*`: multiplication
+ - `/`: division
+- between TimeArray and other values
+ - `+`: addition
+ - `-`: subtraction
+ - `*`: multiplication
+ - `/`: division
+ - `^`: exponentiation
+
+For more flexible arithmetic work on TimeArrays, you can use functions [`ta_mergewith`](@ref) and [`ta_merge`](@ref).
+
+## API
+
+```@docs
+ta_mergewith
+ta_merge
+```
diff --git a/docs/src/pages/array.md b/docs/src/pages/array.md
new file mode 100644
index 0000000..00ddd54
--- /dev/null
+++ b/docs/src/pages/array.md
@@ -0,0 +1,8 @@
+# Replace & Fill
+
+```@docs
+replace
+ta_backward_fill
+ta_forward_fill
+ta_linear_fill
+```
diff --git a/docs/src/pages/custom_types.md b/docs/src/pages/custom_types.md
new file mode 100644
index 0000000..01416af
--- /dev/null
+++ b/docs/src/pages/custom_types.md
@@ -0,0 +1,168 @@
+# Custom types
+
+Not only Numbers, but also custom types can be used as time series values.
+However, it is worth noting that for the full correct use of custom types as `TimeArrays` values, it is necessary to define some methods, which will be listed below.
+
+## Required metods
+
+To work with the main functions of the package, you need to define the following methods:
+
+| Required methods | Description |
+|:-----------------|:------------|
+| `Base.zero(::Type{T})` | Returns an object of a custom type `T` that is treated as a zero value. |
+| `Base.isnan(::Type{T})` | Checks whether an object of type `T` is considered `NaN` |
+| `TimeArray.ta_nan(::Type{T})` | Returns an object of a custom type `T` that is treated as a `NaN` value. |
+
+## Optional methods
+
+The following methods are useful to define for a custom type:
+
+| Optional methods | Description |
+|:-----------------|:------------|
+| `Base.isless(x::T, y::T)` | See [`isless`](https://docs.julialang.org/en/v1/base/base/#Base.isless). |
+| `Base.isequal(x::T, y::T)` | See [`isequal`](https://docs.julialang.org/en/v1/base/base/#Base.isequal). |
+| `Base.:(==)(x::T, y::T)` | See [`==`](https://docs.julialang.org/en/v1/base/math/#Base.:==). |
+| `Base.:(+)(x::T, y::T)` | Addition between custom types. |
+| `Base.:(-)(x::T, y::T)` | Subtraction between custom types. |
+| `Base.:(*)(x::T, y::T)` | Multiplication between custom types. |
+| `Base.:(/)(x::T, y::T)` | Division between custom types. |
+
+## Example
+
+Let's look at the necessary method overloads for our custom type that describes a candle:
+
+```julia
+struct OHLC
+ o::Float64
+ h::Float64
+ l::Float64
+ c::Float64
+end
+```
+
+Next we will define the necessary methods:
+
+```julia
+Base.zero(::Type{OHLC}) = OHLC(0.0, 0.0, 0.0, 0.0)
+Base.isnan(x::OHLC) = isnan(x.o) && isnan(x.h) && isnan(x.l) && isnan(x.c)
+TimeArrays.ta_nan(::Type{OHLC}) = OHLC(NaN, NaN, NaN, NaN)
+
+Base.isless(x::OHLC, y::OHLC) = isless(x.h, y.h)
+
+function Base.isequal(x::OHLC, y::OHLC)
+ return all([
+ isequal(x.o, y.o),
+ isequal(x.h, y.h),
+ isequal(x.l, y.l),
+ isequal(x.c, y.c),
+ ])
+end
+
+function Base.:(==)(x::OHLC, y::OHLC)
+ return all([
+ x.o == y.o,
+ x.h == y.h,
+ x.l == y.l,
+ x.c == y.c,
+ ])
+end
+
+Base.:+(left::OHLC, right::OHLC) = OHLC(left.o + right.o, left.h + right.h, left.l + right.l, left.c + right.c)
+Base.:-(left::OHLC, right::OHLC) = OHLC(left.o - right.o, left.h - right.h, left.l - right.l, left.c - right.c)
+Base.:*(left::OHLC, right::OHLC) = OHLC(left.o * right.o, left.h * right.h, left.l * right.l, left.c * right.c)
+Base.:*(left::Number, right::OHLC) = OHLC(left * right.o, left * right.h, left * right.l, left * right.c)
+Base.:*(left::OHLC, right::Number) = right * left
+Base.:/(left::Number, right::OHLC) = OHLC(left / right.o, left / right.h, left / right.l, left / right.c)
+Base.:/(left::OHLC, right::Number) = OHLC(left.o / right, left.h / right, left.l / right, left.c / right)
+```
+
+Now we can use `OHLC` as the time series value and use all the available functions:
+
+```julia-repl
+julia> t_left = TimeArray([
+ TimeTick(DateTime("2024-1-1T1"), OHLC(1, 2, 3, 4)),
+ TimeTick(DateTime("2024-1-1T2"), OHLC(1, 2, 3, 4)),
+ TimeTick(DateTime("2024-1-1T3"), OHLC(1, 2, 3, 4)),
+ ]);
+
+julia> t_right = TimeArray([
+ TimeTick(DateTime("2024-1-1T2"), OHLC(1, 2, 3, 4)),
+ TimeTick(DateTime("2024-1-1T3"), OHLC(1, 2, 3, 4)),
+ TimeTick(DateTime("2024-1-1T4"), OHLC(1, 2, 3, 4)),
+ ]);
+
+julia> t_left + t_right
+4-element TimeArray{DateTime, OHLC}:
+ TimeTick(2024-01-01T01:00:00, OHLC(NaN, NaN, NaN, NaN))
+ TimeTick(2024-01-01T02:00:00, OHLC(2.0, 4.0, 6.0, 8.0))
+ TimeTick(2024-01-01T03:00:00, OHLC(2.0, 4.0, 6.0, 8.0))
+ TimeTick(2024-01-01T04:00:00, OHLC(2.0, 4.0, 6.0, 8.0))
+```
+
+```julia-repl
+julia> t_nan = TimeArray([
+ TimeTick(DateTime("2024-01-02"), OHLC(1, 1, 1, 1)),
+ TimeTick(DateTime("2024-01-03"), OHLC(NaN, NaN, NaN, NaN)),
+ TimeTick(DateTime("2024-01-04"), OHLC(NaN, NaN, NaN, NaN)),
+ TimeTick(DateTime("2024-01-05"), OHLC(10, 10, 10, 10)),
+ ]);
+
+julia> ta_forward_fill(t_nan)
+4-element TimeArray{DateTime, OHLC}:
+ TimeTick(2024-01-02T00:00:00, OHLC(1.0, 1.0, 1.0, 1.0))
+ TimeTick(2024-01-03T00:00:00, OHLC(10.0, 10.0, 10.0, 10.0))
+ TimeTick(2024-01-04T00:00:00, OHLC(10.0, 10.0, 10.0, 10.0))
+ TimeTick(2024-01-05T00:00:00, OHLC(10.0, 10.0, 10.0, 10.0))
+
+julia> ta_backward_fill(t_nan)
+4-element TimeArray{DateTime, OHLC}:
+ TimeTick(2024-01-02T00:00:00, OHLC(1.0, 1.0, 1.0, 1.0))
+ TimeTick(2024-01-03T00:00:00, OHLC(1.0, 1.0, 1.0, 1.0))
+ TimeTick(2024-01-04T00:00:00, OHLC(1.0, 1.0, 1.0, 1.0))
+ TimeTick(2024-01-05T00:00:00, OHLC(10.0, 10.0, 10.0, 10.0))
+
+julia> ta_linear_fill(t_nan)
+4-element TimeArray{DateTime, OHLC}:
+ TimeTick(2024-01-02T00:00:00, OHLC(1.0, 1.0, 1.0, 1.0))
+ TimeTick(2024-01-03T00:00:00, OHLC(4.0, 4.0, 4.0, 4.0))
+ TimeTick(2024-01-04T00:00:00, OHLC(7.0, 7.0, 7.0, 7.0))
+ TimeTick(2024-01-05T00:00:00, OHLC(10.0, 10.0, 10.0, 10.0))
+```
+
+```julia-repl
+julia> t_ohlc = TimeArray([
+ TimeTick(DateTime("2024-1-01"), OHLC(1, 2, 3, 4)),
+ TimeTick(DateTime("2024-1-02"), OHLC(1, 2, 3, 4)),
+ TimeTick(DateTime("2024-1-03"), OHLC(1, 2, 3, 4)),
+ TimeTick(DateTime("2024-1-04"), OHLC(1, 2, 3, 4)),
+ ]);
+
+julia> ta_lag(t_ohlc, 2)
+4-element TimeArray{DateTime, OHLC}:
+ TimeTick(2024-01-01T00:00:00, OHLC(NaN, NaN, NaN, NaN))
+ TimeTick(2024-01-02T00:00:00, OHLC(NaN, NaN, NaN, NaN))
+ TimeTick(2024-01-03T00:00:00, OHLC(1.0, 2.0, 3.0, 4.0))
+ TimeTick(2024-01-04T00:00:00, OHLC(1.0, 2.0, 3.0, 4.0))
+
+julia> ta_rolling(sum, t_ohlc, 3)
+4-element TimeArray{DateTime, OHLC}:
+ TimeTick(2024-01-01T00:00:00, OHLC(NaN, NaN, NaN, NaN))
+ TimeTick(2024-01-02T00:00:00, OHLC(NaN, NaN, NaN, NaN))
+ TimeTick(2024-01-03T00:00:00, OHLC(3.0, 6.0, 9.0, 12.0))
+ TimeTick(2024-01-04T00:00:00, OHLC(3.0, 6.0, 9.0, 12.0))
+
+julia> ta_resample(x -> isempty(x) ? ta_nan(x) : sum(x), t_ohlc, Day(2))
+2-element TimeArray{DateTime, OHLC}:
+ TimeTick(2024-01-01T00:00:00, OHLC(2.0, 4.0, 6.0, 8.0))
+ TimeTick(2024-01-03T00:00:00, OHLC(2.0, 4.0, 6.0, 8.0))
+
+julia> ta_resample(sum, t_ohlc, Hour(12))
+7-element TimeArray{DateTime, OHLC}:
+ TimeTick(2024-01-01T00:00:00, OHLC(1.0, 2.0, 3.0, 4.0))
+ TimeTick(2024-01-01T12:00:00, OHLC(0.0, 0.0, 0.0, 0.0))
+ TimeTick(2024-01-02T00:00:00, OHLC(1.0, 2.0, 3.0, 4.0))
+ TimeTick(2024-01-02T12:00:00, OHLC(0.0, 0.0, 0.0, 0.0))
+ TimeTick(2024-01-03T00:00:00, OHLC(1.0, 2.0, 3.0, 4.0))
+ TimeTick(2024-01-03T12:00:00, OHLC(0.0, 0.0, 0.0, 0.0))
+ TimeTick(2024-01-04T00:00:00, OHLC(1.0, 2.0, 3.0, 4.0))
+```
diff --git a/docs/src/pages/interface.md b/docs/src/pages/interface.md
new file mode 100644
index 0000000..36e0ea8
--- /dev/null
+++ b/docs/src/pages/interface.md
@@ -0,0 +1,22 @@
+# Types
+
+```@docs
+TimeArrays.TimeLike
+TimeArrays.PeriodLike
+```
+
+## TimeTick
+
+```@docs
+TimeArrays.AbstractTick
+TimeTick
+TimeTick(::Tuple)
+```
+
+## TimeArray
+
+```@docs
+TimeArrays.AbstractTimeArray
+TimeArray
+TimeArray(::Vector)
+```
diff --git a/docs/src/pages/resample.md b/docs/src/pages/resample.md
new file mode 100644
index 0000000..e5564bc
--- /dev/null
+++ b/docs/src/pages/resample.md
@@ -0,0 +1,176 @@
+# [Resample](@id resample)
+
+Let's assume that you have some time series with arbitrary timestamps and you need to bring the values to a new aligned grid with a fixed period in time.
+For example, like this:
+
+```@raw html
+
+
+ value: 1.0 2.0 3.0 4.0 5.0 6.0 7.0
+ grid: - - X - - X - - - - - X - - - - - - - - X - - X - - X - - X - -
+ time: 1 2 4 7 8 9 10
+
+
+```
+
+To do this you will need a resampling method, which we will now look at in more detail.
+The resampling method can be broken down into four steps:
+- selecting the origin of the time grid.
+- dividing the new grid into sub-intervals.
+- defining the parameters of these sub-intervals, such as the closed side and the label side.
+- Aggregation of values falling into a new subinterval.
+
+## Origin of the new time grid
+
+First you need to select the `origin` of the new grid:
+- `ORIGIN_OF_WINDOW (default)`: Origin of coordinates for the corresponding time type (Beginning of the year for dates, zero for numbers).
+- `START_OF_WINDOW`: The first timestamp in the current time series.
+- `END_OF_WINDOW`: The last timestamp in the current time series.
+
+```@raw html
+
+
+ value: 1.0 2.0 3.0 4.0 5.0 6.0 7.0
+ grid: X - - X - - X - - - - - X - - - - - - - - X - - X - - X - - X - -
+ time: 0 1 2 4 7 8 9 10
+ ^ ^ ^
+ | | |
+ | START_OF_WINDOW END_OF_WINDOW
+ ORIGIN_OF_WINDOW (default)
+
+
+```
+
+## Period of the new time grid
+
+Then, relative to the selected origin, a grid with a step of the specified `period` will be created
+
+```@raw html
+
+
+ value: 1.0 2.0 3.0 4.0 5.0 6.0 7.0
+ grid: X - - X - - X - - - - - X - - - - - - - - X - - X - - X - - X - -
+ time: 0 1 2 4 7 8 9 10
+
+
+
+
+
+ preiod = 2: | - - - - - | - - - - - | - - - - - | - - - - - | - - - - - | - -
+ 0 2 4 6 8 10
+
+ preiod = 3: | - - - - - - - - | - - - - - - - - | - - - - - - - - | - - - - -
+ 0 3 6 9
+ ^
+ |
+ ORIGIN_OF_WINDOW (default)
+
+
+
+
+
+ preiod = 2: - - - | - - - - - | - - - - - | - - - - - | - - - - - | - - - - -
+ 1 3 5 7 9
+
+ preiod = 3: - - - | - - - - - - - - | - - - - - - - - | - - - - - - - - | - -
+ 1 4 7 10
+ ^
+ |
+ START_OF_WINDOW
+
+
+
+
+
+ preiod = 2: | - - - - - | - - - - - | - - - - - | - - - - - | - - - - - | - -
+ 0 2 4 6 8 10
+
+ preiod = 3: - - - | - - - - - - - - | - - - - - - - - | - - - - - - - - | - -
+ 1 4 7 10
+ ^
+ |
+ END_OF_WINDOW
+
+
+```
+
+## Parameters of sub-intervals
+
+Finally, it only remains to determine which side of the subintervals will be closed, as well as on which side the aggregation of the values falling within the interval will occur.
+The following example shows how parameters `CLOSED_LEFT` and `CLOSED_RIGHT`, as well as `LABEL_LEFT` and `LABEL_RIGHT`, determine the behavior of the subintervals.
+
+An example of the obtained sub-intervals with parameters `origin = ORIGIN_OF_WINDOW` and `period = 2`:
+
+```@raw html
+
+
+ value: 1.0 2.0 3.0 1.0 2.0 3.0
+ grid: - - X - - - - X - - - - X - - ➤ - - | - - - - X - - - - | - - - - X - - - - | - -
+ time: 1 2 3 0 2 4
+
+
+```
+
+Possible options for decomposing values into new sub-intervals for subsequent aggregation:
+
+```@raw html
+
+
+ CLOSED_LEFT (default)
+ CLOSED_RIGHT
+
+
+ LABEL_LEFT
+
+
+
+ value: 1.0 2.0 3.0
+ grid: [ - - - - - )[ - - - - - )
+ time: ⤷ 0 ⤷ 2
+
+
+
+
+
+
+ value: 1.0 2.0 3.0
+ grid: ( - - - - - ]( - - - - - ]
+ time: ⤷ 0 ⤷ 2
+
+
+
+
+
+ LABEL_RIGHT
+
+
+
+ value: 1.0 2.0 3.0
+ grid: [ - - - - - )[ - - - - - )
+ time: 2 ⤶ 4 ⤶
+
+
+
+
+
+
+ value: 1.0 2.0 3.0
+ grid: ( - - - - - ]( - - - - - ]
+ time: 2 ⤶ 4 ⤶
+
+
+
+
+
+```
+
+## Values aggregation
+
+Finally, the old values that fall into the new subinterval can be aggregated by applying some function, such as `sum`, `maximum`, `minimum`, `mean`, `median`, etc.
+
+## API
+
+```@docs
+ta_resample
+```
diff --git a/docs/src/pages/rolling.md b/docs/src/pages/rolling.md
new file mode 100644
index 0000000..4770327
--- /dev/null
+++ b/docs/src/pages/rolling.md
@@ -0,0 +1,8 @@
+# Rolling window
+
+```@docs
+ta_rolling
+ta_sma
+ta_lag
+ta_lead
+```
diff --git a/src/TimeArrays.jl b/src/TimeArrays.jl
new file mode 100644
index 0000000..b554476
--- /dev/null
+++ b/src/TimeArrays.jl
@@ -0,0 +1,74 @@
+module TimeArrays
+
+export TimeArray,
+ TimeTick,
+ ta_timestamp,
+ ta_value,
+ ta_values
+
+export ta_mergewith,
+ ta_merge
+
+export ta_backward_fill,
+ ta_forward_fill,
+ ta_linear_fill
+
+export ta_rolling,
+ ta_sma,
+ ta_lag,
+ ta_lead
+
+export ta_resample
+
+export ta_nan
+
+export START_OF_WINDOW,
+ END_OF_WINDOW,
+ ORIGIN_OF_WINDOW
+
+export CLOSED_LEFT,
+ CLOSED_RIGHT
+
+export LABEL_LEFT,
+ LABEL_RIGHT
+
+using Dates
+using Statistics
+
+"""
+ TimeLike <: Union{Dates.TimeType,Real}
+
+`TimeArray`'s timestamp type that accepts `Dates.TimeType` and `Real`.
+"""
+const TimeLike = Union{Real,TimeType}
+
+"""
+ PeriodLike <: Union{Dates.Period,Real}
+
+`TimeArray`'s period type that accepts `Dates.Period` and `Real`.
+"""
+const PeriodLike = Union{Real,Period}
+
+ta_nan(::AbstractVector{T}) where {T} = ta_nan(T)
+ta_nan(::Type{T}) where {T<:Complex} = Complex(NaN, NaN)
+ta_nan(::Type{T}) where {T<:Number} = NaN
+
+promote_nan(::Type{T}) where {T} = promote_type(T, typeof(ta_nan(T)))
+
+function return_type(f::Function, ::Type{V1}, ::Type{V2}) where {V1,V2}
+ return typeof(f(zero(V1), zero(V2)))
+end
+
+function return_type(f::Function, ::Type{V}) where {V}
+ return typeof(f([zero(V)]))
+end
+
+include("interface.jl")
+include("array.jl")
+include("arithmetic.jl")
+include("reduce.jl")
+include("rolling.jl")
+include("resample.jl")
+include("sample_data.jl")
+
+end
diff --git a/src/arithmetic.jl b/src/arithmetic.jl
new file mode 100644
index 0000000..cf1d8d9
--- /dev/null
+++ b/src/arithmetic.jl
@@ -0,0 +1,227 @@
+# arithmetic
+
+"""
+ ta_mergewith(f, l_array::TimeArray, r_array::TimeArray; kw...) -> TimeArray
+
+Creates a new TimeArray object by applying a binary function `f` on elements of `left` and `right` TimeArrays.
+TimeArrays uses the following rules to establish corresponding elements:
+- An element of the first array is matched to the nearest smaller or equal element of the second array.
+- If there is no such element in the second array, then the resulting element will be `NaN`.
+
+## Keyword arguments
+- `l_merge::Bool = true`: Use `left` timestamps in resulting TimeArray.
+- `r_merge::Bool = true`: Use `right` timestamps in resulting TimeArray.
+- `padding::Bool = true`: Preserve first timestamps with `NaN` values.
+
+## Examples
+
+```jldoctest
+julia> using Dates
+
+julia> t_left = TimeArray([
+ TimeTick(DateTime("2024-01-02"), 0.2),
+ TimeTick(DateTime("2024-01-05"), 0.5),
+ ]);
+
+julia> t_right = TimeArray([
+ TimeTick(DateTime("2024-01-01"), 1.0),
+ TimeTick(DateTime("2024-01-05"), 5.0),
+ TimeTick(DateTime("2024-01-07"), 7.0),
+ ]);
+
+julia> ta_mergewith(+, t_left, t_right)
+4-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-01T00:00:00, NaN)
+ TimeTick(2024-01-02T00:00:00, 1.2)
+ TimeTick(2024-01-05T00:00:00, 5.5)
+ TimeTick(2024-01-07T00:00:00, 7.5)
+
+julia> ta_mergewith(-, t_left, t_right; l_merge = false)
+3-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-01T00:00:00, NaN)
+ TimeTick(2024-01-05T00:00:00, -4.5)
+ TimeTick(2024-01-07T00:00:00, -6.5)
+
+julia> ta_mergewith(*, t_left, t_right, r_merge = false, padding = false)
+2-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-02T00:00:00, 0.2)
+ TimeTick(2024-01-05T00:00:00, 2.5)
+```
+"""
+function ta_mergewith(
+ f::Function,
+ l_array::TimeArray{T1,V1},
+ r_array::TimeArray{T2,V2};
+ l_merge::Bool = true,
+ r_merge::Bool = true,
+ padding::Bool = true,
+)::TimeArray where {T1,V1,T2,V2}
+ T = promote_type(T1, T2)
+
+ V = if padding && ta_timestamp(l_array[1]) != ta_timestamp(r_array[1])
+ promote_nan(return_type(f, V1, V2))
+ else
+ return_type(f, V1, V2)
+ end
+
+ if !l_merge && !r_merge || isempty(l_array) || isempty(r_array)
+ return TimeArray{T,V}()
+ end
+
+ n_index = 0
+ n_length = length(l_array) + length(r_array)
+ new_ticks = Vector{TimeTick{T,V}}(undef, n_length)
+
+ l_index, r_index = length(l_array), length(r_array)
+ l_timestamp, l_value = l_array[l_index]
+ r_timestamp, r_value = r_array[r_index]
+
+ while n_index <= n_length
+ n_tick = if l_index < 1 && r_index < 1
+ break
+ elseif l_index < 1
+ if r_merge && padding
+ r_timestamp, r_value = r_array[r_index]
+ r_index -= 1
+ TimeTick{T,V}(r_timestamp, ta_nan(V))
+ else
+ break
+ end
+ elseif r_index < 1
+ if l_merge && padding
+ l_timestamp, l_value = l_array[l_index]
+ l_index -= 1
+ TimeTick{T,V}(l_timestamp, ta_nan(V))
+ else
+ break
+ end
+ else
+ r_timestamp, r_value = r_array[r_index]
+ l_timestamp, l_value = l_array[l_index]
+ n_value = f(l_value, r_value)
+ if r_timestamp > l_timestamp
+ r_index -= 1
+ if r_merge
+ TimeTick{T,V}(r_timestamp, n_value)
+ else
+ continue
+ end
+ elseif l_timestamp > r_timestamp
+ l_index -= 1
+ if l_merge
+ TimeTick{T,V}(l_timestamp, n_value)
+ else
+ continue
+ end
+ elseif l_timestamp == r_timestamp
+ l_index -= 1
+ r_index -= 1
+ TimeTick{T,V}(l_timestamp, n_value)
+ end
+ end
+
+ new_ticks[n_index += 1] = n_tick
+ end
+
+ return TimeArray{T,V}(reverse!(resize!(new_ticks, n_index)))
+end
+
+function Base.:+(l_array::TimeArray, r_array::TimeArray)
+ return ta_mergewith(+, l_array, r_array)
+end
+
+function Base.:-(l_array::TimeArray, r_array::TimeArray)
+ return ta_mergewith(-, l_array, r_array)
+end
+
+function Base.:*(l_array::TimeArray, r_array::TimeArray)
+ return ta_mergewith(*, l_array, r_array)
+end
+
+function Base.:/(l_array::TimeArray, r_array::TimeArray)
+ return ta_mergewith(/, l_array, r_array)
+end
+
+"""
+ ta_merge(f::Function, t_array::TimeArray, value) -> TimeArray
+ ta_merge(f::Function, value, t_array::TimeArray) -> TimeArray
+
+Creates a new TimeArray by applying a binary function `f` with `value` on elements of `t_array`.
+
+## Examples
+```jldoctest
+julia> using Dates
+
+julia> t_array = TimeArray([
+ TimeTick(DateTime("2024-01-03"), 2.0),
+ TimeTick(DateTime("2024-01-04"), 3.0),
+ TimeTick(DateTime("2024-01-08"), 6.0),
+ ]);
+
+julia> ta_merge(+, t_array, 2.0)
+3-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-03T00:00:00, 4.0)
+ TimeTick(2024-01-04T00:00:00, 5.0)
+ TimeTick(2024-01-08T00:00:00, 8.0)
+
+julia> ta_merge(/, 18.0, t_array)
+3-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-03T00:00:00, 9.0)
+ TimeTick(2024-01-04T00:00:00, 6.0)
+ TimeTick(2024-01-08T00:00:00, 3.0)
+```
+"""
+function ta_merge end
+
+function ta_merge(f::Function, t_array::TimeArray{T,V1}, value::V2) where {T,V1,V2}
+ V3 = promote_type(V1, V2)
+ new_ticks = Vector{TimeTick{T,V3}}(undef, length(t_array))
+ for i in eachindex(new_ticks)
+ new_ticks[i] = TimeTick{T,V3}(ta_timestamp(t_array[i]), f(ta_value(t_array[i]), value))
+ end
+ return TimeArray{T,V3}(new_ticks, length(new_ticks))
+end
+
+function ta_merge(f::Function, value::V2, t_array::TimeArray{T,V1}) where {T,V1,V2}
+ return ta_merge((x, y) -> f(y, x), t_array, value)
+end
+
+function Base.:+(l_array::TimeArray, r_array::Number)
+ return ta_merge(+, l_array, r_array)
+end
+
+function Base.:+(l_array::Number, r_array::TimeArray)
+ return ta_merge(+, l_array, r_array)
+end
+
+function Base.:-(l_array::TimeArray, r_array::Number)
+ return ta_merge(-, l_array, r_array)
+end
+
+function Base.:-(l_array::Number, r_array::TimeArray)
+ return ta_merge(-, l_array, r_array)
+end
+
+function Base.:*(l_array::TimeArray, r_array::Number)
+ return ta_merge(*, l_array, r_array)
+end
+
+function Base.:*(l_array::Number, r_array::TimeArray)
+ return ta_merge(*, l_array, r_array)
+end
+
+function Base.:/(l_array::TimeArray, r_array::Number)
+ return ta_merge(/, l_array, r_array)
+end
+
+function Base.:/(l_array::Number, r_array::TimeArray)
+ return ta_merge(/, l_array, r_array)
+end
+
+function Base.:^(l_array::TimeArray, r_array::Number)
+ return ta_merge(^, l_array, r_array)
+end
+
+function Base.:-(t_array::TimeArray)
+ return -1 * t_array
+end
diff --git a/src/array.jl b/src/array.jl
new file mode 100644
index 0000000..f9021c4
--- /dev/null
+++ b/src/array.jl
@@ -0,0 +1,196 @@
+# array
+
+"""
+ replace(t_array::TimeArray, old_new::Pair...; [, count]) -> TimeArray
+
+Return a copy of `t_array` which has all values of `old` replaced by `new` in accordance with `old_new` pair.
+If `count` is specified, then replace at most `count` occurrences in total.
+
+## Examples
+
+```jldoctest
+julia> using Dates
+
+julia> t_array = TimeArray([
+ TimeTick(DateTime("2024-01-01"), 1.0),
+ TimeTick(DateTime("2024-01-02"), 2.0),
+ TimeTick(DateTime("2024-01-03"), 3.0),
+ ]);
+
+julia> replace(t_array, 1.0 => 10.0, 2.0 => -2.0)
+3-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-01T00:00:00, 10.0)
+ TimeTick(2024-01-02T00:00:00, -2.0)
+ TimeTick(2024-01-03T00:00:00, 3.0)
+```
+"""
+function Base.replace(t_array::TimeArray, old_new::Pair...; count = length(t_array))
+ values = ta_values(t_array)
+ timestamps = map(ta_timestamp, values)
+ timevalues = map(ta_value, values)
+ return TimeArray(timestamps, replace(timevalues, old_new...; count))
+end
+
+"""
+ replace(f::Function, t_array::TimeArray; [, count]) -> TimeArray
+
+Return a new array where each element is the result of function `f` applied to elements of `t_array`.
+If `count` is specified, then replace at most `count` occurrences in total.
+
+## Examples
+
+```jldoctest
+julia> using Dates
+
+julia> t_array = TimeArray([
+ TimeTick(DateTime("2024-01-01"), 1.0),
+ TimeTick(DateTime("2024-01-02"), 2.0),
+ TimeTick(DateTime("2024-01-03"), 3.0),
+ ]);
+
+julia> replace(x -> isodd(x) ? -x : x, t_array)
+3-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-01T00:00:00, -1.0)
+ TimeTick(2024-01-02T00:00:00, 2.0)
+ TimeTick(2024-01-03T00:00:00, -3.0)
+```
+"""
+function Base.replace(f::Function, t_array::TimeArray; count = length(t_array))
+ values = ta_values(t_array)
+ timestamps = map(ta_timestamp, values)
+ timevalues = map(ta_value, values)
+ return TimeArray(timestamps, replace(f, timevalues; count))
+end
+
+"""
+ ta_backward_fill([, pattern::Function], t_array::TimeArray) -> TimeArray
+
+Return an array where elements that match `pattern` are replaced by nearest previous non-pattern value in `t_array`.
+By default `pattern` is `isnan` function.
+
+## Examples
+
+```jldoctest
+julia> using Dates
+
+julia> t_array = TimeArray([
+ TimeTick(DateTime("2024-01-03"), 1.0),
+ TimeTick(DateTime("2024-01-07"), NaN),
+ TimeTick(DateTime("2024-01-09"), NaN),
+ TimeTick(DateTime("2024-01-10"), 5.0),
+ ]);
+
+julia> ta_backward_fill(t_array)
+4-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-03T00:00:00, 1.0)
+ TimeTick(2024-01-07T00:00:00, 1.0)
+ TimeTick(2024-01-09T00:00:00, 1.0)
+ TimeTick(2024-01-10T00:00:00, 5.0)
+```
+"""
+function ta_backward_fill(pattern::Function, t_array::TimeArray{T,V}) where {T,V}
+ new_ticks = Vector{TimeTick{T,V}}(undef, length(t_array))
+ for i in eachindex(t_array)
+ prev = findprev(x -> !pattern(x), t_array, i)
+ new_ticks[i] = TimeTick{T,V}(
+ ta_timestamp(t_array[i]),
+ ta_value(t_array[isnothing(prev) ? i : prev]),
+ )
+ end
+ return TimeArray{T,V}(new_ticks)
+end
+
+function ta_backward_fill(t_array::TimeArray)
+ return ta_backward_fill(isnan, t_array)
+end
+
+"""
+ ta_forward_fill([, pattern::Function], t_array::TimeArray) -> TimeArray
+
+Return an array where elements that match `pattern` are replaced by nearest next non-pattern value in `t_array`.
+By default `pattern` is `isnan` function.
+
+## Examples
+
+```jldoctest
+julia> using Dates
+
+julia> t_array = TimeArray([
+ TimeTick(DateTime("2024-01-01"), 2.0),
+ TimeTick(DateTime("2024-01-03"), NaN),
+ TimeTick(DateTime("2024-01-04"), NaN),
+ TimeTick(DateTime("2024-01-08"), 7.0),
+ ]);
+
+julia> ta_forward_fill(t_array)
+4-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-01T00:00:00, 2.0)
+ TimeTick(2024-01-03T00:00:00, 7.0)
+ TimeTick(2024-01-04T00:00:00, 7.0)
+ TimeTick(2024-01-08T00:00:00, 7.0)
+```
+"""
+function ta_forward_fill(pattern::Function, t_array::TimeArray{T,V}) where {T,V}
+ new_ticks = Vector{TimeTick{T,V}}(undef, length(t_array))
+ for i in reverse(eachindex(t_array))
+ next = findnext(x -> !pattern(x), t_array, i)
+ new_ticks[i] = TimeTick{T,V}(
+ ta_timestamp(t_array[i]),
+ ta_value(t_array[isnothing(next) ? i : next]),
+ )
+ end
+ return TimeArray{T,V}(new_ticks)
+end
+
+function ta_forward_fill(t_array::TimeArray)
+ return ta_forward_fill(isnan, t_array)
+end
+
+"""
+ ta_linear_fill([, pattern::Function], t_array::TimeArray) -> TimeArray
+
+Return an array where elements that match `pattern` are replaced by linear interpolation between nearest not-pattern values in `t_array`.
+By default `pattern` is `isnan` function.
+
+## Examples
+
+```jldoctest
+julia> using Dates
+
+julia> t_array = TimeArray([
+ TimeTick(DateTime("2024-01-02"), 2.0),
+ TimeTick(DateTime("2024-01-04"), NaN),
+ TimeTick(DateTime("2024-01-06"), NaN),
+ TimeTick(DateTime("2024-01-08"), 8.0),
+ ]);
+
+julia> ta_linear_fill(t_array)
+4-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-02T00:00:00, 2.0)
+ TimeTick(2024-01-04T00:00:00, 4.0)
+ TimeTick(2024-01-06T00:00:00, 6.0)
+ TimeTick(2024-01-08T00:00:00, 8.0)
+```
+"""
+function ta_linear_fill(pattern::Function, t_array::TimeArray{T,V}) where {T,V}
+ new_ticks = Vector{TimeTick{T,V}}(undef, length(t_array))
+ for i in eachindex(t_array)
+ prev = findprev(x -> !pattern(x), t_array, i)
+ next = findnext(x -> !pattern(x), t_array, i)
+ new_ticks[i] = if isnothing(prev) || isnothing(next) || prev == next
+ t_array[i]
+ else
+ l_timestamp, l_value = t_array[prev]
+ r_timestamp, r_value = t_array[next]
+ i_timestamp, i_value = t_array[i]
+ k = (i_timestamp - l_timestamp) / (r_timestamp - l_timestamp)
+ i_value = l_value + k * (r_value - l_value)
+ TimeTick{T,V}(i_timestamp, i_value)
+ end
+ end
+ return TimeArray{T,V}(new_ticks)
+end
+
+function ta_linear_fill(t_array::TimeArray)
+ return ta_linear_fill(isnan, t_array)
+end
diff --git a/src/interface.jl b/src/interface.jl
new file mode 100644
index 0000000..1b3fdb7
--- /dev/null
+++ b/src/interface.jl
@@ -0,0 +1,408 @@
+# interface
+
+#__ TimeTick
+
+"""
+ AbstractTick{T,V}
+
+Supertype for `TimeTick{T,V}` with timestmap of type `T` and value of type `V`.
+"""
+abstract type AbstractTick{T,V} end
+
+"""
+ TimeTick{T,V} <: AbstractTick{T,V}
+
+A type describing a timestamp of type `T<:TimeLike` and its value of type `V`.
+
+## Fields
+- `timestamp::T`: The timestamp.
+- `value::V`: The value.
+
+## Accessors
+- `ta_timestamp(x::TimeTick)` -> `x.timestamp`
+- `ta_value(x::TimeTick)` -> `x.value`
+"""
+struct TimeTick{T<:TimeLike,V<:Any} <: AbstractTick{T,V}
+ timestamp::T
+ value::V
+
+ function TimeTick{T,V}(timestamp::TimeLike, value) where {T<:TimeLike,V}
+ return new{T,V}(timestamp, value)
+ end
+
+ function TimeTick{T,V}(x::Tuple{TimeLike,Any}) where {T<:TimeLike,V}
+ return new{T,V}(x...)
+ end
+
+ function TimeTick{T,V}(x::NamedTuple{names,<:Tuple{TimeLike,Any}} where {names}) where {T<:TimeLike,V}
+ return new{T,V}(x...)
+ end
+
+ function TimeTick{T,V}(x::Pair{<:TimeLike,<:Any}) where {T<:TimeLike,V}
+ return new{T,V}(x.first, x.second)
+ end
+
+ function TimeTick{T,V}(x::TimeTick) where {T<:TimeLike,V}
+ return new{T,V}(ta_timestamp(x), ta_value(x))
+ end
+end
+
+"""
+ TimeTick{T,V}(timestamp::TimeLike, value)
+ TimeTick(timestamp::T, value::V)
+
+Constructs a [`TimeTick`](@ref) object with the passed `timestamp` and `value`.
+
+## Examples
+```jldoctest
+julia> using Dates
+
+julia> TimeTick{Date,Float64}(DateTime("2024-01-01T00:00:00"), 100)
+TimeTick(2024-01-01, 100.0)
+
+julia> TimeTick(DateTime("2024-01-01T00:00:00"), 100)
+TimeTick(2024-01-01T00:00:00, 100)
+```
+"""
+function TimeTick(timestamp::T, value::V) where {T<:TimeLike,V}
+ return TimeTick{T,V}(timestamp, value)
+end
+
+"""
+ TimeTick{T,V}(x::Tuple{TimeLike,Any})
+ TimeTick(x::Tuple{T,V})
+
+Constructs a [`TimeTick`](@ref) object from tuple `x` which contains the timestamp and value.
+
+## Examples
+```jldoctest
+julia> using Dates
+
+julia> TimeTick{Date,Float64}((DateTime("2024-01-01T00:00:00"), 100))
+TimeTick(2024-01-01, 100.0)
+
+julia> TimeTick((DateTime("2024-01-01T00:00:00"), 100))
+TimeTick(2024-01-01T00:00:00, 100)
+```
+"""
+function TimeTick(x::Tuple{T,V}) where {T<:TimeLike,V}
+ return TimeTick{T,V}(x...)
+end
+
+"""
+ TimeTick{T,V}(x::NamedTuple{_,Tuple{TimeLike,Any}})
+ TimeTick(x::NamedTuple{_,Tuple{TimeLike,Any}})
+
+Constructs a [`TimeTick`](@ref) object from named tuple `x` which contains the timestamp and value.
+
+## Examples
+```jldoctest
+julia> using Dates
+
+julia> TimeTick{Date,Float64}((timestmap = DateTime("2024-01-01T00:00:00"), value = 100))
+TimeTick(2024-01-01, 100.0)
+
+julia> TimeTick((timestmap = DateTime("2024-01-01T00:00:00"), value = 100))
+TimeTick(2024-01-01T00:00:00, 100)
+```
+"""
+function TimeTick(x::NamedTuple{names,Tuple{T,V}}) where {names,T<:TimeLike,V}
+ return TimeTick{T,V}(x...)
+end
+
+"""
+ TimeTick{T,V}(x::Pair{TimeLike,Number})
+ TimeTick(x::Pair{T,V})
+
+Constructs a [`TimeTick`](@ref) object from pair `x` which contains the timestamp and value.
+
+## Examples
+```jldoctest
+julia> using Dates
+
+julia> TimeTick{Date,Float64}(DateTime("2024-01-01T00:00:00") => 100)
+TimeTick(2024-01-01, 100.0)
+
+julia> TimeTick(DateTime("2024-01-01T00:00:00") => 100)
+TimeTick(2024-01-01T00:00:00, 100)
+```
+"""
+function TimeTick(x::Pair{T,V}) where {T<:TimeLike,V}
+ return TimeTick{T,V}(x.first, x.second)
+end
+
+function Base.show(io::IO, x::TimeTick{T,V}) where {T<:TimeLike,V}
+ print(io, "TimeTick(", ta_timestamp(x), ", ", ta_value(x), ")")
+end
+
+ta_timestamp(x::TimeTick) = x.timestamp
+ta_value(x::TimeTick) = x.value
+
+Base.keytype(::TimeTick{T,V}) where {T,V} = T
+Base.valtype(::TimeTick{T,V}) where {T,V} = V
+Base.eltype(::Type{TimeTick{T,V}}) where {T,V} = Union{T,V}
+Base.isnan(x::TimeTick) = isnan(ta_value(x))
+Base.isinf(x::TimeTick) = isinf(ta_value(x))
+
+function Base.convert(::Type{TimeTick{T,V}}, value::TimeTick{T,V}) where {T<:TimeLike,V}
+ return value
+end
+
+function Base.convert(::Type{TimeTick{T,V}}, value::TimeTick{TimeLike,Any}) where {T<:TimeLike,V}
+ return TimeTick{T,V}(value)
+end
+
+function Base.convert(::Type{TimeTick{T,V}}, value::Tuple{T,V}) where {T<:TimeLike,V}
+ return TimeTick{T,V}(value)
+end
+
+function Base.convert(::Type{TimeTick{T,V}}, value::Tuple{TimeLike,Number}) where {T<:TimeLike,V}
+ return TimeTick{T,V}(value)
+end
+
+function Base.convert(::Type{TimeTick{T,V}}, value::Pair{T,V}) where {T<:TimeLike,V}
+ return TimeTick{T,V}(value)
+end
+
+function Base.convert(::Type{TimeTick{T,V}}, value::Pair{TimeLike,Any}) where {T<:TimeLike,V}
+ return TimeTick{T,V}(value)
+end
+
+function Base.getindex(t::TimeTick, i::Integer)
+ i == 1 && return ta_timestamp(t)
+ i == 2 && return ta_value(t)
+ throw(BoundsError(t, i))
+end
+
+Base.firstindex(::TimeTick) = 1
+Base.lastindex(::TimeTick) = 2
+Base.length(::TimeTick) = 2
+Base.isless(l::TimeTick, r::TimeTick) = isless(ta_value(l), ta_value(r))
+
+function Base.iterate(value::TimeTick)
+ return (ta_timestamp(value), 2)
+end
+
+function Base.iterate(value::TimeTick, index::Integer)
+ index == 2 && return (ta_value(value), 3)
+ return nothing
+end
+
+function Base.:(==)(left::TimeTick, right::TimeTick)::Bool
+ return ta_timestamp(left) == ta_timestamp(right) && ta_value(left) == ta_value(right)
+end
+
+function Base.isequal(left::TimeTick, right::TimeTick)::Bool
+ return isequal(ta_timestamp(left), ta_timestamp(right)) && isequal(ta_value(left), ta_value(right))
+end
+
+#__ TimeArray
+
+"""
+ AbstractTimeArray{T,V} <: AbstractVector{TimeTick{T,V}}
+
+Supertype for `TimeArray{T,V}` with timestmaps of type `T` and values of type `V`.
+"""
+abstract type AbstractTimeArray{T,V} <: AbstractVector{TimeTick{T,V}} end
+
+"""
+ TimeArray{T,V} <: AbstractTimeArray{T,V}
+
+Type describing a time series with timestmaps of type `T` and values of type `V`.
+
+## Fields
+- `values::Vector{TimeTick{T,V}}`: Elements of a time series.
+- `length::Int64`: The length of the underlying array.
+
+## Accessors
+- `ta_values(x::TimeArray)` -> `x.values`
+"""
+struct TimeArray{T<:TimeLike,V} <: AbstractTimeArray{T,V}
+ values::Vector{TimeTick{T,V}}
+ length::Int64
+
+ function TimeArray{T,V}(values::AbstractVector{TimeTick{T,V}} = TimeTick{T,V}[]) where {T<:TimeLike,V}
+ issorted(values, by = ta_timestamp) || sort!(values, by = ta_timestamp)
+ return new{T,V}(values, length(values))
+ end
+
+ function TimeArray{T,V}(values::AbstractVector{TimeTick{T,V}}, length::Integer) where {T<:TimeLike,V}
+ return new{T,V}(values, length)
+ end
+
+ function TimeArray{T,V}(values::AbstractVector) where {T<:TimeLike,V}
+ return TimeArray{T,V}(TimeTick{T,V}.(values))
+ end
+end
+
+"""
+ TimeArray{T,V}(values::Vector{TimeTick})
+ TimeArray(values::Vector{TimeTick{T,V}})
+
+Creates a `TimeArray{T,V}` object from `values` and sorts them by date in ascending order.
+
+## Examples
+```jldoctest
+julia> using Dates
+
+julia> values = [
+ TimeTick(DateTime("2022-1-1T00:00:00"), 3),
+ TimeTick(DateTime("2023-1-1T00:00:00"), 1),
+ TimeTick(DateTime("2021-1-1T00:00:00"), 2),
+ ];
+
+julia> TimeArray{Date,Float64}(values)
+3-element TimeArray{Date, Float64}:
+ TimeTick(2021-01-01, 2.0)
+ TimeTick(2022-01-01, 3.0)
+ TimeTick(2023-01-01, 1.0)
+
+julia> TimeArray(values)
+3-element TimeArray{DateTime, Int64}:
+ TimeTick(2021-01-01T00:00:00, 2)
+ TimeTick(2022-01-01T00:00:00, 3)
+ TimeTick(2023-01-01T00:00:00, 1)
+```
+"""
+function TimeArray(values::AbstractVector{TimeTick{T,V}}) where {T<:TimeLike,V}
+ return TimeArray{T,V}(values)
+end
+
+"""
+ TimeArray(values::Vector{Pair{T,V}})
+ TimeArray(values::Vector{Tuple{TimeLike,Any}})
+ TimeArray(values::Vector{NamedTuple{_,Tuple{T,V}}})
+
+Creates a `TimeArray{T,V}` object from `values` and sorts them by date in ascending order.
+
+## Examples
+```jldoctest
+julia> using Dates
+
+julia> TimeArray([
+ DateTime("2024-01-02T00:00:00") => 3,
+ DateTime("2024-01-03T00:00:00") => 1,
+ DateTime("2024-01-01T00:00:00") => 2,
+ ])
+3-element TimeArray{DateTime, Int64}:
+ TimeTick(2024-01-01T00:00:00, 2)
+ TimeTick(2024-01-02T00:00:00, 3)
+ TimeTick(2024-01-03T00:00:00, 1)
+
+julia> TimeArray([
+ (DateTime("2024-01-02T00:00:00"), 3),
+ (DateTime("2024-01-03T00:00:00"), 1),
+ (DateTime("2024-01-01T00:00:00"), 2),
+ ])
+3-element TimeArray{DateTime, Int64}:
+ TimeTick(2024-01-01T00:00:00, 2)
+ TimeTick(2024-01-02T00:00:00, 3)
+ TimeTick(2024-01-03T00:00:00, 1)
+
+julia> TimeArray([
+ (time = DateTime("2024-01-02T00:00:00"), value = 3),
+ (time = DateTime("2024-01-03T00:00:00"), value = 1),
+ (time = DateTime("2024-01-01T00:00:00"), value = 2),
+ ])
+3-element TimeArray{DateTime, Int64}:
+ TimeTick(2024-01-01T00:00:00, 2)
+ TimeTick(2024-01-02T00:00:00, 3)
+ TimeTick(2024-01-03T00:00:00, 1)
+```
+"""
+function TimeArray(values::AbstractVector{Tuple{T,V}}) where {T<:TimeLike,V}
+ return TimeArray{T,V}(values)
+end
+
+function TimeArray(values::AbstractVector{NamedTuple{names,Tuple{T,V}}} where {names}) where {T<:TimeLike,V}
+ return TimeArray{T,V}(values)
+end
+
+function TimeArray(values::AbstractVector{Pair{T,V}}) where {T<:TimeLike,V}
+ return TimeArray{T,V}(values)
+end
+
+"""
+ TimeArray(timestamps::Vector{TimeLike}, values::Vector{Any})
+
+Creates a `TimeArray` by "zipping" together elements of `timestamps` and `values`.
+
+## Examples
+```jldoctest
+julia> using Dates
+
+julia> timestamps = [
+ DateTime("2024-01-02"),
+ DateTime("2024-01-03"),
+ DateTime("2024-01-01"),
+ ];
+
+julia> values = [2.0, 1.0, 3.0];
+
+julia> TimeArray(timestamps, values)
+3-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-01T00:00:00, 3.0)
+ TimeTick(2024-01-02T00:00:00, 2.0)
+ TimeTick(2024-01-03T00:00:00, 1.0)
+```
+"""
+function TimeArray(timestamp::AbstractVector{T}, values::AbstractVector{V}) where {T<:TimeLike,V}
+ return TimeArray{T,V}(TimeTick{T,V}.(timestamp, values))
+end
+
+"""
+ TimeArray{T,V}(values::AbstractVector)
+
+Creates a `TimeArrays{T,V}` from a `values` that contains any elements that can be passed to [`TimeTick{T,V}`](@ref TimeTick) constructors.
+
+!!! warning
+ This approach greatly reduces performance. Use at your own discretion.
+
+## Examples
+```jldoctest
+julia> using Dates
+
+julia> values = [
+ TimeTick(Date("2024-01-02"), 3.0),
+ (DateTime("2024-01-03"), 1.0),
+ Date("2024-01-01") => 2,
+ ];
+
+julia> TimeArray{Date,Int64}(values)
+3-element TimeArray{Date, Int64}:
+ TimeTick(2024-01-01, 2)
+ TimeTick(2024-01-02, 3)
+ TimeTick(2024-01-03, 1)
+```
+"""
+function TimeArray(::AbstractVector) end
+
+ta_values(x::TimeArray) = x.values
+
+Base.values(t_array::TimeArray) = ta_values(t_array)
+Base.keytype(::TimeArray{T,V}) where {T,V} = T
+Base.valtype(::TimeArray{T,V}) where {T,V} = V
+Base.eltype(t_array::TimeArray) = eltype(t_array.values)
+
+Base.length(t_array::TimeArray) = t_array.length
+Base.isempty(t_array::TimeArray) = length(t_array) == 0 || isempty(ta_values(t_array))
+Base.size(t_array::TimeArray) = size(ta_values(t_array))
+Base.IndexStyle(::Type{TimeArray}) = Base.IndexLinear()
+Base.firstindex(t_array::TimeArray) = 1
+Base.lastindex(t_array::TimeArray) = length(t_array)
+Base.eachindex(t_array::TimeArray) = Base.oneto(length(t_array))
+Base.getindex(t_array::TimeArray, i::Integer) = ta_values(t_array)[i]
+Base.getindex(t_array::TimeArray, i::UnitRange{<:Integer}) = TimeArray(ta_values(t_array)[i])
+Base.getindex(t_array::TimeArray, i::AbstractVector{<:Integer}) = TimeArray(ta_values(t_array)[i])
+
+function Base.iterate(t_array::TimeArray, index::Integer = 1)
+ return index <= length(t_array) ? iterate(ta_values(t_array), index) : nothing
+end
+
+function Base.:(==)(left::TimeArray, right::TimeArray)
+ return ta_values(left) == ta_values(right)
+end
+
+function Base.isequal(left::TimeArray, right::TimeArray)
+ return isequal(ta_values(left), ta_values(right))
+end
diff --git a/src/reduce.jl b/src/reduce.jl
new file mode 100644
index 0000000..d5464db
--- /dev/null
+++ b/src/reduce.jl
@@ -0,0 +1,25 @@
+# reduce
+
+function Base.reduce(f::Function, t_array::AbstractVector{TimeTick{T,V}}; kw...) where {T,V}
+ return reduce(f, map(ta_value, t_array; kw...))
+end
+
+function Base.sum(t_array::AbstractVector{TimeTick{T,V}}; init::V = zero(V)) where {T,V}
+ return sum(ta_value, t_array; init)
+end
+
+function Base.prod(t_array::AbstractVector{TimeTick{T,V}}; init::V = one(V)) where {T,V}
+ return prod(ta_value, t_array; init)
+end
+
+function Base.any(f::Function, t_array::AbstractVector{TimeTick{T,V}}) where {T,V}
+ return any(f, map(ta_value, t_array))
+end
+
+function Base.all(f::Function, t_array::AbstractVector{TimeTick{T,V}}) where {T,V}
+ return all(f, map(ta_value, t_array))
+end
+
+function Base.count(f::Function, t_array::AbstractVector{TimeTick{T,V}}) where {T,V}
+ return count(f, map(ta_value, t_array))
+end
diff --git a/src/resample.jl b/src/resample.jl
new file mode 100644
index 0000000..e4ffb72
--- /dev/null
+++ b/src/resample.jl
@@ -0,0 +1,288 @@
+# resample
+
+#__ TimeGrid
+
+struct TimeGrid{T<:TimeLike,P<:PeriodLike}
+ origin::T
+ period::P
+
+ function TimeGrid(origin::T, period::P) where {T<:TimeLike,P<:PeriodLike}
+ @assert hasmethod(+, (T, P)) "Origin type $T is not compatible with period type $P."
+ return new{T,P}(origin, period)
+ end
+end
+
+function Base.getindex(t_grid::TimeGrid, i::Integer)
+ return t_grid.origin + i * t_grid.period
+end
+
+function Base.findnext(predicate::Function, t_grid::TimeGrid, i::Integer = 0)
+ tᵢ = t_grid[i]
+ while !predicate(tᵢ)
+ i += 1
+ tᵢ = t_grid[i]
+ end
+ return i
+end
+
+function Base.findprev(predicate::Function, t_grid::TimeGrid, i::Integer = 0)
+ tᵢ = t_grid[i]
+ while !predicate(tᵢ)
+ i -= 1
+ tᵢ = t_grid[i]
+ end
+ return i
+end
+
+function fit_to_grid(timestamp::TimeLike, t_grid::TimeGrid, closed_left::Bool = true)
+ i = if timestamp <= t_grid.origin
+ cmp = closed_left ? (<=) : (<)
+ findprev(cmp(timestamp), t_grid)
+ elseif timestamp > t_grid.origin
+ cmp = closed_left ? (>) : (>=)
+ findnext(cmp(timestamp), t_grid) - 1
+ end
+ return (t_grid[i], i)
+end
+
+#__ Origin
+
+@enum ORIGIN_TYPE begin
+ START_OF_WINDOW
+ END_OF_WINDOW
+ ORIGIN_OF_WINDOW
+end
+
+@inline function fit_origin(t_array::TimeArray{T,V}, ::Val{ORIGIN_OF_WINDOW}) where {T<:Time,V<:Any}
+ return typemin(T)
+end
+
+@inline function fit_origin(t_array::TimeArray{T,V}, ::Val{ORIGIN_OF_WINDOW}) where {T<:Date,V<:Any}
+ return trunc(ta_timestamp(t_array[begin]), Year)
+end
+
+@inline function fit_origin(t_array::TimeArray{T,V}, ::Val{ORIGIN_OF_WINDOW}) where {T<:DateTime,V<:Any}
+ return trunc(ta_timestamp(t_array[begin]), Year)
+end
+
+@inline function fit_origin(t_array::TimeArray{T,V}, ::Val{ORIGIN_OF_WINDOW}) where {T<:Real,V<:Any}
+ return zero(T)
+end
+
+@inline function fit_origin(t_array::TimeArray{T,V}, ::Val{START_OF_WINDOW}) where {T<:Any,V<:Any}
+ return ta_timestamp(t_array[begin])
+end
+
+@inline function fit_origin(t_array::TimeArray{T,V}, ::Val{END_OF_WINDOW}) where {T<:Any,V<:Any}
+ return ta_timestamp(t_array[end])
+end
+
+function fit_time_interval(
+ t_array::TimeArray,
+ period::PeriodLike,
+ origin_type::ORIGIN_TYPE,
+ closed_left::Bool = true,
+)
+ origin = fit_origin(t_array, Val(origin_type))
+ t_grid = TimeGrid(origin, period)
+
+ t₀, i₀ = fit_to_grid(ta_timestamp(t_array[begin]), t_grid, closed_left)
+ tₙ, iₙ = fit_to_grid(ta_timestamp(t_array[end]), t_grid, closed_left)
+
+ return t₀, tₙ, iₙ - i₀ + 1
+end
+
+#__ TimeInterval
+
+struct TimeInterval{T<:TimeLike}
+ left::T
+ right::T
+ closed::T
+ label::T
+
+ function TimeInterval(
+ l_timestamp::T,
+ r_timestamp::T;
+ closed_left::Bool = true,
+ label_left::Bool = true,
+ ) where {T<:TimeLike}
+ return new{T}(
+ l_timestamp,
+ r_timestamp,
+ closed_left ? l_timestamp : r_timestamp,
+ label_left ? l_timestamp : r_timestamp,
+ )
+ end
+end
+
+function Base.in(timestamp::T, t_interval::TimeInterval{T}) where {T<:TimeLike}
+ return isequal(timestamp, t_interval.closed) ||
+ isless(t_interval.left, timestamp) &&
+ isless(timestamp, t_interval.right)
+end
+
+#__ IntervalIterator
+
+struct IntervalIterator{T<:TimeLike,P<:PeriodLike}
+ t₀::T
+ tₙ::T
+ Δt::P
+ closed_left::Bool
+ label_left::Bool
+
+ function IntervalIterator(
+ t₀::T,
+ tₙ::T,
+ Δt::P;
+ closed_left::Bool = true,
+ label_left::Bool = true,
+ ) where {T<:TimeLike,P<:PeriodLike}
+ return new{T,P}(t₀, tₙ, Δt, closed_left, label_left)
+ end
+end
+
+function Base.iterate(iter::IntervalIterator, i::Integer = 0)
+ tᵢ = iter.t₀ + i * iter.Δt
+ if tᵢ <= iter.tₙ
+ return (
+ TimeInterval(
+ tᵢ,
+ tᵢ + iter.Δt;
+ closed_left = iter.closed_left,
+ label_left = iter.label_left,
+ ),
+ i + 1,
+ )
+ else
+ return nothing
+ end
+end
+
+#__ Resampling
+
+@enum CLOSED_SIDE begin
+ CLOSED_RIGHT = false
+ CLOSED_LEFT = true
+end
+
+@enum LABEL_SIDE begin
+ LABEL_RIGHT = false
+ LABEL_LEFT = true
+end
+
+"""
+ ta_resample(f::Function, t_array::TimeArray{T,V}, period::PeriodLike; kw...) -> TimeArray
+
+Brings the values of `t_array` to a new time grid with new `period` using the function `f` on intermediate values of the old grid.
+
+Function `f` must accept a vector with elements of type `V` as input and return a new value, which will be assigned to the corresponding timestamp of the each window.
+If it is impossible to calculate a new value based on the received vector (for example, the vector is empty), then the `NaN` value or an equivalent value (for custom types) must be returned.
+
+## Keyword arguments
+- `origin::ORIGIN_TYPE = ORIGIN_OF_WINDOW`: Start of new grid (Possible values: `ORIGIN_OF_WINDOW`, `START_OF_WINDOW`, `END_OF_WINDOW`).
+- `closed::CLOSED_SIDE = CLOSED_LEFT`: Closed side of the half-open subintervals of new grid (Possible values: `CLOSED_LEFT`, `CLOSED_RIGHT`).
+- `label::LABEL_SIDE = LABEL_LEFT`: Label side of the subintervals of new grid (Possible values: `LABEL_LEFT`, `LABEL_RIGHT`).
+
+For more information see [`resample section`](@ref resample).
+
+## Examples
+
+```jldoctest
+julia> t_array = TimeArray{Int64,Int64}([(i, i) for i in 3:13])
+11-element TimeArray{Int64, Int64}:
+ TimeTick(3, 3)
+ TimeTick(4, 4)
+ TimeTick(5, 5)
+ TimeTick(6, 6)
+ TimeTick(7, 7)
+ TimeTick(8, 8)
+ TimeTick(9, 9)
+ TimeTick(10, 10)
+ TimeTick(11, 11)
+ TimeTick(12, 12)
+ TimeTick(13, 13)
+
+julia> ta_resample(sum, t_array, 4, closed = CLOSED_LEFT, label = LABEL_LEFT)
+4-element TimeArray{Int64, Float64}:
+ TimeTick(0, 3.0)
+ TimeTick(4, 22.0)
+ TimeTick(8, 38.0)
+ TimeTick(12, 25.0)
+
+julia> ta_resample(sum, t_array, 4, closed = CLOSED_LEFT, label = LABEL_RIGHT)
+4-element TimeArray{Int64, Float64}:
+ TimeTick(4, 3.0)
+ TimeTick(8, 22.0)
+ TimeTick(12, 38.0)
+ TimeTick(16, 25.0)
+
+julia> ta_resample(sum, t_array, 4, closed = CLOSED_RIGHT, label = LABEL_LEFT)
+4-element TimeArray{Int64, Float64}:
+ TimeTick(0, 7.0)
+ TimeTick(4, 26.0)
+ TimeTick(8, 42.0)
+ TimeTick(12, 13.0)
+
+julia> ta_resample(sum, t_array, 4, closed = CLOSED_RIGHT, label = LABEL_RIGHT)
+4-element TimeArray{Int64, Float64}:
+ TimeTick(4, 7.0)
+ TimeTick(8, 26.0)
+ TimeTick(12, 42.0)
+ TimeTick(16, 13.0)
+```
+
+```jldoctest
+julia> using Dates
+
+julia> t_array = TimeArray{DateTime,Int64}([
+ TimeTick(DateTime("2024-01-01"), 1),
+ TimeTick(DateTime("2024-01-02"), 2),
+ TimeTick(DateTime("2024-01-03"), 3),
+ TimeTick(DateTime("2024-01-09"), 4),
+ TimeTick(DateTime("2024-01-12"), 5),
+ TimeTick(DateTime("2024-01-13"), 6),
+ TimeTick(DateTime("2024-01-20"), 7),
+ ]);
+
+julia> ta_resample(x -> isempty(x) ? NaN : maximum(x), t_array, Day(3))
+7-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-01T00:00:00, 3.0)
+ TimeTick(2024-01-04T00:00:00, NaN)
+ TimeTick(2024-01-07T00:00:00, 4.0)
+ TimeTick(2024-01-10T00:00:00, 5.0)
+ TimeTick(2024-01-13T00:00:00, 6.0)
+ TimeTick(2024-01-16T00:00:00, NaN)
+ TimeTick(2024-01-19T00:00:00, 7.0)
+```
+"""
+function ta_resample(
+ f::Function,
+ t_array::TimeArray{T,V},
+ period::PeriodLike;
+ origin::ORIGIN_TYPE = ORIGIN_OF_WINDOW,
+ closed::CLOSED_SIDE = CLOSED_LEFT,
+ label::LABEL_SIDE = LABEL_LEFT,
+) where {T<:TimeLike,V}
+ isempty(t_array) && return t_array
+ V2 = promote_nan(return_type(f, V))
+
+ t₀, tₙ, n = fit_time_interval(t_array, period, origin, Bool(closed))
+ closed_left = Bool(closed)
+ label_left = Bool(label)
+
+ values = ta_value.(t_array)
+ new_ticks = Vector{TimeTick{T,V2}}(undef, n)
+ i = 1
+ for (j, interval) in enumerate(IntervalIterator(t₀, tₙ, period; closed_left, label_left))
+ window_start = i
+ while i <= length(t_array) && ta_timestamp(t_array[i]) in interval
+ i += 1
+ end
+ window_end = i - 1
+ window = view(values, window_start:window_end)
+ sampled_value = f(window)
+ new_ticks[j] = TimeTick{T,V2}(interval.label, sampled_value)
+ end
+
+ return TimeArray{T,V2}(new_ticks, length(new_ticks))
+end
diff --git a/src/rolling.jl b/src/rolling.jl
new file mode 100644
index 0000000..e5210be
--- /dev/null
+++ b/src/rolling.jl
@@ -0,0 +1,242 @@
+# rolling
+
+"""
+ ta_rolling(f::Function, t_array::TimeArray{T,V}, n::Integer) -> TimeArray
+ ta_rolling(f::Function, t_array::TimeArray{T,V}, p::Period) -> TimeArray
+
+Applies function `f` in a sliding window of length `n` or period `p` to the elements of `t_array`.
+Function `f` must accept a vector with elements of type `V` as input and return a new value, which will be assigned to the corresponding timestamp of each window.
+
+Function signature:
+```julia
+f(x::AbstractVector{V})::Any = ...
+```
+
+If it is impossible to calculate a new value based on the received vector (for example, the vector is empty), then the `NaN` value or an equivalent value (for custom types) must be returned.
+
+## Examples
+
+```jldoctest
+julia> using Dates
+
+julia> t_array = TimeArray([
+ TimeTick(DateTime("2024-01-01"), 1.0),
+ TimeTick(DateTime("2024-01-03"), 2.0),
+ TimeTick(DateTime("2024-01-04"), 3.0),
+ TimeTick(DateTime("2024-01-07"), 4.0),
+ TimeTick(DateTime("2024-01-09"), 5.0),
+ ]);
+
+julia> ta_rolling(sum, t_array, 3)
+5-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-01T00:00:00, NaN)
+ TimeTick(2024-01-03T00:00:00, NaN)
+ TimeTick(2024-01-04T00:00:00, 6.0)
+ TimeTick(2024-01-07T00:00:00, 9.0)
+ TimeTick(2024-01-09T00:00:00, 12.0)
+
+julia> t_array = TimeArray([
+ TimeTick(DateTime("2024-01-01"), 1.0),
+ TimeTick(DateTime("2024-01-03"), 2.0),
+ TimeTick(DateTime("2024-01-04"), 3.0),
+ TimeTick(DateTime("2024-01-07"), 4.0),
+ TimeTick(DateTime("2024-01-09"), 5.0),
+ ]);
+
+julia> ta_rolling(sum, t_array, Day(3))
+5-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-01T00:00:00, NaN)
+ TimeTick(2024-01-03T00:00:00, 3.0)
+ TimeTick(2024-01-04T00:00:00, 5.0)
+ TimeTick(2024-01-07T00:00:00, 4.0)
+ TimeTick(2024-01-09T00:00:00, 9.0)
+```
+"""
+function ta_rolling end
+
+function ta_rolling(f::Function, t_array::TimeArray{T,V}, window::Integer) where {T,V}
+ len = length(t_array)
+ V2 = promote_nan(return_type(f, V))
+ values = map(ta_value, t_array)
+ new_ticks = Vector{TimeTick{T,V2}}(undef, len)
+
+ for i in 1:min(window - 1, len)
+ t = ta_timestamp(t_array[i])
+ v = ta_nan(V2)
+ new_ticks[i] = TimeTick{T,V2}(t, v)
+ end
+
+ for i in window:len
+ t = ta_timestamp(t_array[i])
+ v = f(view(values, (i - window + 1):i))
+ new_ticks[i] = TimeTick{T,V2}(t, v)
+ end
+
+ return TimeArray{T,V2}(new_ticks, len)
+end
+
+function ta_rolling(f::Function, t_array::TimeArray{T,V}, window::Period) where {T,V}
+ len = length(t_array)
+ V2 = promote_nan(return_type(f, V))
+ values = map(ta_value, t_array)
+ new_ticks = Vector{TimeTick{T,V2}}(undef, len)
+
+ l_index = len
+ l_timestamp = ta_timestamp(t_array[l_index])
+
+ for r_index in len:-1:1
+ r_timestamp = ta_timestamp(t_array[r_index])
+
+ while l_index > 0
+ l_timestamp = ta_timestamp(t_array[l_index])
+ if l_timestamp > r_timestamp - window
+ l_index -= 1
+ else
+ break
+ end
+ end
+
+ value = if l_index > 0
+ f(view(values, l_index+1:r_index))
+ elseif l_index == 0
+ l_index = -1
+ f(view(values, 1:r_index))
+ else
+ ta_nan(V2)
+ end
+
+ new_ticks[r_index] =TimeTick{T,V2}(r_timestamp, value)
+ end
+
+ return TimeArray{T,V2}(new_ticks, len)
+end
+
+"""
+ ta_sma(t_array::TimeArray, n::Integer) -> TimeArray
+ ta_sma(t_array::TimeArray, p::Period) -> TimeArray
+
+Applies [Simple Moving Average](https://en.wikipedia.org/wiki/Moving_average) algorithm of length `n` or period `p` to the elements of `t_array`.
+
+## Examples
+
+```jldoctest
+julia> using Dates
+
+julia> t_array = TimeArray([
+ TimeTick(DateTime("2024-01-02"), 1.0),
+ TimeTick(DateTime("2024-01-03"), 2.0),
+ TimeTick(DateTime("2024-01-05"), 3.0),
+ TimeTick(DateTime("2024-01-06"), 4.0),
+ TimeTick(DateTime("2024-01-09"), 5.0),
+ ]);
+
+julia> ta_sma(t_array, 2)
+5-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-02T00:00:00, NaN)
+ TimeTick(2024-01-03T00:00:00, 1.5)
+ TimeTick(2024-01-05T00:00:00, 2.5)
+ TimeTick(2024-01-06T00:00:00, 3.5)
+ TimeTick(2024-01-09T00:00:00, 4.5)
+
+julia> t_array = TimeArray([
+ TimeTick(DateTime("2024-01-02"), 1.0),
+ TimeTick(DateTime("2024-01-03"), 2.0),
+ TimeTick(DateTime("2024-01-05"), 3.0),
+ TimeTick(DateTime("2024-01-06"), 4.0),
+ TimeTick(DateTime("2024-01-09"), 5.0),
+ ]);
+
+julia> ta_sma(t_array, Day(3))
+5-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-02T00:00:00, NaN)
+ TimeTick(2024-01-03T00:00:00, 1.5)
+ TimeTick(2024-01-05T00:00:00, 2.5)
+ TimeTick(2024-01-06T00:00:00, 3.5)
+ TimeTick(2024-01-09T00:00:00, 5.0)
+```
+"""
+function ta_sma(t_array::TimeArray, window::Union{Integer,Period})
+ return ta_rolling(mean, t_array, window)
+end
+
+"""
+ ta_lag(t_array::TimeArray, n::Integer) -> TimeArray
+
+Shifts the values of `t_array` elements by `n` positions forward.
+Displaced elements that remain without a value are set to `NaN`.
+
+## Examples
+
+```jldoctest
+julia> using Dates
+
+julia> t_array = TimeArray([
+ TimeTick(DateTime("2024-03-01"), 1.0),
+ TimeTick(DateTime("2024-03-02"), 2.0),
+ TimeTick(DateTime("2024-03-03"), 3.0),
+ TimeTick(DateTime("2024-03-04"), 4.0),
+ ]);
+
+julia> ta_lag(t_array, 2)
+4-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-03-01T00:00:00, NaN)
+ TimeTick(2024-03-02T00:00:00, NaN)
+ TimeTick(2024-03-03T00:00:00, 1.0)
+ TimeTick(2024-03-04T00:00:00, 2.0)
+```
+"""
+function ta_lag(t_array::TimeArray{T,V}, n::Integer) where {T,V}
+ len = length(t_array)
+ V2 = promote_nan(V)
+ values = map(ta_value, t_array)
+ new_ticks = Vector{TimeTick{T,V2}}(undef, len)
+
+ for i in eachindex(new_ticks)
+ t = ta_timestamp(t_array[i])
+ v = i <= n ? ta_nan(V2) : values[i - n]
+ new_ticks[i] = TimeTick{T,V2}(t, v)
+ end
+
+ return TimeArray(new_ticks)
+end
+
+"""
+ ta_lead(t_array::TimeArray{T,V}, n::Integer) -> TimeArray
+
+Shifts the values of `t_array` elements by `n` positions backward.
+Displaced elements that remain without a value are set to `NaN`.
+
+## Examples
+
+```jldoctest
+julia> using Dates
+
+julia> t_array = TimeArray([
+ TimeTick(DateTime("2024-03-01"), 1.0),
+ TimeTick(DateTime("2024-03-02"), 2.0),
+ TimeTick(DateTime("2024-03-03"), 3.0),
+ TimeTick(DateTime("2024-03-04"), 4.0),
+ ]);
+
+julia> ta_lead(t_array, 2)
+4-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-03-01T00:00:00, 3.0)
+ TimeTick(2024-03-02T00:00:00, 4.0)
+ TimeTick(2024-03-03T00:00:00, NaN)
+ TimeTick(2024-03-04T00:00:00, NaN)
+```
+"""
+function ta_lead(t_array::TimeArray{T,V}, n::Integer) where {T,V}
+ len = length(t_array)
+ V2 = promote_nan(V)
+ values = map(ta_value, t_array)
+ new_ticks = Vector{TimeTick{T,V2}}(undef, len)
+
+ for i in eachindex(new_ticks)
+ t = ta_timestamp(t_array[i])
+ v = i > len - n ? ta_nan(V2) : values[i + n]
+ new_ticks[i] = TimeTick{T,V2}(t, v)
+ end
+
+ return TimeArray(new_ticks)
+end
diff --git a/src/sample_data.jl b/src/sample_data.jl
new file mode 100644
index 0000000..ffc94b8
--- /dev/null
+++ b/src/sample_data.jl
@@ -0,0 +1,38 @@
+# sample_data
+
+export ta_price_sample_data,
+ ta_low_price_sample_data,
+ ta_high_price_sample_data
+
+function parse_csv(x::String; types::Dict = Dict{String,Any}())
+ rows = split(x, '\n'; keepempty = false)
+ names = Tuple(Symbol.(split(rows[begin], ',')))
+
+ return map(rows[2:end]) do x
+ vals = split(x, ',')
+ outs = []
+ for (i, name) in enumerate(names)
+ T = get(types, String(name), nothing)
+ push!(outs, isnothing(T) ? vals[i] : T(vals[i]))
+ end
+ NamedTuple{names}(outs)
+ end
+end
+
+function ta_price_sample_data()
+ str = read(joinpath(@__DIR__, "../assets/price_sample_data.csv"), String)
+ csv = parse_csv(str, types = Dict("time" => DateTime, "value" => x -> parse(Float64, x)))
+ return TimeArray(csv)
+end
+
+function ta_high_price_sample_data()
+ str = read(joinpath(@__DIR__, "../assets/high_price_sample_data.csv"), String)
+ csv = parse_csv(str, types = Dict("time" => DateTime, "value" => x -> parse(Float64, x)))
+ return TimeArray(csv)
+end
+
+function ta_low_price_sample_data()
+ str = read(joinpath(@__DIR__, "../assets/low_price_sample_data.csv"), String)
+ csv = parse_csv(str, types = Dict("time" => DateTime, "value" => x -> parse(Float64, x)))
+ return TimeArray(csv)
+end
diff --git a/test/Project.toml b/test/Project.toml
new file mode 100644
index 0000000..6f707c9
--- /dev/null
+++ b/test/Project.toml
@@ -0,0 +1,5 @@
+[deps]
+Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
+NanoDates = "46f1a544-deae-4307-8689-c12aa3c955c6"
diff --git a/test/array.jl b/test/array.jl
new file mode 100644
index 0000000..7c90256
--- /dev/null
+++ b/test/array.jl
@@ -0,0 +1,117 @@
+# t_array
+
+@testset verbose = true "TimeArray modification" begin
+ @testset "Case №1: Replace TimeTick's" begin
+ a = TimeArray([
+ TimeTick(Time(1), -2.0),
+ TimeTick(Time(2), -4.0),
+ TimeTick(Time(3), -6.0),
+ ])
+
+ @test replace(
+ x -> -2.0x,
+ TimeArray([
+ TimeTick(Time(1), 1.0),
+ TimeTick(Time(2), 2.0),
+ TimeTick(Time(3), 3.0),
+ ]),
+ ) == a
+end
+ @testset "Case №2: Replacing NaN's" begin
+ a = TimeArray([
+ TimeTick(Time(1), 1.0),
+ TimeTick(Time(2), 1.0),
+ TimeTick(Time(3), 1.0),
+ ])
+
+ @test replace(TimeArray([
+ TimeTick(Time(1), 1.0),
+ TimeTick(Time(2), NaN),
+ TimeTick(Time(3), 1.0),
+ ]), NaN => 1.0) == a
+
+ @test replace(TimeArray([
+ TimeTick(Time(1), NaN),
+ TimeTick(Time(2), NaN),
+ TimeTick(Time(3), NaN),
+ ]), NaN => 1.0) == a
+ end
+
+ @testset "Case №3: Fill methods" begin
+ ta_nan = TimeArray{Time,Float64}([
+ (Time(1), 5),
+ (Time(2), NaN),
+ (Time(3), 3),
+ (Time(4), Inf),
+ (Time(5), 7),
+ (Time(6), Inf),
+ (Time(7), NaN),
+ (Time(8), 10),
+ ])
+
+ @test isequal(TimeArray{Time,Float64}([
+ TimeTick(Time(1), 5.0),
+ TimeTick(Time(2), 3.0),
+ TimeTick(Time(3), 3.0),
+ TimeTick(Time(4), Inf),
+ TimeTick(Time(5), 7.0),
+ TimeTick(Time(6), Inf),
+ TimeTick(Time(7), 10.0),
+ TimeTick(Time(8), 10.0),
+ ]),
+ ta_forward_fill(ta_nan),
+ )
+
+ @test isequal(TimeArray{Time,Float64}([
+ TimeTick(Time(1), 5.0),
+ TimeTick(Time(2), 5.0),
+ TimeTick(Time(3), 3.0),
+ TimeTick(Time(4), Inf),
+ TimeTick(Time(5), 7.0),
+ TimeTick(Time(6), Inf),
+ TimeTick(Time(7), Inf),
+ TimeTick(Time(8), 10.0),
+ ]),
+ ta_backward_fill(ta_nan),
+ )
+
+ @test isequal(TimeArray{Time,Float64}([
+ TimeTick(Time(1), 5.0),
+ TimeTick(Time(2), 4.0),
+ TimeTick(Time(3), 3.0),
+ TimeTick(Time(4), Inf),
+ TimeTick(Time(5), 7.0),
+ TimeTick(Time(6), Inf),
+ TimeTick(Time(7), NaN),
+ TimeTick(Time(8), 10.0),
+ ]),
+ ta_linear_fill(ta_nan),
+ )
+
+ @test isequal(TimeArray{Time,Float64}([
+ TimeTick(Time(1), 5.0),
+ TimeTick(Time(2), 3.0),
+ TimeTick(Time(3), 3.0),
+ TimeTick(Time(4), 7.0),
+ TimeTick(Time(5), 7.0),
+ TimeTick(Time(6), 10.0),
+ TimeTick(Time(7), 10.0),
+ TimeTick(Time(8), 10.0),
+ ]),
+ ta_forward_fill(x -> isinf(x) || isnan(x), ta_nan),
+ )
+
+ @test isequal(TimeArray{Time,Float64}([
+ TimeTick(Time(1), 5.0),
+ TimeTick(Time(2), NaN),
+ TimeTick(Time(3), 3.0),
+ TimeTick(Time(4), 7.0),
+ TimeTick(Time(5), 7.0),
+ TimeTick(Time(6), NaN),
+ TimeTick(Time(7), NaN),
+ TimeTick(Time(8), 10.0),
+ ]),
+ ta_forward_fill(isinf, ta_nan),
+ )
+ end
+end
diff --git a/test/custom_type.jl b/test/custom_type.jl
new file mode 100644
index 0000000..dff26fa
--- /dev/null
+++ b/test/custom_type.jl
@@ -0,0 +1,192 @@
+# custom_type
+
+@testset verbose = true "Custom type TimeTick" begin
+
+ struct OHLC
+ o::Float64
+ h::Float64
+ l::Float64
+ c::Float64
+ end
+
+ # Interface
+ Base.isless(left::OHLC, right::OHLC) = left.h < right.h
+ TimeArrays.ta_nan(::Type{OHLC}) = OHLC(NaN, NaN, NaN, NaN)
+ Base.isnan(x::OHLC) = isnan(x.o) && isnan(x.h) && isnan(x.l) && isnan(x.c)
+ Base.zero(::Type{OHLC}) = OHLC(0.0, 0.0, 0.0, 0.0)
+
+ function merge_ohlc(left, right)
+ return OHLC(left.o + right.o, left.h - left.h, left.l * right.l, left.c / right.c)
+ end
+
+ Base.:/(left::Number, right::OHLC) = OHLC(left / right.o, left / right.h, left / right.l, left / right.c)
+ Base.:/(left::OHLC, right::Number) = OHLC(left.o / right, left.h / right, left.l / right, left.c / right)
+
+ @testset "Case №1: Merge functions" begin
+ left = TimeArray([
+ TimeTick(DateTime(2024, 1, 1, 1), OHLC(1, 2, 3, 4)),
+ TimeTick(DateTime(2024, 1, 1, 2), OHLC(1, 2, 3, 4)),
+ TimeTick(DateTime(2024, 1, 1, 3), OHLC(1, 2, 3, 4)),
+ ])
+
+ right = TimeArray([
+ TimeTick(DateTime(2024, 1, 1, 2), OHLC(1, 2, 3, 4)),
+ TimeTick(DateTime(2024, 1, 1, 3), OHLC(1, 2, 3, 4)),
+ TimeTick(DateTime(2024, 1, 1, 4), OHLC(1, 2, 3, 4)),
+ ])
+
+ @test isequal(
+ ta_mergewith(merge_ohlc, left, right),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1, 1), OHLC(NaN, NaN, NaN, NaN)),
+ TimeTick(DateTime(2024, 1, 1, 2), OHLC(2.0, 0.0, 9.0, 1.0)),
+ TimeTick(DateTime(2024, 1, 1, 3), OHLC(2.0, 0.0, 9.0, 1.0)),
+ TimeTick(DateTime(2024, 1, 1, 4), OHLC(2.0, 0.0, 9.0, 1.0)),
+ ]),
+ )
+ end
+
+ Base.:+(left::OHLC, right::OHLC) = OHLC(left.o + right.o, left.h + right.h, left.l + right.l, left.c + right.c)
+ Base.:-(left::OHLC, right::OHLC) = OHLC(left.o - right.o, left.h - right.h, left.l - right.l, left.c - right.c)
+ Base.:*(left::OHLC, right::OHLC) = OHLC(left.o * right.o, left.h * right.h, left.l * right.l, left.c * right.c)
+ Base.:*(left::Number, right::OHLC) = OHLC(left * right.o, left * right.h, left * right.l, left * right.c)
+ Base.:*(left::OHLC, right::Number) = right * left
+
+ @testset "Case №2: Fill functions" begin
+ ta_nan = TimeArray([
+ TimeTick(DateTime(2024, 1, 1, 2), OHLC(1, 1, 1, 1)),
+ TimeTick(DateTime(2024, 1, 1, 3), OHLC(NaN, NaN, NaN, NaN)),
+ TimeTick(DateTime(2024, 1, 1, 4), OHLC(NaN, NaN, NaN, NaN)),
+ TimeTick(DateTime(2024, 1, 1, 5), OHLC(10, 10, 10, 10)),
+ ])
+
+ @test isequal(
+ ta_forward_fill(ta_nan),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1, 2), OHLC(1.0, 1.0, 1.0, 1.0)),
+ TimeTick(DateTime(2024, 1, 1, 3), OHLC(10.0, 10.0, 10.0, 10.0)),
+ TimeTick(DateTime(2024, 1, 1, 4), OHLC(10.0, 10.0, 10.0, 10.0)),
+ TimeTick(DateTime(2024, 1, 1, 5), OHLC(10.0, 10.0, 10.0, 10.0)),
+ ]),
+ )
+
+ @test isequal(
+ ta_backward_fill(ta_nan),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1, 2), OHLC(1.0, 1.0, 1.0, 1.0)),
+ TimeTick(DateTime(2024, 1, 1, 3), OHLC(1.0, 1.0, 1.0, 1.0)),
+ TimeTick(DateTime(2024, 1, 1, 4), OHLC(1.0, 1.0, 1.0, 1.0)),
+ TimeTick(DateTime(2024, 1, 1, 5), OHLC(10.0, 10.0, 10.0, 10.0)),
+ ]),
+ )
+
+ @test isequal(
+ ta_linear_fill(ta_nan),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1, 2), OHLC(1.0, 1.0, 1.0, 1.0)),
+ TimeTick(DateTime(2024, 1, 1, 3), OHLC(4.0, 4.0, 4.0, 4.0)),
+ TimeTick(DateTime(2024, 1, 1, 4), OHLC(7.0, 7.0, 7.0, 7.0)),
+ TimeTick(DateTime(2024, 1, 1, 5), OHLC(10.0, 10.0, 10.0, 10.0)),
+ ]),
+ )
+ end
+
+ @testset "Case №3: Window functions" begin
+ ta_ohlc = TimeArray([
+ TimeTick(DateTime(2024, 1, 1, 1), OHLC(1, 2, 3, 4)),
+ TimeTick(DateTime(2024, 1, 1, 2), OHLC(1, 2, 3, 4)),
+ TimeTick(DateTime(2024, 1, 1, 3), OHLC(1, 2, 3, 4)),
+ TimeTick(DateTime(2024, 1, 1, 4), OHLC(1, 2, 3, 4)),
+ TimeTick(DateTime(2024, 1, 1, 5), OHLC(1, 2, 3, 4)),
+ TimeTick(DateTime(2024, 1, 1, 6), OHLC(1, 2, 3, 4)),
+ ])
+
+ @test isequal(
+ ta_lag(ta_ohlc, 3),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1, 1), OHLC(NaN, NaN, NaN, NaN)),
+ TimeTick(DateTime(2024, 1, 1, 2), OHLC(NaN, NaN, NaN, NaN)),
+ TimeTick(DateTime(2024, 1, 1, 3), OHLC(NaN, NaN, NaN, NaN)),
+ TimeTick(DateTime(2024, 1, 1, 4), OHLC(1.0, 2.0, 3.0, 4.0)),
+ TimeTick(DateTime(2024, 1, 1, 5), OHLC(1.0, 2.0, 3.0, 4.0)),
+ TimeTick(DateTime(2024, 1, 1, 6), OHLC(1.0, 2.0, 3.0, 4.0)),
+ ]),
+ )
+
+ @test isequal(
+ ta_sma(ta_ohlc, 3),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1, 1), OHLC(NaN, NaN, NaN, NaN)),
+ TimeTick(DateTime(2024, 1, 1, 2), OHLC(NaN, NaN, NaN, NaN)),
+ TimeTick(DateTime(2024, 1, 1, 3), OHLC(1.0, 2.0, 3.0, 4.0)),
+ TimeTick(DateTime(2024, 1, 1, 4), OHLC(1.0, 2.0, 3.0, 4.0)),
+ TimeTick(DateTime(2024, 1, 1, 5), OHLC(1.0, 2.0, 3.0, 4.0)),
+ TimeTick(DateTime(2024, 1, 1, 6), OHLC(1.0, 2.0, 3.0, 4.0)),
+ ]),
+ )
+
+ @test isequal(
+ ta_rolling(sum, ta_ohlc, 3),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1, 1), OHLC(NaN, NaN, NaN, NaN)),
+ TimeTick(DateTime(2024, 1, 1, 2), OHLC(NaN, NaN, NaN, NaN)),
+ TimeTick(DateTime(2024, 1, 1, 3), OHLC(3.0, 6.0, 9.0, 12.0)),
+ TimeTick(DateTime(2024, 1, 1, 4), OHLC(3.0, 6.0, 9.0, 12.0)),
+ TimeTick(DateTime(2024, 1, 1, 5), OHLC(3.0, 6.0, 9.0, 12.0)),
+ TimeTick(DateTime(2024, 1, 1, 6), OHLC(3.0, 6.0, 9.0, 12.0)),
+ ]),
+ )
+ end
+
+ @testset "Case №4: Resample functions" begin
+
+ ta_ohlc = TimeArray([
+ TimeTick(DateTime(2024, 1, 1, 1), OHLC(1, 2, 3, 4)),
+ TimeTick(DateTime(2024, 1, 1, 2), OHLC(1, 2, 3, 4)),
+ TimeTick(DateTime(2024, 1, 1, 3), OHLC(1, 2, 3, 4)),
+ TimeTick(DateTime(2024, 1, 1, 4), OHLC(1, 2, 3, 4)),
+ TimeTick(DateTime(2024, 1, 1, 5), OHLC(1, 2, 3, 4)),
+ TimeTick(DateTime(2024, 1, 1, 6), OHLC(1, 2, 3, 4)),
+ ])
+
+ @test isequal(
+ ta_resample(sum, ta_ohlc, Hour(2)),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1, 0), OHLC(1.0, 2.0, 3.0, 4.0)),
+ TimeTick(DateTime(2024, 1, 1, 2), OHLC(2.0, 4.0, 6.0, 8.0)),
+ TimeTick(DateTime(2024, 1, 1, 4), OHLC(2.0, 4.0, 6.0, 8.0)),
+ TimeTick(DateTime(2024, 1, 1, 6), OHLC(1.0, 2.0, 3.0, 4.0)),
+ ]),
+ )
+
+ @test isequal(
+ ta_resample(x -> isempty(x) ? ta_nan(x) : maximum(x), ta_ohlc, Minute(40)),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1, 0, 40), OHLC(1.0, 2.0, 3.0, 4.0)),
+ TimeTick(DateTime(2024, 1, 1, 1, 20), OHLC(NaN, NaN, NaN, NaN)),
+ TimeTick(DateTime(2024, 1, 1, 2, 0), OHLC(1.0, 2.0, 3.0, 4.0)),
+ TimeTick(DateTime(2024, 1, 1, 2, 40), OHLC(1.0, 2.0, 3.0, 4.0)),
+ TimeTick(DateTime(2024, 1, 1, 3, 20), OHLC(NaN, NaN, NaN, NaN)),
+ TimeTick(DateTime(2024, 1, 1, 4, 0), OHLC(1.0, 2.0, 3.0, 4.0)),
+ TimeTick(DateTime(2024, 1, 1, 4, 40), OHLC(1.0, 2.0, 3.0, 4.0)),
+ TimeTick(DateTime(2024, 1, 1, 5, 20), OHLC(NaN, NaN, NaN, NaN)),
+ TimeTick(DateTime(2024, 1, 1, 6, 0), OHLC(1.0, 2.0, 3.0, 4.0)),
+ ]),
+ )
+
+ @test isequal(
+ ta_resample(sum, ta_ohlc, Minute(40)),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1, 0, 40), OHLC(1.0, 2.0, 3.0, 4.0)),
+ TimeTick(DateTime(2024, 1, 1, 1, 20), OHLC(0.0, 0.0, 0.0, 0.0)),
+ TimeTick(DateTime(2024, 1, 1, 2, 0), OHLC(1.0, 2.0, 3.0, 4.0)),
+ TimeTick(DateTime(2024, 1, 1, 2, 40), OHLC(1.0, 2.0, 3.0, 4.0)),
+ TimeTick(DateTime(2024, 1, 1, 3, 20), OHLC(0.0, 0.0, 0.0, 0.0)),
+ TimeTick(DateTime(2024, 1, 1, 4, 0), OHLC(1.0, 2.0, 3.0, 4.0)),
+ TimeTick(DateTime(2024, 1, 1, 4, 40), OHLC(1.0, 2.0, 3.0, 4.0)),
+ TimeTick(DateTime(2024, 1, 1, 5, 20), OHLC(0.0, 0.0, 0.0, 0.0)),
+ TimeTick(DateTime(2024, 1, 1, 6, 0), OHLC(1.0, 2.0, 3.0, 4.0)),
+ ]),
+ )
+ end
+end
diff --git a/test/interface.jl b/test/interface.jl
new file mode 100644
index 0000000..c490af5
--- /dev/null
+++ b/test/interface.jl
@@ -0,0 +1,190 @@
+# interface
+
+@testset verbose = true "TimeTick constructors" begin
+ @testset "Case №1: TimeTick from timestamp and value" begin
+ @test TimeTick{Int64,Int64}(1.0, 2.0) == TimeTick(1, 2)
+ @test TimeTick{Float64,Float64}(1, 2) == TimeTick(1.0, 2.0)
+ @test TimeTick{Date,Float64}(DateTime("2023-01-01"), 2.0) == TimeTick(Date("2023-01-01"), 2.0)
+ @test TimeTick{DateTime,Float64}(Date("2023-01-01"), 2.0) == TimeTick(DateTime("2023-01-01"), 2.0)
+ @test TimeTick{DateTime,Float64}(DateTime("2023-01-01"), 2.0) == TimeTick(DateTime("2023-01-01"), 2.0)
+ @test TimeTick{NanoDate,Float64}(Date("2023-01-01"), 2.0) == TimeTick(NanoDate("2023-01-01"), 2.0)
+ @test TimeTick{Date,Float64}(DateTime("2023-01-01"), 2.0) == TimeTick(Date("2023-01-01"), 2.0)
+ @test TimeTick{Time,Float64}(DateTime("2023-01-01"), 2.0) == TimeTick(Time("00:00:00"), 2.0)
+ end
+
+ @testset "Case №2: TimeTick from Tuple" begin
+ @test TimeTick{Int64,Int64}((1.0, 2.0)) == TimeTick((1, 2))
+ @test TimeTick{Float64,Float64}((1, 2)) == TimeTick((1.0, 2.0))
+ @test TimeTick{Date,Float64}((DateTime("2023-01-01"), 2.0)) == TimeTick((Date("2023-01-01"), 2.0))
+ @test TimeTick{DateTime,Float64}((Date("2023-01-01"), 2.0)) == TimeTick((DateTime("2023-01-01"), 2.0))
+ @test TimeTick{DateTime,Float64}((DateTime("2023-01-01"), 2.0)) == TimeTick((DateTime("2023-01-01"), 2.0))
+ @test TimeTick{NanoDate,Float64}((Date("2023-01-01"), 2.0)) == TimeTick((NanoDate("2023-01-01"), 2.0))
+ @test TimeTick{Date,Float64}((DateTime("2023-01-01"), 2.0)) == TimeTick((Date("2023-01-01"), 2.0))
+ @test TimeTick{Time,Float64}((DateTime("2023-01-01"), 2.0)) == TimeTick((Time("00:00:00"), 2.0))
+ end
+
+ @testset "Case №3: TimeTick from Pair" begin
+ @test TimeTick{Int64,Int64}(1.0 => 2.0) == TimeTick(1 => 2)
+ @test TimeTick{Float64,Float64}(1 => 2) == TimeTick(1.0 => 2.0)
+ @test TimeTick{Date,Float64}(DateTime("2023-01-01") => 2.0) == TimeTick(Date("2023-01-01") => 2.0)
+ @test TimeTick{DateTime,Float64}(Date("2023-01-01") => 2.0) == TimeTick(DateTime("2023-01-01") => 2.0)
+ @test TimeTick{DateTime,Float64}(DateTime("2023-01-01") => 2.0) == TimeTick(DateTime("2023-01-01") => 2.0)
+ @test TimeTick{NanoDate,Float64}(Date("2023-01-01") => 2.0) == TimeTick(NanoDate("2023-01-01") => 2.0)
+ @test TimeTick{Date,Float64}(DateTime("2023-01-01") => 2.0) == TimeTick(Date("2023-01-01") => 2.0)
+ @test TimeTick{Time,Float64}(DateTime("2023-01-01") => 2.0) == TimeTick(Time("00:00:00") => 2.0)
+ end
+
+ @testset "Case №4: TimeTick from TimeTick" begin
+ @test TimeTick{Float64,Int64}(TimeTick{Int64,Float64}(1.0, 2)) == TimeTick(1.0, 2)
+ @test TimeTick{Date,Int64}(TimeTick{NanoDate,Float64}(DateTime("2023-01-01"), 2)) == TimeTick(Date("2023-01-01"), 2.0)
+ @test TimeTick{Time,Int64}(TimeTick{NanoDate,Float64}(DateTime("2023-01-01"), 2)) == TimeTick(Time("00:00:00"), 2.0)
+ @test TimeTick{DateTime,Int64}(TimeTick{NanoDate,Float64}(DateTime("2023-01-01"), 2)) == TimeTick(DateTime("2023-01-01"), 2.0)
+ end
+end
+
+@testset verbose = true "TimeArrays constructors" begin
+ @testset "Case №1: TimeArray from TimeTicks" begin
+ date_ticks = [
+ TimeTick{Date,Float64}(Date(2021), 1.0),
+ TimeTick{Date,Float64}(Date(2022), 2.0),
+ TimeTick{Date,Float64}(Date(2023), 3.0),
+ TimeTick{Date,Float64}(Date(2024), 4.0),
+ TimeTick{Date,Float64}(Date(2025), 5.0),
+ ]
+
+ time_ticks = [
+ TimeTick{Time,Float64}(Time(1), 1.0),
+ TimeTick{Time,Float64}(Time(2), 2.0),
+ TimeTick{Time,Float64}(Time(3), 3.0),
+ TimeTick{Time,Float64}(Time(4), 4.0),
+ TimeTick{Time,Float64}(Time(5), 5.0),
+ ]
+
+ value_ticks = [
+ TimeTick{Int64,Float64}(1, 1.0),
+ TimeTick{Int64,Float64}(2, 2.0),
+ TimeTick{Int64,Float64}(3, 3.0),
+ TimeTick{Int64,Float64}(4, 4.0),
+ TimeTick{Int64,Float64}(5, 5.0),
+ ]
+
+ @test TimeArray{Date,Float64}(date_ticks) == TimeArray(date_ticks)
+ @test TimeArray{Date,Float64}(date_ticks) == TimeArray(reverse(date_ticks))
+
+ @test TimeArray{Time,Float64}(time_ticks) == TimeArray(time_ticks)
+ @test TimeArray{Time,Float64}(time_ticks) == TimeArray(reverse(time_ticks))
+
+ @test TimeArray{Int64,Float64}(value_ticks) == TimeArray(value_ticks)
+ @test TimeArray{Int64,Float64}(value_ticks) == TimeArray(reverse(value_ticks))
+ end
+
+ @testset "Case №2: TimeArray from Tuples" begin
+ date_tuples = [
+ (Date(2021), 1.0),
+ (Date(2022), 2.0),
+ (Date(2023), 3.0),
+ (Date(2024), 4.0),
+ (Date(2025), 5.0),
+ ]
+
+ time_tuples = [
+ (Time(1), 1.0),
+ (Time(2), 2.0),
+ (Time(3), 3.0),
+ (Time(4), 4.0),
+ (Time(5), 5.0),
+ ]
+
+ value_tuples = [
+ (1, 1.0),
+ (2, 2.0),
+ (3, 3.0),
+ (4, 4.0),
+ (5, 5.0),
+ ]
+
+ @test TimeArray{Date,Float64}(date_tuples) == TimeArray(date_tuples)
+ @test TimeArray{Date,Float64}(date_tuples) == TimeArray(reverse(date_tuples))
+
+ @test TimeArray{Time,Float64}(time_tuples) == TimeArray(time_tuples)
+ @test TimeArray{Time,Float64}(time_tuples) == TimeArray(reverse(time_tuples))
+
+ @test TimeArray{Int64,Float64}(value_tuples) == TimeArray(value_tuples)
+ @test TimeArray{Int64,Float64}(value_tuples) == TimeArray(reverse(value_tuples))
+ end
+
+ @testset "Case №3: TimeArray from Pairs" begin
+ date_pairs = [
+ Date(2021) => 1.0,
+ Date(2022) => 2.0,
+ Date(2023) => 3.0,
+ Date(2024) => 4.0,
+ Date(2025) => 5.0,
+ ]
+
+ time_pairs = [
+ Time(1) => 1.0,
+ Time(2) => 2.0,
+ Time(3) => 3.0,
+ Time(4) => 4.0,
+ Time(5) => 5.0,
+ ]
+
+ value_pairs = [
+ 1 => 1.0,
+ 2 => 2.0,
+ 3 => 3.0,
+ 4 => 4.0,
+ 5 => 5.0,
+ ]
+
+ @test TimeArray{Date,Float64}(date_pairs) == TimeArray(date_pairs)
+ @test TimeArray{Date,Float64}(date_pairs) == TimeArray(reverse(date_pairs))
+
+ @test TimeArray{Time,Float64}(time_pairs) == TimeArray(time_pairs)
+ @test TimeArray{Time,Float64}(time_pairs) == TimeArray(reverse(time_pairs))
+
+ @test TimeArray{Int64,Float64}(value_pairs) == TimeArray(value_pairs)
+ @test TimeArray{Int64,Float64}(value_pairs) == TimeArray(reverse(value_pairs))
+ end
+
+ @testset "Case №3: TimeArray from Anything" begin
+ date_anything = [
+ TimeTick(Date(2021), 1.0),
+ (Date(2022), 2.0),
+ Date(2023) => 3.0,
+ ]
+
+ time_anything = [
+ TimeTick(Time(1), 1.0),
+ (Time(2), 2.0),
+ Time(3) => 3.0,
+ ]
+
+ value_anything = [
+ TimeTick(1, 1.0),
+ (2, 2.0),
+ 3 => 3.0,
+ ]
+
+ @test TimeArray{Date,Float64}(date_anything) == TimeArray{Date,Float64}(reverse(date_anything))
+
+ @test TimeArray{Time,Float64}(time_anything) == TimeArray{Time,Float64}(reverse(time_anything))
+
+ @test TimeArray{Int64,Float64}(value_anything) == TimeArray{Int64,Float64}(reverse(value_anything))
+ end
+
+ @testset "Case №4: TimeArray from timestamps and values" begin
+ date_timestamps = [Date(2021), Date(2022), Date(2023), Date(2024), Date(2025)]
+ time_timestamps = [Time(1), Time(2), Time(3), Time(4), Time(5)]
+ value_timestamps = [1, 2, 3, 4, 5]
+
+ values = [1.0, 2.0, 3.0, 4.0, 5.0]
+
+ @test TimeArray(date_timestamps, values) == TimeArray(reverse(date_timestamps), reverse(values))
+
+ @test TimeArray(time_timestamps, values) == TimeArray(reverse(time_timestamps), reverse(values))
+
+ @test TimeArray(value_timestamps, values) == TimeArray(reverse(value_timestamps), reverse(values))
+ end
+end
diff --git a/test/math.jl b/test/math.jl
new file mode 100644
index 0000000..52aac64
--- /dev/null
+++ b/test/math.jl
@@ -0,0 +1,429 @@
+# math
+
+@testset verbose = true "Merge TimeArrays" begin
+
+ left = TimeArray([
+ TimeTick(Time(1), 1.0),
+ TimeTick(Time(3), -2.0),
+ TimeTick(Time(4), 0.0),
+ ])
+
+ right = TimeArray([
+ TimeTick(Time(2), -1.0),
+ TimeTick(Time(3), 0.0),
+ TimeTick(Time(5), 3.0),
+ ])
+
+ @testset "Case №1: Custom merge functions" begin
+ merged_max = TimeArray([
+ TimeTick(Time(1), NaN),
+ TimeTick(Time(2), 1.0),
+ TimeTick(Time(3), 0.0),
+ TimeTick(Time(4), 0.0),
+ TimeTick(Time(5), 3.0),
+ ])
+
+ @test isequal(merged_max, ta_mergewith(max, left, right))
+
+ merged_min = TimeArray([
+ TimeTick(Time(1), NaN),
+ TimeTick(Time(2), -1.0),
+ TimeTick(Time(3), -2.0),
+ TimeTick(Time(4), 0.0),
+ TimeTick(Time(5), 0.0),
+ ])
+
+ @test isequal(merged_min, ta_mergewith(min, left, right))
+
+ merged_avg = TimeArray([
+ TimeTick(Time(1), NaN),
+ TimeTick(Time(2), 0.0),
+ TimeTick(Time(3), -1.0),
+ TimeTick(Time(4), 0.0),
+ TimeTick(Time(5), 1.5),
+ ])
+
+ @test isequal(merged_avg, ta_mergewith((x, y) -> (x + y) / 2.0, left, right))
+
+ merged_nan = TimeArray([
+ TimeTick(Time(1), NaN),
+ TimeTick(Time(2), NaN),
+ TimeTick(Time(3), NaN),
+ TimeTick(Time(4), NaN),
+ TimeTick(Time(5), NaN),
+ ])
+
+ @test isequal(merged_nan, ta_mergewith((x, y) -> NaN, left, right))
+ end
+
+ @testset "Case №2: Merge left timestamps" begin
+ left_avg = TimeArray([
+ TimeTick(Time(1), NaN),
+ TimeTick(Time(3), -1.0),
+ TimeTick(Time(4), 0.0),
+ ])
+
+ @test isequal(left_avg, ta_mergewith((x, y) -> (x + y) / 2.0, left, right, r_merge = false))
+ end
+
+ @testset "Case №3: Merge right timestamps" begin
+ right_avg = TimeArray([
+ TimeTick(Time(2), 0.0),
+ TimeTick(Time(3), -1.0),
+ TimeTick(Time(5), 1.5),
+ ])
+
+ @test isequal(right_avg, ta_mergewith((x, y) -> (x + y) / 2.0, left, right, l_merge = false))
+ end
+end
+
+@testset verbose = true "Base arithmetic" begin
+
+ a = TimeArray([
+ TimeTick(Time(2), 1.0),
+ TimeTick(Time(4), 2.0),
+ TimeTick(Time(6), 3.0),
+ ])
+
+ @testset verbose = true "Scalar arithmetic" begin
+
+ value = 2.0
+ @testset "Case №1: Plus" begin
+ a_plus_value = TimeArray([
+ TimeTick(Time(2), 3.0),
+ TimeTick(Time(4), 4.0),
+ TimeTick(Time(6), 5.0),
+ ])
+
+ @test isequal(a_plus_value, a + value)
+ end
+
+ @testset "Case №2: Minus" begin
+ a_minus_value = TimeArray([
+ TimeTick(Time(2), -1.0),
+ TimeTick(Time(4), 0.0),
+ TimeTick(Time(6), 1.0),
+ ])
+
+ @test isequal(a_minus_value, a - value)
+ end
+
+ @testset "Case №3: Multiply" begin
+ a_mul_value = TimeArray([
+ TimeTick(Time(2), 2.0),
+ TimeTick(Time(4), 4.0),
+ TimeTick(Time(6), 6.0),
+ ])
+
+ @test isequal(a_mul_value, a * value)
+ end
+
+ @testset "Case №4: Division" begin
+ a_div_value = TimeArray([
+ TimeTick(Time(2), 0.5),
+ TimeTick(Time(4), 1.0),
+ TimeTick(Time(6), 3.0/2.0),
+ ])
+
+ @test isequal(a_div_value, a / value)
+ end
+ end
+
+ @testset verbose = true "Identical timestamps" begin
+ @testset "Case №1: Plus" begin
+ a_plus_a = TimeArray([
+ TimeTick(Time(2), 2.0),
+ TimeTick(Time(4), 4.0),
+ TimeTick(Time(6), 6.0),
+ ])
+
+ @test isequal(a_plus_a, ta_mergewith(+, a, a))
+ @test isequal(a_plus_a, a + a)
+ end
+
+ @testset "Case №2: Minus" begin
+ a_minus_a = TimeArray([
+ TimeTick(Time(2), 0.0),
+ TimeTick(Time(4), 0.0),
+ TimeTick(Time(6), 0.0),
+ ])
+
+ @test isequal(a_minus_a, ta_mergewith(-, a, a))
+ @test isequal(a_minus_a, a - a)
+ end
+
+ @testset "Case №3: Multiply" begin
+ a_mul_a = TimeArray([
+ TimeTick(Time(2), 1.0),
+ TimeTick(Time(4), 4.0),
+ TimeTick(Time(6), 9.0),
+ ])
+
+ @test isequal(a_mul_a, ta_mergewith(*, a, a))
+ @test isequal(a_mul_a, a * a)
+ end
+
+ @testset "Case №4: Division" begin
+ a_div_a = TimeArray([
+ TimeTick(Time(2), 1.0),
+ TimeTick(Time(4), 1.0),
+ TimeTick(Time(6), 1.0),
+ ])
+
+ @test isequal(a_div_a, ta_mergewith(/, a, a))
+ @test isequal(a_div_a, a / a)
+ end
+ end
+
+ @testset verbose = true "Shifted forward timestamps" begin
+
+ b = TimeArray([
+ TimeTick(Time(3), 1.0),
+ TimeTick(Time(5), 2.0),
+ TimeTick(Time(7), 3.0),
+ ])
+
+ @testset "Case №1: Plus" begin
+ a_plus_b = TimeArray([
+ TimeTick(Time(2), NaN),
+ TimeTick(Time(3), 2.0),
+ TimeTick(Time(4), 3.0),
+ TimeTick(Time(5), 4.0),
+ TimeTick(Time(6), 5.0),
+ TimeTick(Time(7), 6.0),
+ ])
+
+ @test isequal(a_plus_b, ta_mergewith(+, a, b))
+ @test isequal(a_plus_b, a + b)
+ end
+
+ @testset "Case №2: Minus" begin
+ a_minus_b = TimeArray([
+ TimeTick(Time(2), NaN),
+ TimeTick(Time(3), 0.0),
+ TimeTick(Time(4), 1.0),
+ TimeTick(Time(5), 0.0),
+ TimeTick(Time(6), 1.0),
+ TimeTick(Time(7), 0.0),
+ ])
+
+ @test isequal(a_minus_b, ta_mergewith(-, a, b))
+ @test isequal(a_minus_b, a - b)
+ end
+
+ @testset "Case №3: Multiply" begin
+ a_mul_b = TimeArray([
+ TimeTick(Time(2), NaN),
+ TimeTick(Time(3), 1.0),
+ TimeTick(Time(4), 2.0),
+ TimeTick(Time(5), 4.0),
+ TimeTick(Time(6), 6.0),
+ TimeTick(Time(7), 9.0),
+ ])
+
+ @test isequal(a_mul_b, ta_mergewith(*, a, b))
+ @test isequal(a_mul_b, a * b)
+ end
+
+ @testset "Case №4: Division" begin
+ a_div_b = TimeArray([
+ TimeTick(Time(2), NaN),
+ TimeTick(Time(3), 1.0),
+ TimeTick(Time(4), 2.0),
+ TimeTick(Time(5), 1.0),
+ TimeTick(Time(6), 1.5),
+ TimeTick(Time(7), 1.0),
+ ])
+
+ @test isequal(a_div_b, ta_mergewith(/, a, b))
+ @test isequal(a_div_b, a / b)
+ end
+ end
+
+ @testset verbose = true "Shifted backward timestamps" begin
+
+ c = TimeArray([
+ TimeTick(Time(1), 1.0),
+ TimeTick(Time(3), 2.0),
+ TimeTick(Time(5), 3.0),
+ ])
+
+ @testset "Case №1: Plus" begin
+ a_plus_c = TimeArray([
+ TimeTick(Time(1), NaN),
+ TimeTick(Time(2), 2.0),
+ TimeTick(Time(3), 3.0),
+ TimeTick(Time(4), 4.0),
+ TimeTick(Time(5), 5.0),
+ TimeTick(Time(6), 6.0),
+ ])
+
+ @test isequal(a_plus_c, ta_mergewith(+, a, c))
+ @test isequal(a_plus_c, a + c)
+ end
+
+ @testset "Case №2: Minus" begin
+ a_minus_c = TimeArray([
+ TimeTick(Time(1), NaN),
+ TimeTick(Time(2), 0.0),
+ TimeTick(Time(3), -1.0),
+ TimeTick(Time(4), 0.0),
+ TimeTick(Time(5), -1.0),
+ TimeTick(Time(6), 0.0),
+ ])
+
+ @test isequal(a_minus_c, ta_mergewith(-, a, c))
+ @test isequal(a_minus_c, a - c)
+ end
+
+ @testset "Case №3: Multiply" begin
+ a_mul_c = TimeArray([
+ TimeTick(Time(1), NaN),
+ TimeTick(Time(2), 1.0),
+ TimeTick(Time(3), 2.0),
+ TimeTick(Time(4), 4.0),
+ TimeTick(Time(5), 6.0),
+ TimeTick(Time(6), 9.0),
+ ])
+
+ @test isequal(a_mul_c, ta_mergewith(*, a, c))
+ @test isequal(a_mul_c, a * c)
+ end
+
+ @testset "Case №4: Division" begin
+ a_div_c = TimeArray([
+ TimeTick(Time(1), NaN),
+ TimeTick(Time(2), 1.0),
+ TimeTick(Time(3), 0.5),
+ TimeTick(Time(4), 1.0),
+ TimeTick(Time(5), 2/3),
+ TimeTick(Time(6), 1.0),
+ ])
+
+ @test isequal(a_div_c, ta_mergewith(/, a, c))
+ @test isequal(a_div_c, a / c)
+ end
+ end
+
+ @testset verbose = true "Outer bounds timestamps" begin
+
+ d = TimeArray([
+ TimeTick(Time(1), 1.0),
+ TimeTick(Time(4), 2.0),
+ TimeTick(Time(7), 3.0),
+ ])
+
+ @testset "Case №1: Plus" begin
+ a_plus_d = TimeArray([
+ TimeTick(Time(1), NaN),
+ TimeTick(Time(2), 2.0),
+ TimeTick(Time(4), 4.0),
+ TimeTick(Time(6), 5.0),
+ TimeTick(Time(7), 6.0),
+ ])
+
+ @test isequal(a_plus_d, ta_mergewith(+, a, d))
+ @test isequal(a_plus_d, a + d)
+ end
+
+ @testset "Case №2: Minus" begin
+ a_minus_d = TimeArray([
+ TimeTick(Time(1), NaN),
+ TimeTick(Time(2), 0.0),
+ TimeTick(Time(4), 0.0),
+ TimeTick(Time(6), 1.0),
+ TimeTick(Time(7), 0.0),
+ ])
+
+ @test isequal(a_minus_d, ta_mergewith(-, a, d))
+ @test isequal(a_minus_d, a - d)
+ end
+
+ @testset "Case №3: Multiply" begin
+ a_mul_d = TimeArray([
+ TimeTick(Time(1), NaN),
+ TimeTick(Time(2), 1.0),
+ TimeTick(Time(4), 4.0),
+ TimeTick(Time(6), 6.0),
+ TimeTick(Time(7), 9.0),
+ ])
+
+ @test isequal(a_mul_d, ta_mergewith(*, a, d))
+ @test isequal(a_mul_d, a * d)
+ end
+
+ @testset "Case №4: Division" begin
+ a_div_d = TimeArray([
+ TimeTick(Time(1), NaN),
+ TimeTick(Time(2), 1.0),
+ TimeTick(Time(4), 1.0),
+ TimeTick(Time(6), 1.5),
+ TimeTick(Time(7), 1.0),
+ ])
+
+ @test isequal(a_div_d, ta_mergewith(/, a, d))
+ @test isequal(a_div_d, a / d)
+ end
+ end
+
+ @testset verbose = true "Inner bounds timestamps" begin
+
+ e = TimeArray([
+ TimeTick(Time(3), 1.0),
+ TimeTick(Time(4), 2.0),
+ TimeTick(Time(5), 3.0),
+ ])
+
+ @testset "Case №1: Plus" begin
+ a_plus_e = TimeArray([
+ TimeTick(Time(2), NaN),
+ TimeTick(Time(3), 2.0),
+ TimeTick(Time(4), 4.0),
+ TimeTick(Time(5), 5.0),
+ TimeTick(Time(6), 6.0),
+ ])
+
+ @test isequal(a_plus_e, ta_mergewith(+, a, e))
+ @test isequal(a_plus_e, a + e)
+ end
+
+ @testset "Case №2: Minus" begin
+ a_minus_e = TimeArray([
+ TimeTick(Time(2), NaN),
+ TimeTick(Time(3), 0.0),
+ TimeTick(Time(4), 0.0),
+ TimeTick(Time(5), -1.0),
+ TimeTick(Time(6), 0.0),
+ ])
+
+ @test isequal(a_minus_e, ta_mergewith(-, a, e))
+ @test isequal(a_minus_e, a - e)
+ end
+
+ @testset "Case №3: Multiply" begin
+ a_mul_e = TimeArray([
+ TimeTick(Time(2), NaN),
+ TimeTick(Time(3), 1.0),
+ TimeTick(Time(4), 4.0),
+ TimeTick(Time(5), 6.0),
+ TimeTick(Time(6), 9.0),
+ ])
+
+ @test isequal(a_mul_e, ta_mergewith(*, a, e))
+ @test isequal(a_mul_e, a * e)
+ end
+
+ @testset "Case №4: Division" begin
+ a_div_e = TimeArray([
+ TimeTick(Time(2), NaN),
+ TimeTick(Time(3), 1.0),
+ TimeTick(Time(4), 1.0),
+ TimeTick(Time(5), 2/3),
+ TimeTick(Time(6), 1.0),
+ ])
+
+ @test isequal(a_div_e, ta_mergewith(/, a, e))
+ @test isequal(a_div_e, a / e)
+ end
+ end
+end
diff --git a/test/resample.jl b/test/resample.jl
new file mode 100644
index 0000000..2487824
--- /dev/null
+++ b/test/resample.jl
@@ -0,0 +1,1140 @@
+# resample
+
+@testset verbose = true "Resampling" begin
+
+ @testset "Case №1: Resample empty" begin
+ @test ta_resample(sum, TimeArray{DateTime,Float64}(), Day(1)) |> isempty
+ end
+
+ @testset "Case №3: Resample custom func" begin
+ custom_ta = TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("1978-10-15T00:00:00"), 1),
+ TimeTick(DateTime("1978-10-15T03:00:00"), 2),
+ TimeTick(DateTime("1978-10-15T12:00:00"), 3),
+ TimeTick(DateTime("1978-10-16T00:00:00"), 4),
+ ])
+
+ @test isequal(TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("1978-10-15T00:00:00"), 42.0),
+ TimeTick(DateTime("1978-10-16T00:00:00"), 42.0),
+ ]),
+ ta_resample(vec -> 42, custom_ta, Day(1))
+ )
+
+ @test isequal(TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("1978-10-15T00:00:00"), 14),
+ TimeTick(DateTime("1978-10-16T00:00:00"), 16),
+ ]),
+ ta_resample(vec -> sum(vec .^ 2), custom_ta, Day(1)),
+ )
+ end
+
+ @testset "Case №4: Resample custom func with empty" begin
+ empty_custom_ta = TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("1978-10-15T00:00:00"), 1),
+ TimeTick(DateTime("1978-10-16T00:00:00"), 4),
+ ])
+
+ @test isequal(TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("1978-10-15T00:00:00"), 1.0),
+ TimeTick(DateTime("1978-10-15T12:00:00"), 0.0),
+ TimeTick(DateTime("1978-10-16T00:00:00"), 16.0),
+ ]),
+ ta_resample(vec -> sum(vec .^ 2), empty_custom_ta, Hour(12))
+ )
+ end
+
+ @testset "Case №5: Resample Real timestamps" begin
+ real_ta = TimeArray{Int64,Float64}([(1, 1), (2, 2), (3, 3)])
+
+ @test ta_resample(first, real_ta, 1) == real_ta
+ @test ta_resample(first, real_ta, 2) == TimeArray{Int64,Float64}([(0, 1.0), (2, 2.0)])
+ end
+
+ @testset "Case №6: Resample Date" begin
+ date_ta = TimeArray{Date,Float64}([
+ TimeTick(Date("2022-02-01"), 1),
+ TimeTick(Date("2022-02-17"), 2),
+ TimeTick(Date("2022-03-02"), 3),
+ ])
+
+ @test isequal(TimeArray{Date,Float64}([
+ TimeTick(Date("2022-01-31"), 1.0),
+ TimeTick(Date("2022-02-15"), 2.0),
+ TimeTick(Date("2022-03-02"), 3.0),
+ ]),
+ ta_resample(first, date_ta, Day(15))
+ )
+
+ @test isequal(TimeArray{Date,Float64}([
+ TimeTick(Date("2022-01-29"), 1.0),
+ TimeTick(Date("2022-02-12"), 2.0),
+ TimeTick(Date("2022-02-26"), 3.0),
+ ]),
+ ta_resample(first, date_ta, Week(2))
+ )
+
+ @test isequal(TimeArray{Date,Float64}([
+ TimeTick(Date("2022-02-01"), 1.0),
+ TimeTick(Date("2022-03-01"), 3.0),
+ ]),
+ ta_resample(first, date_ta, Month(1))
+ )
+ end
+end
+
+@testset verbose = true "Pandas resampling" begin
+ test_ta = TimeArray{DateTime,Float64}([
+ (DateTime("2024-01-01T00:01:00"), 508),
+ (DateTime("2024-01-01T00:29:00"), 925),
+ (DateTime("2024-01-01T00:44:00"), 911),
+ (DateTime("2024-01-01T01:12:00"), 998),
+ (DateTime("2024-01-01T01:17:00"), 93),
+ (DateTime("2024-01-01T01:28:00"), 928),
+ (DateTime("2024-01-01T01:29:00"), 9),
+ (DateTime("2024-01-01T01:31:00"), 587),
+ (DateTime("2024-01-01T02:24:00"), 527),
+ (DateTime("2024-01-01T03:04:00"), 836),
+ (DateTime("2024-01-01T03:16:00"), 469),
+ (DateTime("2024-01-01T03:25:00"), 750),
+ (DateTime("2024-01-01T03:53:00"), 259),
+ (DateTime("2024-01-01T04:14:00"), 843),
+ (DateTime("2024-01-01T04:49:00"), 792),
+ ])
+
+ @testset "Case №1:{'closed': 'left', 'label': 'left', 'origin': 'start'}" begin
+ sampled = ta_resample(
+ x -> isempty(x) ? NaN : mean(x),
+ test_ta,
+ Minute(30),
+ closed = CLOSED_LEFT,
+ label = LABEL_LEFT,
+ origin = START_OF_WINDOW,
+ )
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:01:00"), 716.5),
+ TimeTick(DateTime("2024-01-01T00:31:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 507.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 587.0),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:31:00"), NaN),
+ TimeTick(DateTime("2024-01-01T03:01:00"), 685.0),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled = ta_resample(sum, test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_LEFT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:01:00"), 1433.0),
+ TimeTick(DateTime("2024-01-01T00:31:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 2028.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 587.0),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:31:00"), 0.0),
+ TimeTick(DateTime("2024-01-01T03:01:00"), 2055.0),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : maximum(x), test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_LEFT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:01:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T00:31:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 998.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 587.0),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:31:00"), NaN),
+ TimeTick(DateTime("2024-01-01T03:01:00"), 836.0),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : minimum(x), test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_LEFT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:01:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:31:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 9.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 587.0),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:31:00"), NaN),
+ TimeTick(DateTime("2024-01-01T03:01:00"), 469.0),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : first(x), test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_LEFT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:01:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:31:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 998.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 587.0),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:31:00"), NaN),
+ TimeTick(DateTime("2024-01-01T03:01:00"), 836.0),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled = ta_resample(x -> isempty(x) ? NaN : last(x), test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_LEFT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:01:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T00:31:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 9.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 587.0),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:31:00"), NaN),
+ TimeTick(DateTime("2024-01-01T03:01:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(length, test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_LEFT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:01:00"), 2),
+ TimeTick(DateTime("2024-01-01T00:31:00"), 1),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 4),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 1),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 1),
+ TimeTick(DateTime("2024-01-01T02:31:00"), 0),
+ TimeTick(DateTime("2024-01-01T03:01:00"), 3),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 1),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 1),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 1),
+ ]),
+ sampled,
+ )
+ end
+
+ @testset "Case №2:{'closed': 'right', 'label': 'left', 'origin': 'start'}" begin
+ sampled = ta_resample(
+ x -> isempty(x) ? NaN : mean(x),
+ test_ta,
+ Minute(30),
+ closed = CLOSED_RIGHT,
+ label = LABEL_LEFT,
+ origin = START_OF_WINDOW,
+ )
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2023-12-31T23:31:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:01:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T00:31:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 523.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:31:00"), NaN),
+ TimeTick(DateTime("2024-01-01T03:01:00"), 685.0),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled = ta_resample(sum, test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_LEFT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2023-12-31T23:31:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:01:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T00:31:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 2615.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 0.0),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:31:00"), 0.0),
+ TimeTick(DateTime("2024-01-01T03:01:00"), 2055.0),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : maximum(x), test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_LEFT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2023-12-31T23:31:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:01:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T00:31:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 998.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:31:00"), NaN),
+ TimeTick(DateTime("2024-01-01T03:01:00"), 836.0),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : minimum(x), test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_LEFT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2023-12-31T23:31:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:01:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T00:31:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 9.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:31:00"), NaN),
+ TimeTick(DateTime("2024-01-01T03:01:00"), 469.0),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : first(x), test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_LEFT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2023-12-31T23:31:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:01:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T00:31:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 998.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:31:00"), NaN),
+ TimeTick(DateTime("2024-01-01T03:01:00"), 836.0),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : last(x), test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_LEFT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2023-12-31T23:31:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:01:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T00:31:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 587.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:31:00"), NaN),
+ TimeTick(DateTime("2024-01-01T03:01:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(length, test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_LEFT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2023-12-31T23:31:00"), 1),
+ TimeTick(DateTime("2024-01-01T00:01:00"), 1),
+ TimeTick(DateTime("2024-01-01T00:31:00"), 1),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 5),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 0),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 1),
+ TimeTick(DateTime("2024-01-01T02:31:00"), 0),
+ TimeTick(DateTime("2024-01-01T03:01:00"), 3),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 1),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 1),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 1),
+ ]),
+ sampled,
+ )
+ end
+
+ @testset "Case №3:{'closed': 'left', 'label': 'right', 'origin': 'start'}" begin
+ sampled = ta_resample(
+ x -> isempty(x) ? NaN : mean(x),
+ test_ta,
+ Minute(30),
+ closed = CLOSED_LEFT,
+ label = LABEL_RIGHT,
+ origin = START_OF_WINDOW,
+ )
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:31:00"), 716.5),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 507.0),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 587.0),
+ TimeTick(DateTime("2024-01-01T02:31:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:01:00"), NaN),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 685.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T05:01:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled = ta_resample(sum, test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_RIGHT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:31:00"), 1433.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 2028.0),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 587.0),
+ TimeTick(DateTime("2024-01-01T02:31:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:01:00"), 0.0),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 2055.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T05:01:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : maximum(x), test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_RIGHT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:31:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 998.0),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 587.0),
+ TimeTick(DateTime("2024-01-01T02:31:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:01:00"), NaN),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 836.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T05:01:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : minimum(x), test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_RIGHT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:31:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 9.0),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 587.0),
+ TimeTick(DateTime("2024-01-01T02:31:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:01:00"), NaN),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 469.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T05:01:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : first(x), test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_RIGHT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:31:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 998.0),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 587.0),
+ TimeTick(DateTime("2024-01-01T02:31:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:01:00"), NaN),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 836.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T05:01:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : last(x), test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_RIGHT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:31:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 9.0),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 587.0),
+ TimeTick(DateTime("2024-01-01T02:31:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:01:00"), NaN),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T05:01:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(length, test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_RIGHT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:31:00"), 2),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 1),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 4),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 1),
+ TimeTick(DateTime("2024-01-01T02:31:00"), 1),
+ TimeTick(DateTime("2024-01-01T03:01:00"), 0),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 3),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 1),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 1),
+ TimeTick(DateTime("2024-01-01T05:01:00"), 1),
+ ]),
+ sampled,
+ )
+ end
+
+ @testset "Case №4:{'closed': 'right', 'label': 'right', 'origin': 'start'}" begin
+ sampled = ta_resample(
+ x -> isempty(x) ? NaN : mean(x),
+ test_ta,
+ Minute(30),
+ closed = CLOSED_RIGHT,
+ label = LABEL_RIGHT,
+ origin = START_OF_WINDOW,
+ )
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:01:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:31:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 523.0),
+ TimeTick(DateTime("2024-01-01T02:01:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:31:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:01:00"), NaN),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 685.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T05:01:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(sum, test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_RIGHT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:01:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:31:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 2615.0),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 0.0),
+ TimeTick(DateTime("2024-01-01T02:31:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:01:00"), 0.0),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 2055.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T05:01:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : maximum(x), test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_RIGHT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:01:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:31:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 998.0),
+ TimeTick(DateTime("2024-01-01T02:01:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:31:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:01:00"), NaN),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 836.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T05:01:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : minimum(x), test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_RIGHT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:01:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:31:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 9.0),
+ TimeTick(DateTime("2024-01-01T02:01:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:31:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:01:00"), NaN),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 469.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T05:01:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : first(x), test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_RIGHT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:01:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:31:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 998.0),
+ TimeTick(DateTime("2024-01-01T02:01:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:31:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:01:00"), NaN),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 836.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T05:01:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : last(x), test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_RIGHT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:01:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:31:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 587.0),
+ TimeTick(DateTime("2024-01-01T02:01:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:31:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:01:00"), NaN),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T05:01:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(length, test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_RIGHT, origin = START_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:01:00"), 1),
+ TimeTick(DateTime("2024-01-01T00:31:00"), 1),
+ TimeTick(DateTime("2024-01-01T01:01:00"), 1),
+ TimeTick(DateTime("2024-01-01T01:31:00"), 5),
+ TimeTick(DateTime("2024-01-01T02:01:00"), 0),
+ TimeTick(DateTime("2024-01-01T02:31:00"), 1),
+ TimeTick(DateTime("2024-01-01T03:01:00"), 0),
+ TimeTick(DateTime("2024-01-01T03:31:00"), 3),
+ TimeTick(DateTime("2024-01-01T04:01:00"), 1),
+ TimeTick(DateTime("2024-01-01T04:31:00"), 1),
+ TimeTick(DateTime("2024-01-01T05:01:00"), 1),
+ ]),
+ sampled,
+ )
+ end
+
+ @testset "Case №5:{'closed': 'left', 'label': 'left', 'origin': 'end'}" begin
+ sampled = ta_resample(
+ x -> isempty(x) ? NaN : mean(x),
+ test_ta,
+ Minute(30),
+ closed = CLOSED_LEFT,
+ label = LABEL_LEFT,
+ origin = END_OF_WINDOW,
+ )
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2023-12-31T23:49:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:19:00"), 918.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 545.5),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:19:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 652.5),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 551.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), NaN),
+ TimeTick(DateTime("2024-01-01T04:49:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled = ta_resample(sum, test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_LEFT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2023-12-31T23:49:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:19:00"), 1836.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 1091.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 1524.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), 0.0),
+ TimeTick(DateTime("2024-01-01T02:19:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 1305.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 1102.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 0.0),
+ TimeTick(DateTime("2024-01-01T04:49:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : maximum(x), test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_LEFT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2023-12-31T23:49:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:19:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 998.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 928.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:19:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 836.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), NaN),
+ TimeTick(DateTime("2024-01-01T04:49:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : minimum(x), test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_LEFT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2023-12-31T23:49:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:19:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 93.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 9.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:19:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 469.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), NaN),
+ TimeTick(DateTime("2024-01-01T04:49:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled = ta_resample(x -> isempty(x) ? NaN : first(x), test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_LEFT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2023-12-31T23:49:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:19:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 998.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 928.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:19:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 836.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), NaN),
+ TimeTick(DateTime("2024-01-01T04:49:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled = ta_resample(x -> isempty(x) ? NaN : last(x), test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_LEFT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2023-12-31T23:49:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:19:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 93.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 587.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:19:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 469.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), NaN),
+ TimeTick(DateTime("2024-01-01T04:49:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled = ta_resample(length, test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_LEFT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2023-12-31T23:49:00"), 1),
+ TimeTick(DateTime("2024-01-01T00:19:00"), 2),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 2),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 3),
+ TimeTick(DateTime("2024-01-01T01:49:00"), 0),
+ TimeTick(DateTime("2024-01-01T02:19:00"), 1),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 2),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 1),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 2),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 0),
+ TimeTick(DateTime("2024-01-01T04:49:00"), 1),
+ ]),
+ sampled,
+ )
+ end
+
+ @testset "Case №6:{'closed': 'right', 'label': 'left', 'origin': 'end'}" begin
+ sampled = ta_resample(
+ x -> isempty(x) ? NaN : mean(x),
+ test_ta,
+ Minute(30),
+ closed = CLOSED_RIGHT,
+ label = LABEL_LEFT,
+ origin = END_OF_WINDOW,
+ )
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2023-12-31T23:49:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:19:00"), 918.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 545.5),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:19:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 652.5),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 551.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled = ta_resample(sum, test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_LEFT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2023-12-31T23:49:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:19:00"), 1836.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 1091.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 1524.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), 0.0),
+ TimeTick(DateTime("2024-01-01T02:19:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 1305.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 1102.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : maximum(x), test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_LEFT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2023-12-31T23:49:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:19:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 998.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 928.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:19:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 836.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : minimum(x), test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_LEFT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2023-12-31T23:49:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:19:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 93.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 9.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:19:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 469.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled = ta_resample(x -> isempty(x) ? NaN : first(x), test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_LEFT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2023-12-31T23:49:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:19:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 998.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 928.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:19:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 836.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled = ta_resample(x -> isempty(x) ? NaN : last(x), test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_LEFT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2023-12-31T23:49:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:19:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 93.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 587.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:19:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 469.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(length, test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_LEFT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2023-12-31T23:49:00"), 1),
+ TimeTick(DateTime("2024-01-01T00:19:00"), 2),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 2),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 3),
+ TimeTick(DateTime("2024-01-01T01:49:00"), 0),
+ TimeTick(DateTime("2024-01-01T02:19:00"), 1),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 2),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 1),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 2),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 1),
+ ]),
+ sampled,
+ )
+ end
+
+ @testset "Case №7:{'closed': 'left', 'label': 'right', 'origin': 'end'}" begin
+ sampled = ta_resample(
+ x -> isempty(x) ? NaN : mean(x),
+ test_ta,
+ Minute(30),
+ closed = CLOSED_LEFT,
+ label = LABEL_RIGHT,
+ origin = END_OF_WINDOW,
+ )
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:19:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 918.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 545.5),
+ TimeTick(DateTime("2024-01-01T01:49:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T02:19:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 652.5),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 551.0),
+ TimeTick(DateTime("2024-01-01T04:49:00"), NaN),
+ TimeTick(DateTime("2024-01-01T05:19:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled = ta_resample(sum, test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_RIGHT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:19:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 1836.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 1091.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), 1524.0),
+ TimeTick(DateTime("2024-01-01T02:19:00"), 0.0),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 1305.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 1102.0),
+ TimeTick(DateTime("2024-01-01T04:49:00"), 0.0),
+ TimeTick(DateTime("2024-01-01T05:19:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : maximum(x), test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_RIGHT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:19:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 998.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), 928.0),
+ TimeTick(DateTime("2024-01-01T02:19:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 836.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T04:49:00"), NaN),
+ TimeTick(DateTime("2024-01-01T05:19:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : minimum(x), test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_RIGHT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:19:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 93.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), 9.0),
+ TimeTick(DateTime("2024-01-01T02:19:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 469.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:49:00"), NaN),
+ TimeTick(DateTime("2024-01-01T05:19:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled = ta_resample(x -> isempty(x) ? NaN : first(x), test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_RIGHT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:19:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 998.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), 928.0),
+ TimeTick(DateTime("2024-01-01T02:19:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 836.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:49:00"), NaN),
+ TimeTick(DateTime("2024-01-01T05:19:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled = ta_resample(x -> isempty(x) ? NaN : last(x), test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_RIGHT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:19:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 93.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), 587.0),
+ TimeTick(DateTime("2024-01-01T02:19:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 469.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T04:49:00"), NaN),
+ TimeTick(DateTime("2024-01-01T05:19:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(length, test_ta, Minute(30), closed = CLOSED_LEFT, label = LABEL_RIGHT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:19:00"), 1),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 2),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 2),
+ TimeTick(DateTime("2024-01-01T01:49:00"), 3),
+ TimeTick(DateTime("2024-01-01T02:19:00"), 0),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 1),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 2),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 1),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 2),
+ TimeTick(DateTime("2024-01-01T04:49:00"), 0),
+ TimeTick(DateTime("2024-01-01T05:19:00"), 1),
+ ]),
+ sampled,
+ )
+ end
+
+ @testset "Case №8:{'closed': 'right', 'label': 'right', 'origin': 'end'}" begin
+ sampled = ta_resample(
+ x -> isempty(x) ? NaN : mean(x),
+ test_ta,
+ Minute(30),
+ closed = CLOSED_RIGHT,
+ label = LABEL_RIGHT,
+ origin = END_OF_WINDOW,
+ )
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:19:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 918.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 545.5),
+ TimeTick(DateTime("2024-01-01T01:49:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T02:19:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 652.5),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 551.0),
+ TimeTick(DateTime("2024-01-01T04:49:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled = ta_resample(sum, test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_RIGHT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:19:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 1836.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 1091.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), 1524.0),
+ TimeTick(DateTime("2024-01-01T02:19:00"), 0.0),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 1305.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 1102.0),
+ TimeTick(DateTime("2024-01-01T04:49:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : maximum(x), test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_RIGHT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:19:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 998.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), 928.0),
+ TimeTick(DateTime("2024-01-01T02:19:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 836.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T04:49:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : minimum(x), test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_RIGHT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:19:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 93.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), 9.0),
+ TimeTick(DateTime("2024-01-01T02:19:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 469.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:49:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(x -> isempty(x) ? NaN : first(x), test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_RIGHT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:19:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 925.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 998.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), 928.0),
+ TimeTick(DateTime("2024-01-01T02:19:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 836.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 259.0),
+ TimeTick(DateTime("2024-01-01T04:49:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled = ta_resample(x -> isempty(x) ? NaN : last(x), test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_RIGHT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:19:00"), 508.0),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 911.0),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 93.0),
+ TimeTick(DateTime("2024-01-01T01:49:00"), 587.0),
+ TimeTick(DateTime("2024-01-01T02:19:00"), NaN),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 527.0),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 469.0),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 750.0),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 843.0),
+ TimeTick(DateTime("2024-01-01T04:49:00"), 792.0),
+ ]),
+ sampled,
+ )
+ sampled =
+ ta_resample(length, test_ta, Minute(30), closed = CLOSED_RIGHT, label = LABEL_RIGHT, origin = END_OF_WINDOW)
+ @test isequal(
+ TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01T00:19:00"), 1),
+ TimeTick(DateTime("2024-01-01T00:49:00"), 2),
+ TimeTick(DateTime("2024-01-01T01:19:00"), 2),
+ TimeTick(DateTime("2024-01-01T01:49:00"), 3),
+ TimeTick(DateTime("2024-01-01T02:19:00"), 0),
+ TimeTick(DateTime("2024-01-01T02:49:00"), 1),
+ TimeTick(DateTime("2024-01-01T03:19:00"), 2),
+ TimeTick(DateTime("2024-01-01T03:49:00"), 1),
+ TimeTick(DateTime("2024-01-01T04:19:00"), 2),
+ TimeTick(DateTime("2024-01-01T04:49:00"), 1),
+ ]),
+ sampled,
+ )
+ end
+end
diff --git a/test/rolling.jl b/test/rolling.jl
new file mode 100644
index 0000000..ee80773
--- /dev/null
+++ b/test/rolling.jl
@@ -0,0 +1,311 @@
+# rolling
+
+@testset verbose = true "" begin
+ @testset "Case №1: Fixed window" begin
+ ta_for_window = TimeArray([
+ TimeTick(DateTime(2024, 1, 1), 1.0),
+ TimeTick(DateTime(2024, 1, 2), 2.0),
+ TimeTick(DateTime(2024, 1, 5), 3.0),
+ TimeTick(DateTime(2024, 1, 6), 4.0),
+ TimeTick(DateTime(2024, 1, 7), 5.0),
+ TimeTick(DateTime(2024, 1, 15), 6.0),
+ ])
+
+ @test isequal(
+ ta_rolling(sum, ta_for_window, 4),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1), NaN),
+ TimeTick(DateTime(2024, 1, 2), NaN),
+ TimeTick(DateTime(2024, 1, 5), NaN),
+ TimeTick(DateTime(2024, 1, 6), 10.0),
+ TimeTick(DateTime(2024, 1, 7), 14.0),
+ TimeTick(DateTime(2024, 1, 15), 18.0),
+ ]),
+ )
+
+ @test isequal(
+ ta_rolling(mean, ta_for_window, 4),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1), NaN),
+ TimeTick(DateTime(2024, 1, 2), NaN),
+ TimeTick(DateTime(2024, 1, 5), NaN),
+ TimeTick(DateTime(2024, 1, 6), 2.5),
+ TimeTick(DateTime(2024, 1, 7), 3.5),
+ TimeTick(DateTime(2024, 1, 15), 4.5),
+ ]),
+ )
+
+ @test isequal(
+ ta_rolling(maximum, ta_for_window, 4),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1), NaN),
+ TimeTick(DateTime(2024, 1, 2), NaN),
+ TimeTick(DateTime(2024, 1, 5), NaN),
+ TimeTick(DateTime(2024, 1, 6), 4.0),
+ TimeTick(DateTime(2024, 1, 7), 5.0),
+ TimeTick(DateTime(2024, 1, 15), 6.0),
+ ]),
+ )
+
+ @test isequal(
+ ta_rolling(minimum, ta_for_window, 4),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1), NaN),
+ TimeTick(DateTime(2024, 1, 2), NaN),
+ TimeTick(DateTime(2024, 1, 5), NaN),
+ TimeTick(DateTime(2024, 1, 6), 1.0),
+ TimeTick(DateTime(2024, 1, 7), 2.0),
+ TimeTick(DateTime(2024, 1, 15), 3.0),
+ ]),
+ )
+
+ @test isequal(
+ ta_rolling(first, ta_for_window, 4),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1), NaN),
+ TimeTick(DateTime(2024, 1, 2), NaN),
+ TimeTick(DateTime(2024, 1, 5), NaN),
+ TimeTick(DateTime(2024, 1, 6), 1.0),
+ TimeTick(DateTime(2024, 1, 7), 2.0),
+ TimeTick(DateTime(2024, 1, 15), 3.0),
+ ]),
+ )
+
+ @test isequal(
+ ta_rolling(last, ta_for_window, 4),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1), NaN),
+ TimeTick(DateTime(2024, 1, 2), NaN),
+ TimeTick(DateTime(2024, 1, 5), NaN),
+ TimeTick(DateTime(2024, 1, 6), 4.0),
+ TimeTick(DateTime(2024, 1, 7), 5.0),
+ TimeTick(DateTime(2024, 1, 15), 6.0),
+ ]),
+ )
+
+ @test isequal(
+ ta_rolling(median, ta_for_window, 4),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1), NaN),
+ TimeTick(DateTime(2024, 1, 2), NaN),
+ TimeTick(DateTime(2024, 1, 5), NaN),
+ TimeTick(DateTime(2024, 1, 6), 2.5),
+ TimeTick(DateTime(2024, 1, 7), 3.5),
+ TimeTick(DateTime(2024, 1, 15), 4.5),
+ ]),
+ )
+
+ @test isequal(
+ ta_rolling(std, ta_for_window, 4),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1), NaN),
+ TimeTick(DateTime(2024, 1, 2), NaN),
+ TimeTick(DateTime(2024, 1, 5), NaN),
+ TimeTick(DateTime(2024, 1, 6), 1.2909944487358056),
+ TimeTick(DateTime(2024, 1, 7), 1.2909944487358056),
+ TimeTick(DateTime(2024, 1, 15), 1.2909944487358056),
+ ]),
+ )
+ end
+
+ @testset "Case №2: Periodic window" begin
+ ta_for_window = TimeArray([
+ TimeTick(DateTime(2024, 1, 1), 1.0),
+ TimeTick(DateTime(2024, 1, 2), 2.0),
+ TimeTick(DateTime(2024, 1, 5), 3.0),
+ TimeTick(DateTime(2024, 1, 6), 4.0),
+ TimeTick(DateTime(2024, 1, 7), 5.0),
+ TimeTick(DateTime(2024, 1, 15), 6.0),
+ ])
+
+ @test isequal(
+ ta_rolling(sum, ta_for_window, Day(4)),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1), NaN),
+ TimeTick(DateTime(2024, 1, 2), 3.0),
+ TimeTick(DateTime(2024, 1, 5), 5.0),
+ TimeTick(DateTime(2024, 1, 6), 7.0),
+ TimeTick(DateTime(2024, 1, 7), 12.0),
+ TimeTick(DateTime(2024, 1, 15), 6.0),
+ ]),
+ )
+
+ @test isequal(
+ ta_rolling(mean, ta_for_window, Day(4)),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1), NaN),
+ TimeTick(DateTime(2024, 1, 2), 1.5),
+ TimeTick(DateTime(2024, 1, 5), 2.5),
+ TimeTick(DateTime(2024, 1, 6), 3.5),
+ TimeTick(DateTime(2024, 1, 7), 4.0),
+ TimeTick(DateTime(2024, 1, 15), 6.0),
+ ]),
+ )
+
+ @test isequal(
+ ta_rolling(maximum, ta_for_window, Day(4)),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1), NaN),
+ TimeTick(DateTime(2024, 1, 2), 2.0),
+ TimeTick(DateTime(2024, 1, 5), 3.0),
+ TimeTick(DateTime(2024, 1, 6), 4.0),
+ TimeTick(DateTime(2024, 1, 7), 5.0),
+ TimeTick(DateTime(2024, 1, 15), 6.0),
+ ]),
+ )
+
+ @test isequal(
+ ta_rolling(minimum, ta_for_window, Day(4)),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1), NaN),
+ TimeTick(DateTime(2024, 1, 2), 1.0),
+ TimeTick(DateTime(2024, 1, 5), 2.0),
+ TimeTick(DateTime(2024, 1, 6), 3.0),
+ TimeTick(DateTime(2024, 1, 7), 3.0),
+ TimeTick(DateTime(2024, 1, 15), 6.0),
+ ]),
+ )
+
+ @test isequal(
+ ta_rolling(first, ta_for_window, Day(4)),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1), NaN),
+ TimeTick(DateTime(2024, 1, 2), 1.0),
+ TimeTick(DateTime(2024, 1, 5), 2.0),
+ TimeTick(DateTime(2024, 1, 6), 3.0),
+ TimeTick(DateTime(2024, 1, 7), 3.0),
+ TimeTick(DateTime(2024, 1, 15), 6.0),
+ ]),
+ )
+
+ @test isequal(
+ ta_rolling(last, ta_for_window, Day(4)),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1), NaN),
+ TimeTick(DateTime(2024, 1, 2), 2.0),
+ TimeTick(DateTime(2024, 1, 5), 3.0),
+ TimeTick(DateTime(2024, 1, 6), 4.0),
+ TimeTick(DateTime(2024, 1, 7), 5.0),
+ TimeTick(DateTime(2024, 1, 15), 6.0),
+ ]),
+ )
+
+ @test isequal(
+ ta_rolling(median, ta_for_window, Day(4)),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1), NaN),
+ TimeTick(DateTime(2024, 1, 2), 1.5),
+ TimeTick(DateTime(2024, 1, 5), 2.5),
+ TimeTick(DateTime(2024, 1, 6), 3.5),
+ TimeTick(DateTime(2024, 1, 7), 4.0),
+ TimeTick(DateTime(2024, 1, 15), 6.0),
+ ]),
+ )
+
+ @test isequal(
+ ta_rolling(std, ta_for_window, Day(4)),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1), NaN),
+ TimeTick(DateTime(2024, 1, 2), 0.7071067811865476),
+ TimeTick(DateTime(2024, 1, 5), 0.7071067811865476),
+ TimeTick(DateTime(2024, 1, 6), 0.7071067811865476),
+ TimeTick(DateTime(2024, 1, 7), 1.0),
+ TimeTick(DateTime(2024, 1, 15), NaN),
+ ]),
+ )
+ end
+
+ @testset "Case №3: SMA" begin
+ sma_date = TimeArray([
+ TimeTick(DateTime(2021, 7), 1.0),
+ TimeTick(DateTime(2021, 12), 2.0),
+ TimeTick(DateTime(2022, 2), 3.0),
+ TimeTick(DateTime(2023, 3), 4.0),
+ TimeTick(DateTime(2023, 4), 5.0),
+ TimeTick(DateTime(2024, 6), 6.0),
+ ])
+
+ @test isequal(
+ ta_sma(sma_date, 2),
+ TimeArray([
+ TimeTick(DateTime(2021, 7), NaN),
+ TimeTick(DateTime(2021, 12), 1.5),
+ TimeTick(DateTime(2022, 2), 2.5),
+ TimeTick(DateTime(2023, 3), 3.5),
+ TimeTick(DateTime(2023, 4), 4.5),
+ TimeTick(DateTime(2024, 6), 5.5),
+ ]),
+ )
+
+ @test isequal(
+ ta_sma(sma_date, 4),
+ TimeArray([
+ TimeTick(DateTime(2021, 7), NaN),
+ TimeTick(DateTime(2021, 12), NaN),
+ TimeTick(DateTime(2022, 2), NaN),
+ TimeTick(DateTime(2023, 3), 2.5),
+ TimeTick(DateTime(2023, 4), 3.5),
+ TimeTick(DateTime(2024, 6), 4.5),
+ ]),
+ )
+
+ @test isequal(
+ ta_sma(sma_date, Month(6)),
+ TimeArray([
+ TimeTick(DateTime(2021, 7), NaN),
+ TimeTick(DateTime(2021, 12), 1.5),
+ TimeTick(DateTime(2022, 2), 2.5),
+ TimeTick(DateTime(2023, 3), 4.0),
+ TimeTick(DateTime(2023, 4), 4.5),
+ TimeTick(DateTime(2024, 6), 6.0),
+ ]),
+ )
+
+ @test isequal(
+ ta_sma(sma_date, Year(1)),
+ TimeArray([
+ TimeTick(DateTime(2021, 7), NaN),
+ TimeTick(DateTime(2021, 12), NaN),
+ TimeTick(DateTime(2022, 2), 2.0),
+ TimeTick(DateTime(2023, 3), 4.0),
+ TimeTick(DateTime(2023, 4), 4.5),
+ TimeTick(DateTime(2024, 6), 6.0),
+ ]),
+ )
+ end
+
+ @testset "Case №4: Lag" begin
+ ta_for_lag = TimeArray([
+ TimeTick(DateTime(2024, 1, 1), 1.0),
+ TimeTick(DateTime(2024, 1, 2), 2.0),
+ TimeTick(DateTime(2024, 1, 3), 3.0),
+ TimeTick(DateTime(2024, 1, 4), 4.0),
+ TimeTick(DateTime(2024, 1, 5), 5.0),
+ TimeTick(DateTime(2024, 1, 6), 6.0),
+ ])
+
+ @test isequal(
+ ta_lag(ta_for_lag, 3),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1), NaN),
+ TimeTick(DateTime(2024, 1, 2), NaN),
+ TimeTick(DateTime(2024, 1, 3), NaN),
+ TimeTick(DateTime(2024, 1, 4), 1.0),
+ TimeTick(DateTime(2024, 1, 5), 2.0),
+ TimeTick(DateTime(2024, 1, 6), 3.0),
+ ]),
+ )
+
+ @test isequal(
+ ta_lag(ta_for_lag, 10),
+ TimeArray([
+ TimeTick(DateTime(2024, 1, 1), NaN),
+ TimeTick(DateTime(2024, 1, 2), NaN),
+ TimeTick(DateTime(2024, 1, 3), NaN),
+ TimeTick(DateTime(2024, 1, 4), NaN),
+ TimeTick(DateTime(2024, 1, 5), NaN),
+ TimeTick(DateTime(2024, 1, 6), NaN),
+ ]),
+ )
+ end
+end
diff --git a/test/runtests.jl b/test/runtests.jl
new file mode 100644
index 0000000..6daf159
--- /dev/null
+++ b/test/runtests.jl
@@ -0,0 +1,14 @@
+# runtests
+
+using Test
+using Dates
+using NanoDates
+using Statistics
+using TimeArrays
+
+include("interface.jl")
+include("math.jl")
+include("array.jl")
+include("rolling.jl")
+include("resample.jl")
+include("custom_type.jl")
+
+
+Visualized with [LightweightCharts.jl](https://github.com/bhftbootcamp/LightweightCharts.jl).
+
+
+Visualized with [LightweightCharts.jl](https://github.com/bhftbootcamp/LightweightCharts.jl).
+
+
+Visualized with [LightweightCharts.jl](https://github.com/bhftbootcamp/LightweightCharts.jl).
+
+```
+
+# TimeArrays.jl
+
+TimeArrays simplifies working with time series data. It offers features like basic math operations, sliding window techniques, data resampling, and handling of missing values.
+
+## Installation
+To install TimeArrays, simply use the Julia package manager:
+
+```julia
+] add TimeArrays
+```
+
+## Usage
+
+In this example we perform math operations on several sets of time series.
+
+```julia
+using Dates
+using TimeArrays
+
+a = TimeArray{DateTime,Float64}([
+ TimeTick(DateTime("2024-01-01"), 1.0),
+ TimeTick(DateTime("2024-01-02"), 4.0),
+ TimeTick(DateTime("2024-01-05"), 2.0),
+ TimeTick(DateTime("2024-01-07"), 5.0),
+])
+
+b = TimeArray{DateTime,Float64}([
+ (DateTime("2024-01-02"), 4.0),
+ (DateTime("2024-01-06"), 2.0),
+ (DateTime("2024-01-10"), 1.0),
+])
+
+c = TimeArray{DateTime,Float64}([
+ DateTime("2024-01-01") => 2.0,
+ DateTime("2024-01-09") => 5.0,
+ DateTime("2024-01-11") => 4.0,
+])
+
+julia> 2(a * b) + b / c
+8-element TimeArray{DateTime, Float64}:
+ TimeTick(2024-01-01T00:00:00, NaN)
+ TimeTick(2024-01-02T00:00:00, 34.0)
+ ⋮
+ TimeTick(2024-01-11T00:00:00, 10.25)
+```
+
+!!! note
+ Since our implementation of arithmetic operations between elements of two TimeArray's is somewhat different from the usual work with arrays, a diagram is provided below that shows how exactly the elements of the time series are related to each other. For more information see [arithmetic section](https://bhftbootcamp.github.io/TimeArrays.jl/stable/pages/arithmetic/) in documentation.
+
+```@raw html
+
+
+Visualized with LightweightCharts.jl.
+
+
+Visualized with LightweightCharts.jl.
+
+
+Visualized with LightweightCharts.jl.
+