-
Notifications
You must be signed in to change notification settings - Fork 34
/
time.jl
81 lines (62 loc) · 2.33 KB
/
time.jl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#
# Types supporting parameterized Timestep and Clock objects
#
abstract type AbstractTimestep <: MimiStruct end
struct FixedTimestep{FIRST, STEP, LAST} <: AbstractTimestep
t::Int
end
struct VariableTimestep{TIMES} <: AbstractTimestep
t::Int
current::Int
function VariableTimestep{TIMES}(t::Int = 1) where {TIMES}
# The special case below handles when functions like next_step step beyond
# the end of the TIMES array. The assumption is that the length of this
# last timestep, starting at TIMES[end], is 1.
current::Int = t > length(TIMES) ? TIMES[end] + 1 : TIMES[t]
return new(t, current)
end
end
"""
TimestepValue
A user-facing type used to index into a `TimestepArray` in `run_timestep` functions,
containing a `value` of the same Type as the times in the `TimstepArray` which is used to
index into the array at that position, with an optional Int `offset` in terms of timesteps.
"""
struct TimestepValue{T}
value::T
offset::Int
function TimestepValue(v::T; offset::Int = 0) where T
return new{T}(v, offset)
end
end
"""
TimestepIndex
A user-facing type used to index into a `TimestepArray` in `run_timestep` functions,
containing an Int `index` that indicates the position in the array in terms of timesteps.
"""
struct TimestepIndex
index::Int
end
mutable struct Clock{T <: AbstractTimestep} <: MimiStruct
ts::T
function Clock{T}(FIRST::Int, STEP::Int, LAST::Int) where T
return new(FixedTimestep{FIRST, STEP, LAST}(1))
end
function Clock{T}(TIMES::NTuple{N, Int} where N) where T
return new(VariableTimestep{TIMES}())
end
end
mutable struct TimestepArray{T_TS <: AbstractTimestep, T, N, ti, S<:AbstractArray{T,N}} <: MimiStruct
data::S
function TimestepArray{T_TS, T, N, ti}(d::S) where {T_TS, T, N, ti, S}
return new{T_TS, T, N, ti, S}(d)
end
end
function TimestepArray{T_TS, T, N, ti}(lengths::Int...) where {T_TS, T, N, ti}
return TimestepArray{T_TS, T, N, ti}(Array{T, N}(undef, lengths...))
end
# Since these are the most common cases, we define methods (in time.jl)
# specific to these type aliases, avoiding some of the inefficiencies
# associated with an arbitrary number of dimensions.
const TimestepMatrix{T_TS, T, ti} = TimestepArray{T_TS, T, 2, ti}
const TimestepVector{T_TS, T} = TimestepArray{T_TS, T, 1, 1}