licenses
sequencelengths 1
3
| version
stringclasses 677
values | tree_hash
stringlengths 40
40
| path
stringclasses 1
value | type
stringclasses 2
values | size
stringlengths 2
8
| text
stringlengths 25
67.1M
| package_name
stringlengths 2
41
| repo
stringlengths 33
86
|
|---|---|---|---|---|---|---|---|---|
[
"MPL-2.0"
] | 0.2.21 | 693005fe9ead5e4a74af9fb943e7c37ff635ef08 | docs | 487 | [](https://github.com/Circo-dev/CircoCore.jl/actions/workflows/ci.yml)
[](http://codecov.io/github/Circo-dev/CircoCore.jl?branch=master)
CircoCore.jl is the small inner core of the Circo decentralized actor system.
As a normal user you probably want to check out the main repo: https://github.com/Circo-dev/Circo
| CircoCore | https://github.com/Circo-dev/CircoCore.jl.git |
|
[
"MPL-2.0"
] | 0.2.21 | 693005fe9ead5e4a74af9fb943e7c37ff635ef08 | docs | 593 | # Introducing CircoCore.jl
CircoCore.jl is the small inner core of the [Circo](https://github.com/Circo-dev/Circo) actor system.
You may want to use the full-featured system directly.
CircoCore.jl provides a single-threaded actor scheduler with a powerful plugin architecture, plus a few plugins to serve
minimalistic use cases.
Circo extends this system with plugins that provide multithreading, clustering, debugging, interoperability and more.
The main goal of separating these packages is to allow alternative implementations of the high level functionality. (like kernel and distros) | CircoCore | https://github.com/Circo-dev/CircoCore.jl.git |
|
[
"MPL-2.0"
] | 0.2.21 | 693005fe9ead5e4a74af9fb943e7c37ff635ef08 | docs | 67 | # Reference
```@index
```
```@autodocs
Modules = [CircoCore]
```
| CircoCore | https://github.com/Circo-dev/CircoCore.jl.git |
|
[
"MIT"
] | 1.0.3 | 59b6e9c5d3148a8d5cf2693725cd20e1b45a8e9f | code | 643 | using CryptoMarketData
using Documenter
DocMeta.setdocmeta!(CryptoMarketData, :DocTestSetup, :(using CryptoMarketData); recursive=true)
makedocs(;
modules=[CryptoMarketData],
authors="contributors",
sitename="CryptoMarketData.jl",
format=Documenter.HTML(;
canonical="https://g-gundam.github.io/CryptoMarketData.jl",
edit_link="main",
assets=String[],
),
pages=[
"Home" => "index.md",
"API" => "api.md",
"Exchanges" => "exchanges.md",
"Examples" => "examples.md"
],
)
deploydocs(;
repo="github.com/g-gundam/CryptoMarketData.jl",
devbranch="main",
)
| CryptoMarketData | https://github.com/g-gundam/CryptoMarketData.jl.git |
|
[
"MIT"
] | 1.0.3 | 59b6e9c5d3148a8d5cf2693725cd20e1b45a8e9f | code | 13433 | module CryptoMarketData
using URIs
using HTTP
using JSON3
using TimeZones
using Dates
using NanoDates
using DataStructures
using DocStringExtensions
using CSV
using DataFrames
using DataFramesMeta
# Every exchange implements its own subtype of these.
abstract type AbstractExchange end
abstract type AbstractCandle end
# This is used to contain WebSocket sessions and interact with them.
# It's generic and can be used for any exchange.
@kwdef mutable struct Session
url::URI
commands::Union{Channel, Missing}
messages::Union{Channel, Missing}
ws::Union{HTTP.WebSocket, Missing}
task::Union{Task, Missing}
end
# Include NHDaly/Select locally.
# It may be old and unmaintained, but I like the way it works.
# When a better way to wait on multiple channels appears, I'll switch.
include("Select.jl")
# unexported utility functions
include("helpers.jl")
# exported exchange-specific structures and methods
include("exchanges/binance.jl") # DONE
include("exchanges/bitget.jl") # DONE
include("exchanges/bitmex.jl") # DONE
include("exchanges/bitstamp.jl") # DONE
include("exchanges/bybit.jl") # DONE
include("exchanges/pancakeswap.jl") # DONE
# general functions
export get_saved_markets
# general functions that operate on exchanges
export save!
export load
export earliest_candle
export get_candles_for_day
export save_day!
# functions with exchange-specific methods
export csv_headers
export csv_select
export ts2datetime_fn
export candle_datetime
export short_name
export candles_max
export get_markets
export get_candles
export subscribe
"""
get_markets(exchange)
Fetch the available markets for the given exchange.
# Example
```julia-repl
julia> bitstamp = Bitstamp()
julia> markets = get_markets(bitstamp)
```
"""
CryptoMarketData.get_markets(exchange)
"""
subscribe(url::String)
This is a convenience method that accepts URLs as strings.
"""
function subscribe(url::String)
uri = URI(url)
subscribe(uri)
end
"""
subscribe(uri::URI)
This is the general version of websocket subscription that the other exchange-specific
versions of subscribe are built on. It connects to the given uri and returns a struct
that contains two Channels that can be used to interact with the WebSocket.
# Example
```julia-repl
julia> using URIs, JSON3
julia> s = subscribe(URI("wss://ws.bitstamp.net"))
CryptoMarketData.Session(URI("wss://ws.bitstamp.net"), missing, missing, missing, Task (runnable) @0x00007970dac63d00)
julia> btcusd_subscribe = Dict(:event => "bts:subscribe", :data => Dict(:channel => "live_trades_btcusd"))
Dict{Symbol, Any} with 2 entries:
:event => "bts:subscribe"
:data => Dict(:channel=>"live_trades_btcusd")
julia> put!(s.commands, JSON3.write(btcusd_subscribe))
"{\"event\":\"bts:subscribe\",\"data\":{\"channel\":\"live_trades_btcusd\"}}"
julia> s.messages
Channel{Any}(32) (2 items available)
julia> take!(s.messages)
"{\"event\":\"bts:subscription_succeeded\",\"channel\":\"live_trades_btcusd\",\"data\":{}}"
julia> JSON3.read(take!(s.messages))
JSON3.Object{Base.CodeUnits{UInt8, String}, Vector{UInt64}} with 3 entries:
:data => {…
:channel => "live_trades_btcusd"
:event => "trade"
```
"""
function subscribe(uri::URI)
session = Session(uri, missing, missing, missing, missing)
handler = function (ws)
session.ws = ws
session.commands = Channel(32)
session.messages = Channel(32) do ch
while true
msg = WebSockets.receive(ws)
put!(ch, msg)
end
end
try
while true
command = take!(session.commands)
WebSockets.send(session.ws, command)
end
catch e
@warn "exception, restart"
sleep(0.10) # TODO: debounce the websocket reconnection
session.task = Threads.@spawn WebSockets.open(handler, uri)
end
end
session.task = Threads.@spawn WebSockets.open(handler, uri)
return session
end
"""
$(SIGNATURES)
Return a DataFrame that lists the currently saved markets.
# Keyword Arguments
* datadir="./data" - directory where saved data is stored
# Example
```julia-repl
julia> saved = get_saved_markets()
10×4 DataFrame
Row │ exchange market start stop
│ Any Any Any Any
─────┼───────────────────────────────────────────────────────
1 │ binance BTCUSD_240628 2023-12-29 2024-02-17
2 │ binance BTCUSD_PERP 2020-08-11 2020-08-16
3 │ bitget BTCUSD_DMCBL 2019-04-23 2024-02-16
4 │ bitget DOGEUSD_DMCBL 2024-02-01 2024-02-20
5 │ bitmex ETHUSD 2018-08-02 2024-02-19
6 │ bitstamp BTCUSD 2011-08-18 2024-02-25
7 │ bybit ADAUSD 2022-03-24 2022-04-21
8 │ bybit-inverse ADAUSD 2022-03-24 2022-04-20
9 │ bybit-linear 10000LADYSUSDT 2023-05-11 2024-03-04
10 │ pancakeswap BTCUSD 2023-03-15 2024-03-04
```
"""
function get_saved_markets(; datadir="./data")
@debug "datadir" datadir
df = DataFrame(exchange=[], market=[], start=[], stop=[])
exchanges = readdir(datadir)
for ex in exchanges
markets = readdir("$(datadir)/$(ex)")
for mk in markets
csv_a = first_csv("$(datadir)/$(ex)/$(mk)")
csv_b = last_csv("$(datadir)/$(ex)/$(mk)")
start = if ismissing(csv_a)
missing
else
_filename_to_date(csv_a)
end
stop = if ismissing(csv_b)
missing
else
_filename_to_date(csv_b)
end
df = vcat(df, DataFrame(exchange=[ex], market=[mk], start=[start], stop=[stop]))
end
end
return df
end
"""
$(SIGNATURES)
Download 1m candles from the given exchange and market, and save them locally.
# Keyword Arguments
* datadir="./data" - directory where saved data is stored
* startday - a `Date` to start fetching candles from
* endday - a `Date` to stop fetching candles
* delay - a delay to be passed to `sleep()` that will pause between internal calls to `save_day!()`
# Example
```julia-repl
julia> bitstamp = Bitstamp()
julia> save!(bitstamp, "BTC/USD", endday=Date("2020-08-16"))
```
"""
function save!(exchange::AbstractExchange, market; datadir="./data", startday=missing, endday=today(tz"UTC"), delay=0.5)
# make directories if they don't already exist
outdir = joinpath(datadir, short_name(exchange), replace(market, "/" => ""))
mkpath(outdir)
# figure out what day we're on
csv_name = last_csv(outdir)
current_day = missing
if !ismissing(startday)
current_day = Date(startday)
elseif ismissing(csv_name)
first_candle = earliest_candle(exchange, market)
current_day = Date(candle_datetime(first_candle))
else
csv_date = Date(replace(csv_name, ".csv" => ""))
lines = countlines(joinpath(outdir, csv_name))
if lines > 1440
current_day = csv_date + Dates.Day(1)
else
current_day = csv_date
end
end
while current_day <= endday
cs = get_candles_for_day(exchange, market, current_day)
@info current_day length(cs)
save_day!(exchange, market, cs)
current_day = current_day + Dates.Day(1)
sleep(delay)
end
end
"""
save_day!(exchange, market, candles; datadir="./data")
Save a day worth of 1m candles the caller provides for the
given exchange and market.
# Keyword Arguments
* datadir="./data" - directory where saved data is stored
"""
function save_day!(exchange::AbstractExchange, market, candles; datadir="./data")
current_day = Date(candle_datetime(candles[1]))
outdir = joinpath(datadir, short_name(exchange), replace(market, "/" => ""))
outfile = outdir * "/" * Dates.format(current_day, "yyyy-mm-dd") * ".csv"
CSV.write(outfile, candles |> DataFrame)
end
"""
earliest_candle(exchange, market)
Return the earliest candle for the given market in the 1m timeframe.
"""
function earliest_candle(exchange::AbstractExchange, market; endday=today(tz"UTC"))
# starting from the current day
stop = DateTime(endday)
max = candles_max(exchange; tf=Day(1))
start = stop - Dates.Day(max)
candles = missing
# grab as many (large timeframe like 1d) candles as is allowed and
while true
@debug "ec" start stop
candles = get_candles(exchange, market; tf=Day(1), start=start, stop=stop, limit=max)
length(candles) == max || break
stop = start
start = stop - Dates.Day(max)
end
@debug "after 1d"
# work backwards until a result with fewer items than the limit is reached.
# go to the earliest day
first_day = floor(candle_datetime(candles[1]), Dates.Day)
half_way = first_day + Dates.Hour(12)
end_of_day = half_way + Dates.Hour(12)
# there are 1440 minutes in a day.
# grab 720 candles
# XXX :: hopefully candles_max(exchange) > 720
@debug "1m" first_day (:start => half_way) (:stop => end_of_day)
candles2 = get_candles(exchange, market; tf=Minute(1), start=half_way, stop=end_of_day - Minute(1), limit=720)
# start at later half of the day
# if less than 720 returned, we've found the earliest candle
if length(candles2) < 720
@debug "< 720" length(candles2)
return candles2[1]
else
# if not, go to earlier half of the day
# grab 720 more candles
@debug ">= 720" first_day half_way
candles3 = get_candles(exchange, market; tf=Minute(1), start=first_day, stop=half_way - Minute(1), limit=720)
if length(candles3) == 0
@debug "length(candles3) == 0"
return candles2[1]
else
@debug "ok" length(candles3) length(candles2)
return candles3[1]
end
end
# it better be less than 720 returned and earliest candle found
# if not? there's a bug.
end
"""
get_candles_for_day(exchange, market, day::Date)
Fetch all of the 1m candles for the given exchange, market, and day.
The vector and candles returned is just the right size to save to the archives.
"""
function get_candles_for_day(exchange::AbstractExchange, market, day::Date)
limit = candles_max(exchange) # tf exists to get around a special case for binance
n_reqs = convert(Int64, ceil(1440 / limit)) # number of requests
l_preq = convert(Int64, 1440 / n_reqs) # limit per request
candles = []
current_ts = DateTime(day)
stop_ts = current_ts + Dates.Minute(l_preq - 1)
for _ in 1:n_reqs
c = get_candles(exchange, market; start=current_ts, stop=stop_ts, limit=l_preq)
append!(candles, c)
current_ts = stop_ts + Dates.Minute(1)
stop_ts = current_ts + Dates.Minute(l_preq - 1)
end
candles
end
"""
$(SIGNATURES)
Load candles for the given exchange and market from the file system.
# Keyword Arguments
* datadir="./data" - directory where saved data is stored
* span - a `Date` span that defines what Dates to load candles. If it's `missing`, load everything.
* tf - a `Period` that is used to aggregate 1m candles into higher timeframes.
* table - a Tables.jl-compatible struct to load candles into. The default is `DataFrame`.
# Example
```julia-repl
julia> bitstamp = Bitstamp()
julia> btcusd4h = load(bitstamp, "BTC/USD"; span=Date("2024-01-01"):Date("2024-02-10"), tf=Hour(4))
```
"""
function load(exchange::AbstractExchange, market; datadir="./data", span=missing, tf::Union{Period,Missing}=missing, table=DataFrame)
indir = joinpath(datadir, short_name(exchange), replace(market, "/" => ""))
cfs = readdir(indir; join=true)
if !ismissing(span)
if typeof(span) <: UnitRange
cfs = cfs[span]
elseif typeof(span) <: StepRange
# convert span to UnitRange
a = _d2i(first(span), cfs)
b = _d2i(last(span), cfs)
cfs = cfs[range(a, b)]
end
end
res = missing
headers = csv_headers(exchange)
select = csv_select(exchange)
#csv_read = (cf) -> CSV.read(cf, table; headers=headers, select=select, skipto=2)
for cf in cfs
csv = CSV.read(cf, table; header=headers, select=select, skipto=2)
csv[!, :ts] = map(ts2datetime_fn(exchange), csv[!, :ts])
if ismissing(res)
res = csv
else
append!(res, csv)
end
end
# Do optional timeframe summarization
if ismissing(tf)
return res
else
return @chain res begin
@transform(:ts2 = floor.(:ts, tf))
groupby(:ts2) # LSP doesn't know the @chain macro is doing magic.
@combine begin
:o = first(:o)
:h = maximum(:h)
:l = minimum(:l)
:c = last(:c)
:v = sum(:v)
end
@select(:ts = :ts2, :o, :h, :l, :c, :v)
end
end
end
end
#=
using CryptoMarketData
using DataFrames
using DataFramesMeta
using NanoDates
using Dates
1 + 1
b = 9
c = 9
markets = get_saved_markets()
pancakeswap = PancakeSwap()
bitstamp = Bitstamp()
btcusd = load(bitstamp, "BTCUSD"; tf=Minute(1), span=Date("2024-01-01"):Date("2024-01-02"))
s = subscribe(pancakeswap) # s for websocket session
=#
| CryptoMarketData | https://github.com/g-gundam/CryptoMarketData.jl.git |
|
[
"MIT"
] | 1.0.3 | 59b6e9c5d3148a8d5cf2693725cd20e1b45a8e9f | code | 20048 | module Select
using Nullables
export @select
# =========================================================================================
# Custom concurrency primitives needed to support `@select`
# ------------------
function isready_put(c::Channel, sibling_tasks)
# TODO: To fix the circular dependency, I think it might be enough to just add a check
# here that there is at least one ready task that _isn't_ one of our siblings! We can
# take another argument to this function, which is the list of tasks, and cross-reference it?
return if Base.isbuffered(c)
length(c.data) != c.sz_max
else
# TODO: No this isn't enough. I need to do it for the _wait_ function, not the wait_put. :'(
#@info sibling_tasks
#@info "isready_put:" (!isempty(c.cond_take.waitq))#, collect(c.cond_take.waitq))
!isempty(c.cond_take.waitq) && any(t->!in(t, sibling_tasks), c.cond_take.waitq)
end
end
function wait_put(c::Channel, sibling_tasks)
#isready_put(c, sibling_tasks) && return
# TODO: Is this sufficiently thread-safe?
lock(c)
try
while !isready_put(c, sibling_tasks)
Base.check_channel_state(c)
wait(c.cond_put) # Can be cancelled while waiting here...
end
finally
unlock(c)
end
nothing
end
isready_wait_nosibs(c::Channel, sibling_tasks) = n_avail_nosibs(c, sibling_tasks) > 0
function n_avail_nosibs(c::Channel, sibling_tasks)
if Base.isbuffered(c)
length(c.data)
else
#@info "isready_wait_nosibs:" (isempty(c.cond_put.waitq), collect(c.cond_put.waitq))
length(filter(t->0==count(x->x==t, sibling_tasks), collect(c.cond_put.waitq)))
end
end
function wait_nosibs(c::Channel, sibling_tasks)
# I don't understand why its okay to access this outside the lock...?
#isready_wait_nosibs(c, sibling_tasks) && return
lock(c)
try
while !isready_wait_nosibs(c, sibling_tasks)
Base.check_channel_state(c)
wait(c.cond_wait)
end
finally
unlock(c)
end
nothing
end
wait_select(c::Channel, parent_task, sibling_tasks) = wait_nosibs(c, sibling_tasks)
wait_select(c::Base.GenericCondition, parent_task, sibling_tasks) = wait_from_parent(c, parent_task)
wait_select(x, parent_task, sibling_tasks) = wait(x)
# ---- Conditions ---------
assert_parent_haslock(c::Base.GenericCondition, parent_task) = assert_parent_haslock(c.lock, parent_task)
assert_parent_haslock(l::ReentrantLock, parent_task) =
(islocked(l) && l.locked_by === parent_task) ? nothing : Base.concurrency_violation()
assert_parent_haslock(l::Base.AlwaysLockedST, parent_task) =
(islocked(l) && l.ownertid === parent_task) ? nothing : Base.concurrency_violation()
function wait_from_parent(c::Base.GenericCondition, parent_task)
ct = current_task()
# Note that the parent task is guaranteed to be blocking on us, so this is okay.
assert_parent_haslock(c, parent_task)
push!(c.waitq, ct)
token = unlockall_from_parent(c.lock, parent_task)
try
return wait()
catch
ct.queue === nothing || Base.list_deletefirst!(ct.queue, ct)
rethrow()
finally
# Note that now _this task_ gets the lock, so we can execute the remaining body w/ the lock
Base.relockall(c.lock, token)
# eww, manually re-assign the parent to own this lock
c.lock.locked_by = parent_task
end
end
function unlockall_from_parent(rl::ReentrantLock, parent_task)
n = rl.reentrancy_cnt
rl.locked_by === parent_task || error("unlock from wrong thread")
n == 0 && error("unlock count must match lock count")
lock(rl.cond_wait)
rl.reentrancy_cnt = 0
rl.locked_by = nothing
if !isempty(rl.cond_wait.waitq)
try
notify(rl.cond_wait)
catch
unlock(rl.cond_wait)
rethrow()
end
end
unlock(rl.cond_wait)
return n
end
# =========================================================================================
## Implementation of 'select' mechanism to block on the disjunction of
## of 'waitable' objects.
@enum SelectClauseKind SelectPut SelectTake SelectDefault
# Represents a single parsed select "clause" of a @select macro call.
# eg, the (channel |> value) part of
# @select if channel |> value
# println(value)
# ...
# end
struct SelectClause{ChannelT, ValueT}
kind::SelectClauseKind
channel::Nullable{ChannelT}
value::Nullable{ValueT}
end
const select_take_symbol = :|>
const select_put_symbol = :<|
# A 'structured' select clause is one of the form "channel|>val" or
# "channel<|val". All other clauses are considered "non-structured", meaning
# the entire clause is assumed to be an expression that evaluates to a
# conditional to which "_take!" will be applied.
is_structured_select_clause(clause::Expr) =
clause.head == :call &&
length(clause.args) == 3 &&
clause.args[1] ∈ (select_take_symbol, select_put_symbol)
is_structured_select_clause(clause) = false
function parse_select_clause(clause)
if is_structured_select_clause(clause)
if clause.args[1] == select_take_symbol
SelectClause(SelectTake, Nullable(clause.args[2]), Nullable(clause.args[3]))
elseif clause.args[1] == select_put_symbol
SelectClause(SelectPut, Nullable(clause.args[2]), Nullable(clause.args[3]))
end
else
# Assume this is a 'take' clause whose return value isn't wanted.
# To simplify the rest of the code to not have to deal with this special case,
# the return value is assigned to a throw-away gensym.
SelectClause(SelectTake, Nullable(clause), Nullable(gensym()))
end
end
"""
`@select`
A select expression of the form:
```julia
@select begin
clause1 => body1
clause2 => body2
_ => default_body
end
end
```
Wait for multiple clauses simultaneously using a pattern matching syntax, taking a different action depending on which clause is available first.
A clause has three possible forms:
1) `event |> value`
If `event` is an `AbstractChannel`, wait for a value to become available in the channel and assign `take!(event)` to `value`.
if `event` is a `Task`, wait for the task to complete and assign `value` the return value of the task.
2) `event |< value`
Only suppored for `AbstractChannel`s. Wait for the channel to capabity to store an element, and then call `put!(event, value)`.
3) `event`
Calls `wait` on `event`, discarding the return value. Usable on any "waitable" events", which include channels, tasks, `Condition` objects, and processes.
If a default branch is provided, `@select` will check arbitrary choose any event which is ready and execute its body, or will execute `default_body` if none of them are.
Otherise, `@select` blocks until at least one event is ready.
For example,
```julia
channel1 = Channel()
channel2 = Channel()
task = @task ...
result = @select begin
channel1 |> value => begin
info("Took from channel1")
value
end
channel2 <| :test => info("Put :test into channel2")
task => info("task finished")
end
```
"""
macro select(expr)
clauses = Tuple{SelectClause, Any}[]
# @select can operate in blocking or nonblocking mode, determined by whether
# an 'else' clause is present in the @select body (in which case it will be
# nonblocking).
mode = :blocking
for se in expr.args
# skip line nodes
isa(se, Expr) || continue
# grab all the pairs
if se.head == :call && se.args[1] == :(=>)
if se.args[2] != :_
push!(clauses, (parse_select_clause(se.args[2]), se.args[3]))
else
# The defaule case (_). If present, the select
# statement is considered non-blocking and will return this
# section if none of the other conditions are immediately available.
push!(clauses, (SelectClause(SelectDefault, Nullable(), Nullable()), se.args[3]))
mode = :nonblocking
end
elseif se.head != :block && se.head != :line
# if we run into an expression that is not a block. line or pair throw an error
throw(ErrorException("Selection expressions must be Pairs. Found: $(se.head)"))
end
end
if mode == :nonblocking
_select_nonblock_macro(clauses)
else
_select_block_macro(clauses)
end
end
# These defintions allow for any condition-like object to be used
# with select.
# @select if x |> value ... will ultimately insert an expression value=_take!(x).
_take!(c::AbstractChannel) = take!(c)
_take!(x) = fetch(x)
# @select if x <| value .... will ultimately inset value=put!(x), which currently
# is only meanginful for channels and so no underscore varirant is used here.
# These are used with the non-blocking variant of select, which will
# only work with channels and tasks. Arbitrary conditionals can't be supported
# since "wait" is level-triggered.
_isready(c::AbstractChannel) = isready(c)
_isready(t::Task) = istaskdone(t)
_wait_condition(c::AbstractChannel) = c.cond_wait
_wait_condition(x) = x
# helper function to place the default case in the proper position
function set_default_first!(clauses)
default_pos = findall(clauses) do x
clause, body = x
clause.kind == SelectDefault
end
l = length(default_pos)
l == 0 && return # bail out if there is no default case
l > 1 && throw(ErrorException("Select takes at most one default case. Found: $l"))
# swap elements to sure make SelectDefault comes first
clauses[1], clauses[default_pos[1]] = clauses[default_pos[1]], clauses[1]
clauses
end
function _select_nonblock_macro(clauses)
set_default_first!(clauses)
branches = Expr(:block)
for (clause, body) in clauses
branch =
if clause.kind == SelectPut
channel_var = gensym("channel")
channel_assignment_expr = :($channel_var = $(clause.channel|>get|>esc))
:(if ($channel_assignment_expr; isready_put($channel_var, []))
put!($channel_var, $(clause.value|>get|>esc))
$(esc(body))
end)
elseif clause.kind == SelectTake
channel_var = gensym("channel")
channel_assignment_expr = :($channel_var = $(clause.channel|>get|>esc))
:(if ($channel_assignment_expr; _isready($channel_var))
$(clause.value|>get|>esc) = _take!($channel_var)
$(esc(body))
end)
elseif clause.kind == SelectDefault
:($(esc(body)))
end
# the next two lines build an if / elseif chain from the bottom up
push!(branch.args, branches)
branches = branch
end
:($branches)
end
# The strategy for blocking select statements is to create a set of "rival"
# tasks, one per condition. When a rival "wins" by having its conditional be
# the first available, it sends a special interrupt to its rivals to kill them.
# The interrupt includes the task where control should be resumed
# once the rival has shut itself down.
struct SelectInterrupt <: Exception
parent::Task
end
# Kill all tasks in "tasks" besides a given task. Used for killing the rivals
# of the winning waiting task.
function select_kill_rivals(tasks, myidx)
#@info myidx
for (taskidx, task) in enumerate(tasks)
taskidx == myidx && continue
#@info taskidx, task
#if task.state == :waiting || task.state == :queued
# Rival is blocked waiting for its channel; send it a message that it's
# lost the race.
Base.schedule(task, SelectInterrupt(current_task()), error=true)
# TODO: Is this still a legit optimization?:
# elseif task.state==:queued
# # Rival hasn't starting running yet and so hasn't blocked or set up
# # a try-catch block to listen for SelectInterrupt.
# # Just delete it from the workqueue.
# queueidx = findfirst(Base.Workqueue.==task)
# deleteat!(Base.Workqueue, queueidx)
# end
end
#@info "done killing"
end
function _select_block_macro(clauses)
branches = Expr(:block)
body_branches = Expr(:block)
clause_lock = gensym("clause_lock")
lock_assignment_expr = :($clause_lock = Base.ReentrantLock())
for (i, (clause, body)) in enumerate(clauses)
channel_var = gensym("channel")
value_var = clause.value|>get|>esc
channel_declaration_expr = :(local $channel_var)
channel_assignment_expr = :($channel_var = $(clause.channel|>get|>esc))
if clause.kind == SelectPut
isready_func = isready_put
wait_for_channel = :(wait_put($channel_var, tasks))
mutate_channel = :(put!($channel_var, $value_var))
bind_variable = :(nothing)
elseif clause.kind == SelectTake
isready_func = _isready
wait_for_channel = :(wait_select($channel_var, maintask, tasks))
mutate_channel = :(_take!($channel_var))
bind_variable = :($value_var = branch_val)
end
branch = quote
tasks[$i] = @async begin
$channel_declaration_expr
try # Listen for genuine errors to throw to the main task
$channel_assignment_expr
# ---- Begin the actual `wait_and_select` algorithm ----
# TODO: Is this sufficiently thread-safe?
# Listen for SelectInterrupt messages so we can shutdown
# if a rival's channel unblocks first.
try
#@info "Task $($i) about to wait"
$wait_for_channel
# TODO: Because of this gap, where no locks are held, it's possible
# that multiple tasks can be woken-up due to a `put!` or `take!` on
# a channel they were waiting for. Only once will proceed in this
# @select, but a channel running _outside this macro_ may yet proceed
# and cause a problem.. I think this is bad. Fix this (probably) by
# returning the lock to unlock from `wait_for_channel`.
# NOTE: This is _not a deadock_ because there is a global ordering
# to the locks: we _ALWAYS_ wait on the channel before waiting on
# the clause_lock. This invariant must not be violated.
#@info "Task $($i) about to lock"
lock($clause_lock)
# We got the lock, so run this task to completion.
try
#@info "Task $($i): got lock"
# This block is atomic, so it _shouldn't_ matter whether we kill
# rivals first or mutate_channel first. It only matters if one
# case is accidentally synchronizing w/ another case, which
# should be specifically prohibited (somehow).
# For now, I'm killing rivals first so that at least we'll get
# an exception, rather than a deadlock, if we end up waiting on
# our rival, sibling cases.
#@info "Task $($i): killing rivals"
select_kill_rivals(tasks, $i)
#@info "Task $($i): mutating"
event_val = $mutate_channel
#@info "Got event_val: $event_val"
put!(winner_ch, ($i, event_val))
finally
#@info "Task $($i)) unlock"
unlock($clause_lock)
end
catch err
if isa(err, SelectInterrupt)
#@info "CAUGHT SelectInterrupt: $err"
#yieldto(err.parent) # TODO: is this still a thing we should do?
return
else
rethrow()
end
end
catch err
Base.throwto(maintask, err)
end
end # if
end # for
push!(branches.args, branch)
body_branch = :(if branch_id == $i; $bind_variable; $(esc(body)); end)
# the next two lines build an if / elseif chain from the bottom up
push!(body_branch.args, body_branches)
body_branches = body_branch
end
quote
winner_ch = Channel(1)
tasks = Array{Task}(undef, $(length(clauses)))
maintask = current_task()
$lock_assignment_expr
$branches # set up competing tasks
(branch_id, branch_val) = take!(winner_ch) # get the id of the winning task
$body_branches # execute the winning block in the original lexical context
end
end
# The following methods are the functional (as opposed to macro) forms of
# the select statement.
function _select_nonblock(clauses)
for (i, clause) in enumerate(clauses)
if clause[1] == :put
if isready_put(clause[2], [])
return (i, put!(clause[2], clause[3]))
end
elseif clause[1] == :take
if _isready(clause[2])
return (i, _take!(clause[2]))
end
else
error("Invalid select clause: $clause")
end
end
return (0, nothing)
end
function _select_block(clauses)
winner_ch = Channel{Tuple{Int, Any}}(1)
tasks = Array{Task}(undef, length(clauses))
maintask = current_task()
for (i, clause) in enumerate(clauses)
tasks[i] = Threads.@spawn begin
try
try
if clause[1] == :put
wait_put(clause[2], tasks)
elseif clause[1] == :take
wait_select(clause[2], maintask, tasks)
end
catch err
if isa(err, SelectInterrupt)
yieldto(err.parent)
return
else
rethrow()
end
end
select_kill_rivals(tasks, i)
if clause[1] == :put
ret = put!(clause[2], clause[3])
elseif clause[1] == :take
ret = _take!(clause[2])
end
put!(winner_ch, (i, ret))
catch err
Base.throwto(maintask, err)
end
end
end
take!(winner_ch)
end
"""
`select(clauses[, block=true]) -> (clause_index, clause_value)`
Functional form of the `@select` macro, intended to be used when the set of clauses is dynamic. In general, this method will be less performant than the macro variant.
Clauses are specified as an array of tuples. Each tuple is expected to have 2 or 3 elements, as follows:
1) The clause type (`:take` or `:put`)
2) The waitable object
3) If the clause type is `:put`, the value to insert into the object.
If `block` is `true` (the default), wait for at least one clause to be satisfied and return a tuple whose first elmement is the index of the clause which unblocked first and whose whose second element is the value of the clause (see the manual on `select` for the meaning of clause value).
Otherwise, an arbitrary available clause will be executed, or a return value of `(0, nothing)` will be returned immediately if no clause is available.
"""
function select(clauses, block=true)
if block
_select_block(clauses)
else
_select_nonblock(clauses)
end
end
# package code goes here
end # module
| CryptoMarketData | https://github.com/g-gundam/CryptoMarketData.jl.git |
|
[
"MIT"
] | 1.0.3 | 59b6e9c5d3148a8d5cf2693725cd20e1b45a8e9f | code | 869 | function pui64(n)
parse(UInt64, n)
end
function pf64(n)
parse(Float64, n)
end
function first_csv(outdir)
cfs = readdir(outdir)
if length(cfs) == 0
missing
else
cfs[1]
end
end
function last_csv(outdir)
cfs = readdir(outdir)
if length(cfs) == 0
missing
else
cfs[end]
end
end
function _filename_to_date(f)
ds = replace(basename(f), ".csv" => "")
m = match(r"(\d{4})-(\d{2})-(\d{2})", ds)
Date(parse.(Int32, m.captures)...)
end
# date to index in span
function _d2i(d::Date, cfs)
a = _filename_to_date(first(cfs))
b = _filename_to_date(last(cfs))
if a <= d <= b
diff = d - a
return diff.value + 1
else
missing
end
end
function get_tz_offset(n=now(localzone()))
secs = (n.zone.offset.std + n.zone.offset.dst)
secs.value * -1000
end
| CryptoMarketData | https://github.com/g-gundam/CryptoMarketData.jl.git |
|
[
"MIT"
] | 1.0.3 | 59b6e9c5d3148a8d5cf2693725cd20e1b45a8e9f | code | 2758 |
struct Binance <: AbstractExchange
base_url::String
http_options::Dict
function Binance()
new("https://dapi.binance.com", Dict())
end
function Binance(http_options::Dict)
new("https://dapi.binance.com", http_options)
end
function Binance(base_url::String)
new(base_url, Dict())
end
function Binance(base_url::String, http_options::Dict)
new(base_url, http_options)
end
end
struct BinanceCandle <: AbstractCandle
ts::UInt64
o::Float64
h::Float64
l::Float64
c::Float64
v::Float64 # I might not care about anything below this comment, but someone else might so I keep it.
close_ts::UInt64
v2::Float64
trades::UInt64
tbv::Float64
tbv2::Float64
ignore::Float64
end
function csv_headers(binance::Binance)
collect(fieldnames(BinanceCandle))
end
function csv_select(binance::Binance)
1:6
end
function ts2datetime_fn(binance::Binance)
DateTime ∘ unixmillis2nanodate
end
function candle_datetime(c::BinanceCandle)
unixmillis2nanodate(c.ts)
end
function short_name(binance::Binance)
"binance"
end
function candles_max(binance::Binance; tf=Minute(1))
if tf == Day(1)
200
elseif tf == Minute(1)
1500
else
1500
end
end
function get_markets(binance::Binance)
info_url = binance.base_url * "/dapi/v1/exchangeInfo"
uri = URI(info_url)
res = HTTP.get(uri; binance.http_options...)
json = JSON3.read(res.body)
return map(m -> m[:symbol], json[:symbols])
end
function get_candles(binance::Binance, market; start, stop, tf=Minute(1), limit::Integer=10)
symbol = replace(market, r"\W" => s"") |> lowercase
interval = if tf == Day(1)
"1d"
elseif tf == Minute(1)
"1m"
else
"1m"
end
q = OrderedDict(
"interval" => interval,
"startTime" => nanodate2unixmillis(NanoDate(start)),
"endTime" => nanodate2unixmillis(NanoDate(stop)),
"limit" => limit,
"symbol" => symbol
)
ohlc_url = binance.base_url * "/dapi/v1/klines"
uri = URI(ohlc_url, query=q)
res = HTTP.get(uri; binance.http_options...)
json = JSON3.read(res.body)
map(json) do c
BinanceCandle(
c[1] % UInt64, # Casting Int64 to UInt64 :: https://discourse.julialang.org/t/casting-int64-to-uint64/33856/4
pf64(c[2]),
pf64(c[3]),
pf64(c[4]),
pf64(c[5]),
pf64(c[6]), # keeping data after this even if I don't use it.
c[7] % UInt64,
pf64(c[8]),
c[9] % UInt64,
pf64(c[10]),
pf64(c[11]),
pf64(c[12])
)
end
end
export Binance
export BinanceCandle
| CryptoMarketData | https://github.com/g-gundam/CryptoMarketData.jl.git |
|
[
"MIT"
] | 1.0.3 | 59b6e9c5d3148a8d5cf2693725cd20e1b45a8e9f | code | 3507 | struct Bitget <: AbstractExchange
base_url::String
home_url::String
http_options::Dict
type::String
function Bitget(; type="dmcbl")
new("https://api.bitget.com", "https://www.bitget.com", Dict(), type)
end
function Bitget(http_options::Dict; type="dmcbl")
new("https://api.bitget.com", "https://www.bitget.com", http_options, type)
end
end
struct BitgetCandle <: AbstractCandle
ts::UInt64
o::Float64
h::Float64
l::Float64
c::Float64
v::Float64
v2::Float64
end
function csv_headers(Bitget::Bitget)
collect(fieldnames(BitgetCandle))
end
function csv_select(Bitget::Bitget)
1:6
end
function ts2datetime_fn(bitget::Bitget)
DateTime ∘ unixmillis2nanodate
end
function candle_datetime(c::BitgetCandle)
unixmillis2nanodate(c.ts)
end
function short_name(bitget::Bitget)
# symbol names don't collide so all market types can be saved to the same directory
"bitget"
end
function candles_max(bitget::Bitget; tf=Minute(1))
1000
end
function get_markets(bitget::Bitget)
# type can be
# umcbl (usdt settled contracts)
# dmcbl (coin settled contracts)
# sumcbl (testnet usdt settled contracts)
# sdmcbl (testnet coin settled contracts)
info_url = bitget.base_url * "/api/mix/v1/market/contracts"
q = OrderedDict(
"productType" => bitget.type
)
uri = URI(info_url; query=q)
res = HTTP.get(uri; bitget.http_options...)
json = JSON3.read(res.body)
return map(m -> m[:symbol], json[:data])
end
function get_candles(bitget::Bitget, market; start, stop, tf=Minute(1), limit::Integer=10, tz_offset=get_tz_offset())
symbol = market
interval = if tf == Day(1)
"1D"
elseif tf == Minute(1)
"1m"
else
"1m"
end
# Add 1 minute to end time, because their API doesn't include the last minute otherwise.
# Not sure if the 1D interval also needs an adjustment.
adjustment = if interval == "1m"
Minute(1)
else
Minute(0)
end
q = OrderedDict(
"symbolId" => symbol,
"kLineStep" => interval,
"kLineType" => 1,
"languageType" => 0,
"startTime" => nanodate2unixmillis(NanoDate(start)),
"endTime" => nanodate2unixmillis(NanoDate(stop) + adjustment),
"limit" => limit
)
#@info "get_candles" start q["startTime"] stop q["endTime"] limit
ohlc_url = bitget.home_url * "/v1/kline/getMoreKlineData"
uri = URI(ohlc_url)
headers = ["Content-Type" => "application/json"]
body = JSON3.write(q)
res = HTTP.post(uri, headers, body; bitget.http_options...)
json = JSON3.read(res.body)
# I don't know how, but bitget seems to be able to infer my local timezone
# even though I'm behind a proxy. What is going on?
effective_offset = if interval == "1D"
tz_offset
else
0
end
candles = map(json.data) do c
BitgetCandle(
pui64(c[1]) + effective_offset,
pf64(c[2]),
pf64(c[3]),
pf64(c[4]),
pf64(c[5]),
pf64(c[6]),
pf64(c[7])
)
end
real_start = findfirst(candles) do c
c.ts == q["startTime"]
end
#@info "cdl" real_start length(candles) candle_datetime(candles[1])
if isnothing(real_start)
return []
elseif real_start > 0
return candles[real_start:end]
else
return candles
end
end
export Bitget
export BitgetCandle
| CryptoMarketData | https://github.com/g-gundam/CryptoMarketData.jl.git |
|
[
"MIT"
] | 1.0.3 | 59b6e9c5d3148a8d5cf2693725cd20e1b45a8e9f | code | 4732 | const BITMEX_API = "https://www.bitmex.com"
const BITMEX_TESTNET_API = "https://testnet.bitmex.com"
struct Bitmex <: AbstractExchange
base_url::String
http_options::Dict
function Bitmex()
new("https://www.bitmex.com", Dict())
end
function Bitmex(http_options::Dict)
new("https://www.bitmex.com", http_options)
end
function Bitmex(base_url::String)
new(base_url, Dict())
end
function Bitmex(base_url::String, http_options::Dict)
new(base_url, http_options)
end
# TODO - implement optional authentication to get improved rate limits
# https://www.bitmex.com/app/apiKeysUsage
# https://www.bitmex.com/app/restAPI#Limits
end
struct BitmexCandle <: AbstractCandle
timestamp::String
symbol::String
open::Union{Float64,Missing}
high::Union{Float64,Missing}
low::Union{Float64,Missing}
close::Union{Float64,Missing}
trades::Integer
volume::Union{Float64,Missing}
vwap::Union{Float64,Missing}
lastSize::Union{Integer,Missing}
turnover::Integer
homeNotional::Float64
foreignNotional::Float64
end
function Base.getproperty(c::BitmexCandle, s::Symbol)
if s == :ts
return getfield(c, :timestamp)
elseif s == :o
return getfield(c, :open)
elseif s == :h
return getfield(c, :high)
elseif s == :l
return getfield(c, :low)
elseif s == :c
return getfield(c, :close)
elseif s == :v
return getfield(c, :volume)
else
return getfield(c, s)
end
end
# https://www.bitmex.com/api/explorer/#!/Trade/Trade_getBucketed
# Timestamps returned by our bucketed endpoints are the end of the period,
# indicating when the bucket was written to disk. Some other common systems use
# the timestamp as the beginning of the period. Please be aware of this when
# using this endpoint.
#
# This leads to subtraction and addition of 1 minute at key points.
function csv_headers(bitmex::Bitmex)
[:ts, :symbol, :o, :h, :l, :c, :trades, :v, :vwap, :lastSize, :turnOver, :homeNotional, :foreignNotional]
end
function csv_select(bitmex::Bitmex)
[1, 3, 4, 5, 6, 8]
end
function ts2datetime_fn(bitmex::Bitmex)
return function (dt)
DateTime(NanoDate(dt) - Minute(1))
end
end
function candle_datetime(c::BitmexCandle)
NanoDate(c.ts) - Minute(1)
end
function short_name(bitmex::Bitmex)
if bitmex.base_url == BITMEX_API
"bitmex"
elseif bitmex.base_url == BITMEX_TESTNET_API
"bitmex-testnet"
else
"bitmex-unknown"
end
end
function candles_max(bitmex::Bitmex; tf=Minute(1))
1000
end
function get_markets(bitmex::Bitmex)
url = bitmex.base_url * "/api/v1/instrument/active"
uri = URI(url)
res = HTTP.get(uri; bitmex.http_options...)
json = JSON3.read(res.body)
return map(m -> m[:symbol], json)
end
function get_candles(bitmex::Bitmex, market; start, stop, tf=Minute(1), limit::Integer=10)
interval = if tf == Day(1)
"1d"
elseif tf == Minute(1)
"1m"
else
"1m"
end
adjustment = if tf == Minute(1)
Minute(1)
else
Minute(0)
end
q = OrderedDict(
"symbol" => market,
"binSize" => interval,
"startTime" => format(NanoDate(start) + adjustment),
"endTime" => format(NanoDate(stop) + adjustment),
"count" => limit
)
ohlc_url = bitmex.base_url * "/api/v1/trade/bucketed"
uri = URI(ohlc_url; query=q)
headers = ["Content-Type" => "application/json"]
res = HTTP.get(uri, headers; bitmex.http_options...)
json = JSON3.read(res.body)
candles = map(json) do c
open = if hasproperty(c, :open)
c[:open]
else
missing
end
high = if hasproperty(c, :high)
c[:high]
else
missing
end
low = if hasproperty(c, :low)
c[:low]
else
missing
end
close = if hasproperty(c, :close)
c[:close]
else
missing
end
vwap = if hasproperty(c, :vwap)
c[:vwap]
else
missing
end
lastSize = if hasproperty(c, :lastSize)
c[:lastSize]
else
missing
end
BitmexCandle(
c[:timestamp],
c[:symbol],
open,
high,
low,
close,
c[:trades],
c[:volume],
vwap,
lastSize,
c[:turnover],
c[:homeNotional],
c[:foreignNotional]
)
end
return candles
end
export Bitmex
export BitmexCandle
| CryptoMarketData | https://github.com/g-gundam/CryptoMarketData.jl.git |
|
[
"MIT"
] | 1.0.3 | 59b6e9c5d3148a8d5cf2693725cd20e1b45a8e9f | code | 2425 | struct Bitstamp <: AbstractExchange
base_url::String
function Bitstamp()
new("https://www.bitstamp.net")
end
end
struct BitstampCandle <: AbstractCandle
timestamp::UInt64
open::Union{Float64,Missing}
high::Union{Float64,Missing}
low::Union{Float64,Missing}
close::Union{Float64,Missing}
volume::Union{Float64,Missing}
end
function Base.getproperty(c::BitstampCandle, s::Symbol)
if s == :ts
return getfield(c, :timestamp)
elseif s == :o
return getfield(c, :open)
elseif s == :h
return getfield(c, :high)
elseif s == :l
return getfield(c, :low)
elseif s == :c
return getfield(c, :close)
elseif s == :v
return getfield(c, :volume)
else
return getfield(c, s)
end
end
function csv_headers(bitstamp::Bitstamp)
[:ts, :o, :h, :l, :c, :v]
end
function csv_select(bitstamp::Bitstamp)
1:6
end
function ts2datetime_fn(bitstamp::Bitstamp)
DateTime ∘ unixseconds2nanodate
end
function candle_datetime(c::BitstampCandle)
unixseconds2nanodate(c.ts)
end
function short_name(bitstamp::Bitstamp)
"bitstamp"
end
function candles_max(bitstamp::Bitstamp; tf=Minute(1))
1000
end
function get_markets(bitstamp::Bitstamp)
market_url = bitstamp.base_url * "/api/v2/ticker/"
res = HTTP.get(market_url)
json = JSON3.read(res.body)
return map(r -> r.pair, json)
end
function get_candles(bitstamp::Bitstamp, market; start, stop, tf=Minute(1), limit::Integer=10)
mark2 = replace(market, r"\W" => s"") |> lowercase
# I only support two timeframes. 1d and 1m
step = if tf == Day(1)
60 * 60 * 24
elseif tf == Minute(1)
60
else
60
end
q2 = OrderedDict(
"step" => step,
"start" => nanodate2unixseconds(NanoDate(start)),
"end" => nanodate2unixseconds(NanoDate(stop)),
"limit" => limit
)
ohlc_url = bitstamp.base_url * "/api/v2/ohlc/" * mark2 * "/"
uri = URI(ohlc_url, query=q2)
res = HTTP.get(uri)
json = JSON3.read(res.body)
# TODO - return a standardized candle, not JSON
map(json[:data][:ohlc]) do c
BitstampCandle(
pui64(c[:timestamp]),
pf64(c[:open]),
pf64(c[:high]),
pf64(c[:low]),
pf64(c[:close]),
pf64(c[:volume])
)
end
end
export Bitstamp
export BitstampCandle
| CryptoMarketData | https://github.com/g-gundam/CryptoMarketData.jl.git |
|
[
"MIT"
] | 1.0.3 | 59b6e9c5d3148a8d5cf2693725cd20e1b45a8e9f | code | 2836 | const BYBIT_API = "https://api.bybit.com"
const BYBIT_TESTNET_API = "https://api-testnet.bybit.com"
struct Bybit <: AbstractExchange
base_url::String
http_options::Dict
category::String
function Bybit(; category="inverse")
new(BYBIT_API, Dict(), category)
end
function Bybit(http_options::Dict; category="inverse")
new(BYBIT_API, http_options, category)
end
end
struct BybitCandle <: AbstractCandle
# Their API returns candles in a JSON array, so I picked the field names to suit me.
ts::UInt64
o::Float64
h::Float64
l::Float64
c::Float64
v::Float64
v2::Float64
end
function csv_headers(bybit::Bybit)
collect(fieldnames(BybitCandle)) # https://discourse.julialang.org/t/convert-tuple-to-array/2147/6
end
function csv_select(bybit::Bybit)
1:6
end
function ts2datetime_fn(bybit::Bybit)
DateTime ∘ unixmillis2nanodate
end
function candle_datetime(c::BybitCandle)
unixmillis2nanodate(c.ts)
end
function short_name(bybit::Bybit)
# symbol name collision is possible so candles of different categories
# are stored in separate directories.
network = if bybit.base_url == BYBIT_API
""
elseif bybit.base_url == BYBIT_TESTNET_API
"testnet"
else
"unknown"
end
if network == ""
return "bybit-$(bybit.category)"
else
return "bybit-$(bybit.category)-$(network)"
end
end
function candles_max(bybit::Bybit; tf=Minute(1))
1000
end
# valid categories: linear, inverse, option, spot
function get_markets(bybit::Bybit)
url = bybit.base_url * "/v5/market/instruments-info"
q = OrderedDict("category" => bybit.category)
uri = URI(url; query=q)
res = HTTP.get(uri; bybit.http_options...)
json = JSON3.read(res.body)
return map(m -> m[:symbol], json[:result][:list])
end
function get_candles(bybit::Bybit, market; start, stop, tf=Minute(1), limit::Integer=10)
interval = if tf == Day(1)
"D"
elseif tf == Minute(1)
"1"
else
"1"
end
q = OrderedDict(
"category" => bybit.category,
"symbol" => market,
"interval" => interval,
"start" => nanodate2unixmillis(NanoDate(start)),
"end" => nanodate2unixmillis(NanoDate(stop)),
"limit" => limit
)
ohlc_url = bybit.base_url * "/v5/market/kline"
uri = URI(ohlc_url; query=q)
headers = ["Content-Type" => "application/json"]
res = HTTP.get(uri, headers; bybit.http_options...)
json = JSON3.read(res.body)
return map(reverse(json[:result][:list])) do c
BybitCandle(
pui64(c[1]),
pf64(c[2]),
pf64(c[3]),
pf64(c[4]),
pf64(c[5]),
pf64(c[6]),
pf64(c[7])
)
end
end
export Bybit
export BybitCandle
| CryptoMarketData | https://github.com/g-gundam/CryptoMarketData.jl.git |
|
[
"MIT"
] | 1.0.3 | 59b6e9c5d3148a8d5cf2693725cd20e1b45a8e9f | code | 3392 | struct PancakeSwap <: AbstractExchange
base_url::String
http_options::Dict
function PancakeSwap()
new("https://perp.pancakeswap.finance", Dict())
end
end
struct PancakeSwapCandle <: AbstractCandle
ts::UInt64
o::Float64
h::Float64
l::Float64
c::Float64
v::Float64
close_ts::UInt64
v2::Float64
trades::UInt64
tbv::Float64
tbv2::Float64
ignore::Float64
end
function csv_headers(pancakeswap::PancakeSwap)
collect(fieldnames(PancakeSwapCandle))
end
function csv_select(pancakeswap::PancakeSwap)
1:6
end
function ts2datetime_fn(pancakeswap::PancakeSwap)
DateTime ∘ unixmillis2nanodate
end
function candle_datetime(c::PancakeSwapCandle)
unixmillis2nanodate(c.ts)
end
function short_name(pancakeswap::PancakeSwap)
"pancakeswap"
end
function candles_max(pancakeswap::PancakeSwap; tf=Minute(1))
1500
end
# Hard-code the [list of market pairs](https://docs.pancakeswap.finance/products/perpetual-trading/perpetual-trading-v2/supported-chains-modes-and-markets#supported-chain-markets) until an API for this info is discovered.
PANCAKESWAP_MARKETS = [
"BTCUSD",
"MADBTCUSD",
"ETHUSD",
"BNBUSD",
"SUIUSD",
"CAKEUSD",
"ARBUSD",
"XRPUSD",
"OPUSD",
"RDNTUSD",
"1000PEPEUSD",
"SOLUSD",
"DOTUSD",
"MKRUSD",
"LDOUSD",
"UNIUSD",
"DOGEUSD",
"GMXUSD",
"MATICUSD",
"BCHUSD",
"LTCUSD",
"TRXUSD",
"ADAUSD",
"LINKUSD",
"AVAXUSD",
"EURUSD",
"JPYUSD",
"AUDUSD",
"GBPUSD",
"CHFUSD",
"MXNUSD"
]
function get_markets(pancakeswap::PancakeSwap)
# info_url = pancakeswap.base_url * "/fapi/v1/exchangeInfo"
# uri = URI(info_url)
# res = HTTP.get(uri; pancakeswap.http_options...)
# json = JSON3.read(res.body)
# return map(m -> m[:symbol], json[:symbols])
return PANCAKESWAP_MARKETS
end
function get_candles(pancakeswap::PancakeSwap, market; start, stop, tf=Minute(1), limit::Integer=10)
symbol = replace(market, r"\W" => s"") |> lowercase
interval = if tf == Day(1)
"1d"
elseif tf == Minute(1)
"1m"
else
"1m"
end
q = OrderedDict(
"interval" => interval,
"contractType" => "PERPETUAL",
"startTime" => nanodate2unixmillis(NanoDate(start)),
"endTime" => nanodate2unixmillis(NanoDate(stop)),
"limit" => limit,
"symbol" => symbol
)
ohlc_url = pancakeswap.base_url * "/fapi/v1/markPriceKlines"
uri = URI(ohlc_url, query=q)
res = HTTP.get(uri; pancakeswap.http_options...)
json = JSON3.read(res.body)
map(json) do c
PancakeSwapCandle(
c[1] % UInt64, # Casting Int64 to UInt64 :: https://discourse.julialang.org/t/casting-int64-to-uint64/33856/4
pf64(c[2]),
pf64(c[3]),
pf64(c[4]),
pf64(c[5]),
pf64(c[6]),
c[7] % UInt64,
pf64(c[8]),
c[9] % UInt64,
pf64(c[10]),
pf64(c[11]),
pf64(c[12])
)
end
end
function subscribe(pancakeswap::PancakeSwap)
uri = URI("wss://perp-fstream.pancakeswap.finance/plain/stream?streams=!markPriceTicker@arr")
session = subscribe(uri)
return session
end
function subscribe(pancakeswap::PancakeSwap, market)
end
export PancakeSwap
export PancakeSwapCandle
| CryptoMarketData | https://github.com/g-gundam/CryptoMarketData.jl.git |
|
[
"MIT"
] | 1.0.3 | 59b6e9c5d3148a8d5cf2693725cd20e1b45a8e9f | code | 105 | using CryptoMarketData
using Test
@testset "CryptoMarketData.jl" begin
# Write your tests here.
end
| CryptoMarketData | https://github.com/g-gundam/CryptoMarketData.jl.git |
|
[
"MIT"
] | 1.0.3 | 59b6e9c5d3148a8d5cf2693725cd20e1b45a8e9f | docs | 2509 | # CryptoMarketData
[](https://g-gundam.github.io/CryptoMarketData.jl/stable/)
[](https://g-gundam.github.io/CryptoMarketData.jl/dev/)
[](https://github.com/g-gundam/CryptoMarketData.jl/actions/workflows/CI.yml?query=branch%3Amain)
[](https://codecov.io/gh/g-gundam/CryptoMarketData.jl)
A library for saving and loading OHLCV candle data from cryptocurrency exchanges
## Goals
1. **Be able to save 1 minute candle data from a variety of cryptocurrency exchanges.**
+ I only want 1 minute candles, because I can derive higher timeframes myself.
+ Implement extremely minimal exchange drivers for this purpose.
- Don't try to do everything.
- Focus on fetching 1 minute and 1 day candles well.
+ Save all the candle data the exchange gives us.
- Save even the non-OHLCV data.
- I don't care about it, but maybe someone else does.
- Each day worth of 1 minute candles should be saved in its own date-stamped CSV file.
2. **After saving, be able to load that data into a DataFrame.**
+ 1m candles are the default.
+ Other arbitrary timeframes should be supported.
## Exchanges
| Name | Status |
|-------------|------------------|
| Binance | Work in Progress |
| Bitget | Slightly Broken |
| Bitmex | Done |
| Bitstamp | Done |
| Bybit | Done |
| PancakeSwap | Done |
## Examples
### Save and Load Candles
This is the most basic thing you can do with this library.
```julia-repl
julia> using CryptoMarketData
julia> bitstamp = Bitstamp()
Bitstamp("https://www.bitstamp.net")
julia> markets = get_markets(bitstamp); markets[1:5]
5-element Vector{String}:
"BTC/USD"
"BTC/EUR"
"BTC/GBP"
"BTC/PAX"
"GBP/USD"
julia> save!(bitstamp, "BTC/USD"; endday=Date("2011-08-25"))
┌ Info: 2011-08-18
└ length(cs) = 683
┌ Info: 2011-08-19
└ length(cs) = 1440
┌ Info: 2011-08-20
└ length(cs) = 1440
┌ Info: 2011-08-21
└ length(cs) = 1440
┌ Info: 2011-08-22
└ length(cs) = 1440
┌ Info: 2011-08-23
└ length(cs) = 1440
┌ Info: 2011-08-24
└ length(cs) = 1440
┌ Info: 2011-08-25
└ length(cs) = 1440
julia> btcusd = load(bitstamp, "BTC/USD")
```
| CryptoMarketData | https://github.com/g-gundam/CryptoMarketData.jl.git |
|
[
"MIT"
] | 1.0.3 | 59b6e9c5d3148a8d5cf2693725cd20e1b45a8e9f | docs | 940 | ```@meta
CurrentModule = CryptoMarketData
```
# API
Documentation for [CryptoMarketData](https://github.com/g-gundam/CryptoMarketData.jl).
## Types
### AbstractExchange
Every exchange is a subtype of AbstractExchange.
### AbstractCandle
Every exchange also has a matching candle type that's a subtype of AbstractCandle.
Its purpose is to capture the data given to us by the exchange.
## Functions
### General Functions
- [`get_saved_markets`](@ref)
```@docs
get_saved_markets
```
### Generalized on Exchange
- [`save!`](@ref)
- [`load`](@ref)
- [`earliest_candle`](@ref)
- [`get_candles_for_day`](@ref)
- [`save_day!`](@ref)
```@docs
save!
```
```@docs
load
```
```@docs
earliest_candle
```
```@docs
get_candles_for_day
```
```@docs
save_day!
```
### Exchange Specific Implementations
- csv_headers
- csv_select
- ts2datetime_fn
- short_name
- candles_max
- [`get_markets`](@ref)
- get_candles
```@docs
get_markets
```
| CryptoMarketData | https://github.com/g-gundam/CryptoMarketData.jl.git |
|
[
"MIT"
] | 1.0.3 | 59b6e9c5d3148a8d5cf2693725cd20e1b45a8e9f | docs | 2932 | # Examples
## Construct an Exchange
The defaults are usually fine.
```julia-repl
julia> using CryptoMarketData
julia> bitget = Bitget()
Bitget("https://api.bitget.com", "https://www.bitget.com", Dict{Any, Any}(), "dmcbl")
julia> bitmex = Bitmex()
Bitmex("https://www.bitmex.com", Dict{Any, Any}())
julia> bitstamp = Bitstamp()
Bitstamp("https://www.bitstamp.net")
julia> bybit = Bybit()
Bybit("https://api.bybit.com", Dict{Any, Any}(), "inverse")
julia> pancakeswap = PancakeSwap()
PancakeSwap("https://perp.pancakeswap.finance", Dict{Any, Any}())
```
Some exchanges categorize their markets in a way that affects the API calls that must be used to access them.
This is expressed during exchange construction.
```julia-repl
julia> bitget_u = Bitget(;type="umcbl")
Bitget("https://api.bitget.com", "https://www.bitget.com", Dict{Any, Any}(), "umcbl")
julia> bitget_d = Bitget(;type="dmcbl") # default
Bitget("https://api.bitget.com", "https://www.bitget.com", Dict{Any, Any}(), "dmcbl")
julia> markets_u = get_markets(bitget_u);
julia> markets_d = get_markets(bitget_d);
julia> size(markets_u)
(195,)
julia> size(markets_d)
(12,)
```
Some of you who live in forbidden countries will need to use a proxy that's outside of your home country to get around IP bans.
Setting up a proxy is beyond the scope of this document, but I recommend
[Squid](https://www.digitalocean.com/community/tutorials/how-to-set-up-squid-proxy-on-ubuntu-22-04).
```julia-repl
julia> bybit = Bybit(Dict(:proxy => "http://user:pass@proxyhost:3128"))
Bybit("https://api.bybit.com", Dict(:proxy => "http://user:pass@proxyhost:3128"), "inverse")
```
## Get a List of Available Markets
```julia-repl
julia> markets = get_markets(bitstamp); markets[1:5]
5-element Vector{String}:
"BTC/USD"
"BTC/EUR"
"BTC/GBP"
"BTC/PAX"
"GBP/USD"
```
## Save Candles
This is the most basic thing you can do with this library.
```julia-repl
julia> save!(bitstamp, "BTC/USD"; endday=Date("2011-08-25"))
┌ Info: 2011-08-18
└ length(cs) = 683
┌ Info: 2011-08-19
└ length(cs) = 1440
┌ Info: 2011-08-20
└ length(cs) = 1440
┌ Info: 2011-08-21
└ length(cs) = 1440
┌ Info: 2011-08-22
└ length(cs) = 1440
┌ Info: 2011-08-23
└ length(cs) = 1440
┌ Info: 2011-08-24
└ length(cs) = 1440
┌ Info: 2011-08-25
└ length(cs) = 1440
```
### Find Out When Candle Data for a Market Begins
```julia-repl
julia> ec = earliest_candle(bitstamp, "BTC/USD")
BitstampCandle(0x000000004e4d076c, 10.9, 10.9, 10.9, 10.9, 0.48990826)
julia> candle_datetime(ec)
2011-08-18T12:37:00
```
## Load Candles
### Everything
```julia-repl
julia> btcusd = load(bitstamp, "BTC/USD")
```
### Within a Certain Date Range
```julia-repl
julia> btcusd = load(bitstamp, "BTC/USD";
span=Date("2024-01-01"):Date("2024-01-15"))
```
### In a Certain Time Frame
```julia-repl
julia> btcusd4h = load(bitstamp, "BTC/USD";
tf=Hour(4), span=Date("2024-01-01"):Date("2024-01-15"))
```
| CryptoMarketData | https://github.com/g-gundam/CryptoMarketData.jl.git |
|
[
"MIT"
] | 1.0.3 | 59b6e9c5d3148a8d5cf2693725cd20e1b45a8e9f | docs | 2568 | # Exchanges
## Binance
Status: Work in Progress
I have a preliminary `Binance` struct, and it supports Binance's COIN-M Futures
API. It works, but to properly support all of Binance's APIs, I'm going to
have to add more structs and rename the current `Binance` struct to something
like `BinanceCMFutures`. In the end, there may be 4 or 5 exchange types just
for Binance.
Proxies are needed if you're local IP is from a forbidden country.
## Bitget
Status: Slightly Broken
I had to use an undocumented API that their trading front-end uses to acquire
1m candles, because their official API only gives you the last 30 days of 1m
candles. It was working fine for a while, but in early February 2024, its
behavior changed and broke `earliest_candle()`.
The constructor for `Bitget` takes an optional named parameter `type` to
specify which [`productType`](https://bitgetlimited.github.io/apidoc/en/mix/#producttype)
to use. The default value is `dmcbl`.
```julia-repl
julia> bitget_u = Bitget(;type="umcbl")
Bitget("https://api.bitget.com", "https://www.bitget.com", Dict{Any, Any}(), "umcbl")
```
Proxies are needed if you're local IP is from a forbidden country.
## Bitmex
Status: DONE
When running `save!(bitmex, market)`, I strongly advise setting `delay=3.5`.
That'll keep you under the rate limit for unauthenticated users.
One thing I like about this library is that you don't need to be authenticated
to use it. However, Bitmex gives authenticated users a much better rate limit,
so I'd like to support authentication eventually.
## Bitstamp
Status: DONE
This exchange is a valuable source of historical data. Their "BTC/USD" goes
back all the way to 2011-08-18 which is the longest of any known exchange.
## Bybit
Status: DONE
The `Bybit` constructor takes an optional `category` parameter that
chooses which of the 3 market categories to use. The default value is `inverse`,
but `linear` and `spot` can also be specified.
```julia-repl
julia> bybit_spot = Bybit(;category=spot)
Bybit("https://api.bybit.com", Dict{Any, Any}(), "spot")
```
Proxies are needed if you're local IP is from a forbidden country.
(The v5 iteration of their API is one of the nicest I've worked with.)
## PancakeSwap
Status: DONE*
I say it's done, but I'm not totally sure. Instead of using documentation
(which I couldn't find), I ended up reverse engineering their APIs. I later
discovered that they look a lot like Binance's APIs, and that helped me take
this to a working state.
This is the only DEX among the currently supported exchanges.
| CryptoMarketData | https://github.com/g-gundam/CryptoMarketData.jl.git |
|
[
"MIT"
] | 1.0.3 | 59b6e9c5d3148a8d5cf2693725cd20e1b45a8e9f | docs | 1190 | ```@meta
CurrentModule = CryptoMarketData
```
# CryptoMarketData
A library for saving and loading OHLCV candle data from cryptocurrency exchanges
## Goals
1. **Be able to save 1 minute candle data from a variety of cryptocurrency exchanges.**
+ I only want 1 minute candles, because I can derive higher timeframes myself.
+ Implement extremely minimal exchange drivers for this purpose.
- Don't try to do everything.
- Focus on fetching 1 minute and 1 day candles well.
+ Save all the candle data the exchange gives us.
- Save even the non-OHLCV data.
- I don't care about it, but maybe someone else does.
- Each day worth of 1 minute candles should be saved in its own date-stamped CSV file.
2. **After saving, be able to load that data into a DataFrame.**
+ 1m candles are the default.
+ Other arbitrary timeframes should be supported.
## Exchanges
| Name | Status |
|-------------|------------------|
| Binance | Work in Progress |
| Bitget | Slightly Broken |
| Bitmex | Done |
| Bitstamp | Done |
| Bybit | Done |
| PancakeSwap | Done |
| CryptoMarketData | https://github.com/g-gundam/CryptoMarketData.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 3257 | using Documenter, Jusdl
# using DocumenterLaTeX
DocMeta.setdocmeta!(Jusdl, :DocTestSetup, :(using Jusdl); recursive=true)
makedocs(
modules=[Jusdl],
sitename="Jusdl",
pages=[
"Home" => "index.md",
"Modeling and Simulation in Jusdl" => [
"modeling_and_simulation/modeling.md",
"modeling_and_simulation/simulation.md",
],
"Tutorials" => [
"Model Construction" => "tutorials/model_construction.md",
"Model Simulation" => "tutorials/model_simulation.md",
"Algebraic Loops" => "tutorials/algebraic_loops.md",
"Extending Component Library" => "tutorials/defining_new_components.md",
"Coupled Systems" => "tutorials/coupled_systems.md",
],
"Manual" => [
"Utilities" => [
"manual/utilities/callback.md",
"manual/utilities/buffers.md"
],
"Connections" => [
"manual/connections/link.md",
"manual/connections/pin.md",
"manual/connections/port.md",
],
"Components" => [
"ComponentsBase" => [
"manual/components/componentsbase/hierarchy.md",
"manual/components/componentsbase/evolution.md",
"manual/components/componentsbase/interpolation.md",
],
"Sources" => [
"manual/components/sources/clock.md",
"manual/components/sources/generators.md",
],
"Sinks" => [
"manual/components/sinks/sinks.md",
"manual/components/sinks/writer.md",
"manual/components/sinks/printer.md",
"manual/components/sinks/scope.md",
],
"Systems" => [
"StaticSystems" => [
"StaticSystems" => "manual/components/systems/staticsystems/staticsystems.md",
# "Subsystem" => "manual/components/systems/staticsystems/subsystem.md",
],
"DynamicSystems" => [
"DiscreteSystem" => "manual/components/systems/dynamicsystems/discretesystem.md",
"ODESystem" => "manual/components/systems/dynamicsystems/odesystem.md",
"DAESystem" => "manual/components/systems/dynamicsystems/daesystem.md",
"RODESystem" => "manual/components/systems/dynamicsystems/rodesystem.md",
"SDESystem" => "manual/components/systems/dynamicsystems/sdesystem.md",
"DDESystem" => "manual/components/systems/dynamicsystems/ddesystem.md",
],
]
],
"Models" => [
"manual/models/taskmanager.md",
"manual/models/simulation.md",
"manual/models/model.md",
],
"Plugins" => "manual/plugins/plugins.md",
]
]
)
deploydocs(;
repo="github.com/zekeriyasari/Jusdl.jl.git",
devbranch = "master",
devurl = "dev",
versions = ["stable" => "v^", "v#.#", "v#.#.#"]
)
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 941 | # This file illustrates the use of memory blocks to break algebraic loops
using Jusdl
using Plots
# Simualation settings
t0, dt, tf = 0, 1 / 64, 1.
# Construct the model
@defmodel model begin
@nodes begin
gen = FunctionGenerator(readout=identity)
adder = Adder(signs = (+, -))
mem = Memory(delay = dt)
writer = Writer(input=Inport(2))
end
@branches begin
gen[1] => adder[1]
adder[1] => mem[1]
mem[1] => adder[2]
gen[1] => writer[1]
adder[1] => writer[2]
end
end
# Simulate the model
sim = simulate!(model, t0, dt, tf)
# Diplay model taskmanager
display(model.taskmanager.pairs)
# Read the simulation data
t, x = read(getnode(model, :writer).component)
# Plot the results
p1 = plot(t, x[:, 1], label=:u, marker=(:circle, 1))
plot!(t, x[:, 2], label=:y, marker=(:circle, 1))
display(p1)
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 958 | # This file includes an example file by breaking algebraic loops by solving loop equation numerically.
using Jusdl
using Plots
# Simulation parameter
α = 3.
# Construct model with algebraic loop
@defmodel model begin
@nodes begin
gen = RampGenerator()
adder = Adder(signs=(+,-))
gain = Gain(gain=α)
writer = Writer(input=Inport(2))
end
@branches begin
gen[1] => adder[1]
adder[1] => gain[1]
gain[1] => adder[2]
gen[1] => writer[1]
gain[1] => writer[2]
end
end
# Simulate the model
simulate!(model, 0., 1., 100.)
# Plot the results
t, y = read(getnode(model, :writer).component)
yt = α / (α + 1) * getnode(model, :gen).component.readout.(t)
err = yt - y[:, 2]
p1 = plot(t, y[:, 1], label=:u)
plot!(t, y[:, 2], label=:y)
plot!(t, yt, label=:true)
p2 = plot(t, err, label=:err)
plot(p1, p2, layout=(2, 1))
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 951 | # This file includes the simulation of a model consisting an algrebraic loop with multiple inneighbor branches joinin an algrebraic loop.
using Jusdl
using Plots
# Construct the model
@defmodel model begin
@nodes begin
gen1 = SinewaveGenerator(frequency=2.)
gain1 = Gain()
adder1 = Adder(signs=(+,+))
gen2 = SinewaveGenerator(frequency=3.)
adder2 = Adder(signs=(+,+,-))
gain2 = Gain()
writer = Writer()
gain3 = Gain()
end
@branches begin
gen1[1] => gain1[1]
gain1[1] => adder1[1]
adder1[1] => adder2[1]
gen2[1] => adder1[2]
gen2[1] => adder2[2]
adder2[1] => gain2[1]
gain2[1] => writer[1]
gain2[1] => gain3[1]
gain3[1] => adder2[3]
end
end
simulate!(model)
t, x = read(getnode(model, :writer).component)
plot(t, x)
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 1072 | # Simulation of coupled Lorenz systems.
using Jusdl
using Plots
# Construct the model
ε = 10.
@defmodel model begin
@nodes begin
ds1 = ForcedLorenzSystem()
ds2 = ForcedLorenzSystem()
coupler = Coupler(conmat = ε*[-1. 1; 1 -1], cplmat=[1. 0 0; 0 0 0; 0 0 0])
writer = Writer(input=Inport(6))
end
@branches begin
ds1[1:3] => coupler[1:3]
ds2[1:3] => coupler[4:6]
coupler[1:3] => ds1[1:3]
coupler[4:6] => ds2[1:3]
ds1[1:3] => writer[1:3]
ds2[1:3] => writer[4:6]
end
end
# Plot signal flow diagram of model
display(signalflow(model))
# Simulate the model
simulate!(model, 0., 0.01, 100)
# Plot signal flow diagram of model
display(signalflow(model))
# Read simulation data
t, x = read(getnode(model, :writer).component)
# Compute errors
err = x[:, 1] - x[:, 4]
# Plot the results.
p1 = plot(x[:, 1], x[:, 2])
p2 = plot(x[:, 4], x[:, 5])
p3 = plot(t, err)
display(plot(p1, p2, p3, layout=(3, 1)))
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 607 | using Jusdl
using Plots
# Construct the model
@defmodel model begin
@nodes begin
ds = ChenSystem()
writer = Writer(input=Inport(3))
end
@branches begin
ds[1:3] => writer[1:3]
end
end
# Simulate the model
simulate!(model, 0, 0.01, 100.)
# Plot results
t, x = read(getnode(model, :writer).component)
plots = [
plot(t, x[:, 1], label=:x1),
plot(t, x[:, 2], label=:x1),
plot(t, x[:, 3], label=:x1),
plot(x[:, 1], x[:, 2], label=:x1x2),
plot(x[:, 1], x[:, 3], label=:x1x3),
plot(x[:, 2], x[:, 3], label=:x2x3)
]
display(plot(plots...)) | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 954 | # This file simulates a closed system
using Jusdl
# Construct the model
@defmodel model begin
@nodes begin
gen = FunctionGenerator(readout=sin)
adder = Adder(signs=(+,-))
ds = ContinuousLinearSystem()
writer = Writer(input=Inport(2))
end
@branches begin
gen[1] => adder[1]
adder[1] => ds[1]
ds[1] => adder[2]
gen[1] => writer[1]
ds[1] => writer[2]
end
end
# Simualate the model
sim = simulate!(model, 0., 0.01, 10.)
# Read and plot data
t, x = read(getnode(model, :writer).component)
using Plots
plot(t, x[:, 1], label="r(t)", xlabel="t", lw=3)
plot!(t, x[:, 2], label="y(t)", xlabel="t", lw=3)
plot!(t, 6 / 5 * exp.(-2t) + 1 / 5 * (2 * sin.(t) - cos.(t)), label="Analytical Solution", lw=3)
# fileanme = "readme_example.svg"
# path = joinpath(@__DIR__, "../docs/src/assets/ReadMePlot/")
# savefig(joinpath(path, fileanme))
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 996 | # This file illustrates the simulation of feedthrough dynamical system in a unity feedback.
using Jusdl
using Plots
# Construct the model
x0 = ones(1)
@defmodel model begin
@nodes begin
gen = FunctionGenerator(readout=sin)
adder = Adder(signs=(+,-))
ds = ContinuousLinearSystem(state=x0)
writer = Writer()
end
@branches begin
gen[1] => adder[1]
adder => ds
ds[1] => adder[2]
ds => writer
end
end
# Simulate the model
simulate!(model, 0., 0.01, 10.)
# Read simulation data
t, ys = read(getnode(model, :writer).component)
# Compoute simulation error
r = getnode(model,:gen).component.readout.(t)
xa = (x0[1] + 2 / 13) * exp.(-3 / 2 * t) + 3 / 13 * sin.(t) - 2 / 13 * cos.(t)
ya = (xa + r) / 2
er = ys - ya
# Plot results.
p1 = plot(t, ys, label=:simulation)
plot!(t, ya, label=:analytic)
p2 = plot(t, er, label=:error)
display(plot(p1, p2, layout=(2, 1)))
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 748 | # This file simulates an opamp integrator circuit.
using Jusdl
using Plots
freq = 5e3
T = 1 / freq
r = 10e3
c = 10e-9
τ = r * c
t0, dt, tf = 0, T/1000, 5T
@defmodel model begin
@nodes begin
gen = SquarewaveGenerator(high=0.5, low=-0.5, period=T)
ds = ContinuousLinearSystem(A=fill(0., 1, 1), B=fill(1/τ, 1, 1), C=fill(-1., 1, 1), state=zeros(1))
writerin = Writer()
writerout = Writer()
end
@branches begin
gen => ds
gen => writerin
ds => writerout
end
end
sim = simulate!(model, t0, dt, tf)
t, u = read(getnode(model, :writerin).component)
t, y = read(getnode(model, :writerout).component)
p1 = plot(t, u)
plot!(t, y)
display(p1)
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 1128 | # This file includes an example of memory operation.
# In this example `mem` delays its input for one step size time.
using Jusdl
using Plots
# Construct a model
ti, dt, tf = 0., 1., 100.
numtaps = 5 # Number of buffer taps in Memory.
delay = dt # One step size delay.
model = Model(clock=Clock(ti, dt, tf))
@defmodel model begin
@nodes begin
gen = RampGenerator()
mem = Memory(delay=dt, numtaps=numtaps)
writer = Writer(input=Inport(2))
end
@branches begin
gen => mem
mem[1] => writer[1]
gen[1] => writer[2]
end
end
# Simulate model
simulate!(model, ti, dt, tf)
# Read simulation data
t, x = read(getnode(model, :writer).component)
u = getnode(model, :gen).component.readout.(t .- delay)
err = u - x[:, 2]
# Plots simulation data
n1, n2 = 1, 5
marker = (:circle, 2)
p1 = plot(t[n1:n2], x[n1:n2, 1], label=:mem, marker=marker)
plot!(t[n1:n2], x[n1:n2, 2], label=:gen, marker=marker)
plot!(t[n1:n2], u[n1:n2], label=:real, marker=marker)
p2 = plot(t[n1:n2], err[n1:n2], label=:error, marker=marker)
display(plot(p1, p2, layout=(2,1)))
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 333 | # This file is illustrates multiple simulations of a model
using Jusdl
# Constrcut the model
@defmodel model begin
@nodes begin
gen = SinewaveGenerator()
writer = Writer()
end
@branches begin
gen => writer
end
end
# Multiple simulations.
for i in 1 : 5
simulate!(model)
end | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 874 | using Jusdl
# Deifne model
@defmodel model begin
@nodes begin
gen = SinewaveGenerator(amplitude=1., frequency=1/2π)
adder = Adder(signs=(+, -))
ds = ContinuousLinearSystem(A=fill(-1., 1, 1), state=[1.])
writer = Writer(input=Inport(2))
end
@branches begin
gen[1] => adder[1]
adder[1] => ds[1]
ds[1] => adder[2]
ds[1] => writer[1]
gen[1] => writer[2]
end
end
# Simulate the model
tinit, tsample, tfinal = 0., 0.01, 10.
sim = simulate!(model, tinit, tsample, tfinal)
# Read and plot data
t, x = read(getnode(model, :writer).component)
t, x = read(getnode(model, :writer).component)
using Plots
plot(t, x[:, 1], label="r(t)", xlabel="t")
plot!(t, x[:, 2], label="y(t)", xlabel="t")
plot!(t, 6 / 5 * exp.(-2t) + 1 / 5 * (2 * sin.(t) - cos.(t)), label="Analytical Solution")
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 1082 | # This file illustrates synchronizing channels that are bound the different tasks that elapse in different amount of
# time..
function taker5(ch, chr)
while true
val = take!(ch)
@info "In $(objectid(ch)). Took $val"
val === missing && (@info "Breaking out of $(objectid(ch))"; break)
sleep(5)
@info "Slept 5 seconds in $(objectid(ch)) for $val"
put!(chr, true)
end
end
function taker20(ch, chr)
while true
val = take!(ch)
@info "In $(objectid(ch)). Took $val"
val === missing && (@info "Breaking out of $(objectid(ch))"; break)
sleep(20)
@info "Slept 20 seconds in $(objectid(ch)) for $val"
put!(chr, true)
end
end
chn1 = Channel(0)
chn2 = Channel(0)
chr1 = Channel(0)
chr2 = Channel(0)
@info objectid(chn1)
@info objectid(chn2)
t1 = @async taker5(chn1, chr1)
t2 = @async taker20(chn2, chr2)
for t in 1. : 2.
foreach(chn -> put!(chn, t), [chn1, chn2])
foreach(take!, [chr1, chr2])
end
@info "Out of loop"
# foreach(chn -> put!(chn, missing), [chn1, chn2]) | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 4730 | #
# Julia System Desciption Language
#
module Jusdl
@warn "Jusdl.jl is being renamed to Causal.jl. For further updates greater than v0.2.2, you will need to add Causal.jl\n"
using UUIDs
using DifferentialEquations
using Sundials
using LightGraphs
using DataStructures
using JLD2
using Plots
using ProgressMeter
using Logging
using LinearAlgebra
using Dates
using NLsolve
using Interpolations
using LibGit2
using DocStringExtensions
import GraphPlot.gplot
import FileIO: load
import Base: show, display, write, read, close, setproperty!, mv, cp, open, istaskdone, istaskfailed,
getindex, setindex!, size, isempty
include("utilities/utils.jl")
export equip
include("utilities/callback.jl")
export Callback,
enable!,
disable!,
isenabled,
applycallbacks
include("utilities/buffer.jl")
export BufferMode,
LinearMode,
CyclicMode,
Buffer,
Normal,
Cyclic,
Fifo,
Lifo,
write!,
isfull,
ishit,
content,
mode,
snapshot,
datalength,
inbuf,
outbuf
include("connections/link.jl")
export Link,
launch,
refresh!
include("connections/pin.jl")
export AbstractPin,
Outpin,
Inpin,
connect!,
disconnect!,
isconnected,
isbound
include("connections/port.jl")
export AbstractPort,
Inport,
Outport,
datatype
include("components/componentsbase/hierarchy.jl")
export AbstractComponent,
AbstractSource,
AbstractSystem,
AbstractSink,
AbstractStaticSystem,
AbstractDynamicSystem,
AbstractSubSystem,
AbstractMemory,
AbstractDiscreteSystem,
AbstractODESystem,
AbstractRODESystem,
AbstractDAESystem,
AbstractSDESystem,
AbstractDDESystem
include("components/componentsbase/macros.jl")
include("components/componentsbase/interpolant.jl")
export Interpolant
include("components/componentsbase/takestep.jl")
export readtime!,
readstate,
readinput!,
writeoutput!,
computeoutput,
evolve!,
takestep!,
drive!,
approve!
include("components/sources/clock.jl")
export Clock,
isrunning,
ispaused,
isoutoftime,
set!,
stop!,
pause!
include("components/sources/generators.jl")
export @def_source,
FunctionGenerator,
SinewaveGenerator,
DampedSinewaveGenerator,
SquarewaveGenerator,
TriangularwaveGenerator,
ConstantGenerator,
RampGenerator,
StepGenerator,
ExponentialGenerator,
DampedExponentialGenerator
include("components/systems/staticsystems/staticsystems.jl")
export @def_static_system,
StaticSystem,
Adder,
Multiplier,
Gain,
Terminator,
Memory,
Coupler,
Differentiator
include("components/systems/dynamicalsystems/init.jl")
include("components/systems/dynamicalsystems/odesystems.jl")
export @def_ode_system,
ODESystem,
ContinuousLinearSystem,
LorenzSystem,
ChenSystem,
ChuaSystem,
RosslerSystem,
VanderpolSystem,
ForcedLorenzSystem,
ForcedChenSystem,
ForcedChuaSystem,
ForcedRosslerSystem,
ForcedVanderpolSystem,
Integrator
include("components/systems/dynamicalsystems/discretesystems.jl")
export @def_discrete_system,
DiscreteSystem,
DiscreteLinearSystem,
HenonSystem,
LoziSystem,
BogdanovSystem,
GingerbreadmanSystem,
LogisticSystem
include("components/systems/dynamicalsystems/sdesystems.jl")
export @def_sde_system,
SDESystem,
NoisyLorenzSystem,
ForcedNoisyLorenzSystem
include("components/systems/dynamicalsystems/daesystems.jl")
export @def_dae_system,
DAESystem,
RobertsonSystem,
PendulumSystem,
RLCSystem
include("components/systems/dynamicalsystems/rodesystems.jl")
export @def_rode_system,
RODESystem,
MultiplicativeNoiseLinearSystem
include("components/systems/dynamicalsystems/ddesystems.jl")
export @def_dde_system,
DDESystem,
DelayFeedbackSystem
include("components/sinks/sinks.jl")
export @def_sink,
Writer,
Printer,
Scope,
write!,
fwrite!,
fread,
update!
include("models/taskmanager.jl")
export TaskManager,
checktaskmanager
include("models/simulation.jl")
export Simulation,
setlogger,
closelogger,
report
include("models/model.jl")
export @defmodel,
Model,
inspect!,
initialize!,
run!,
terminate!,
simulate!,
getloops,
breakloop!,
Node,
Branch,
addnode!,
getnode,
addbranch!,
getbranch,
deletebranch!,
signalflow,
troubleshoot
include("plugins/loadplugins.jl")
export AbstractPlugin,
process,
add,
remove,
enable,
disable,
check
end # module
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 2031 | # This file contains the Base module of Plugins module.
# Type hierarchy
"""
$(TYPEDEF)
Abstract type of all components
"""
abstract type AbstractComponent end
"""
$(TYPEDEF)
Abstract typeof all source components
"""
abstract type AbstractSource <: AbstractComponent end
"""
$(TYPEDEF)
Abstract type of all system components
"""
abstract type AbstractSystem <: AbstractComponent end
"""
$(TYPEDEF)
Abstract type of all sink components
"""
abstract type AbstractSink <: AbstractComponent end
"""
$(TYPEDEF)
Abstract type of all static systems
"""
abstract type AbstractStaticSystem <: AbstractSystem end
"""
$(TYPEDEF)
Abstract type of all dynamic system components
"""
abstract type AbstractDynamicSystem <: AbstractSystem end
"""
$(TYPEDEF)
Abstract type of all subsystem components
"""
abstract type AbstractSubSystem <: AbstractSystem end
"""
$(TYPEDEF)
Abstract type of all memory components
"""
abstract type AbstractMemory <: AbstractStaticSystem end
"""
$(TYPEDEF)
Abstract type of all dynamic systems modelled by dicrete difference equations.
"""
abstract type AbstractDiscreteSystem <: AbstractDynamicSystem end
"""
$(TYPEDEF)
Abstract type of all dynamical systems modelled by ordinary differential equations.
"""
abstract type AbstractODESystem <: AbstractDynamicSystem end
"""
$(TYPEDEF)
Abstract type of all dynamical systems modelled by random ordinary differential equations.
"""
abstract type AbstractRODESystem <: AbstractDynamicSystem end
"""
$(TYPEDEF)
Abstract type of all dynamical systems modelled by differential algebraic equations
"""
abstract type AbstractDAESystem <: AbstractDynamicSystem end
"""
$(TYPEDEF)
Abstract type of all dynamical systems modelled by stochastic differential equations.
"""
abstract type AbstractSDESystem <: AbstractDynamicSystem end
"""
$(TYPEDEF)
Abstract type of all dynamical systems modlled by delay dynamical systems.
"""
abstract type AbstractDDESystem <: AbstractDynamicSystem end
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 1803 | # This file includes interpolant for interplation of sampled inputs.
"""
Interpolant(tinit, tfinal, coefinit, coeffinal)
Constructs a linnear interpolant that interpolates between the poinsts `(tinit, coefinit)` and `(tfinal, coeffinal)`.
"""
mutable struct Interpolant{TMB, INB, ITP}
timebuf::TMB
databuf::INB
itp::ITP
function Interpolant(nt::Int, nd::Int)
timebuf = Buffer(nt)
databuf = nd == 1 ? Buffer(nt) : Buffer(nd, nt)
itp = [interpolation(zeros(1), zeros(1)) for i in 1 : nd]
new{typeof(timebuf), typeof(databuf), typeof(itp)}(timebuf, databuf, itp)
end
end
show(io::IO, interpolant::Interpolant) = print(io, "Interpolant(timebuf:$(interpolant.timebuf), ",
"databuf:$(interpolant.databuf), itp:$(interpolant.itp))")
# Callling interpolant.
getindex(interpolant::Interpolant, idx::Int) = interpolant.itp[idx]
# Update of interpolant. That is, reinterpolation.
"""
update!(intepolant)
Updates `interpolant` using the data in `timebuf` and `databuf` of `interpolant`.
"""
update!(interpolant::Interpolant{T1, <:AbstractVector, T2}) where {T1,T2} = interpolant.itp[1] = _update!(interpolant)
update!(interpolant::Interpolant{T1, <:AbstractMatrix, T2}) where {T1,T2} = interpolant.itp = _update!(interpolant)
_update!(interpolant) = interpolation(content(interpolant.timebuf, flip=true), content(interpolant.databuf, flip=true))
interpolation(tt, uu::AbstractMatrix) = map(row -> interpolation(tt, row), eachrow(uu))
interpolation(tt, uu::AbstractVector) = CubicSplineInterpolation(getranges(tt, uu)...; extrapolation_bc=Line())
function getranges(tt, uu)
length(tt) < 2 && return (range(tt[1], length=2, step=eps()), range(uu[1], length=2, step=eps()))
return range(tt[1], tt[end], length=length(tt)), uu
end
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 2756 | # This file includes macro tools to define new components types
function _append_common_fields!(ex, newbody, newparamtypes)
# Append body
body = ex.args[3]
append!(body.args, newbody.args)
# Append struct type parameters
name = ex.args[2]
if name isa Expr && name.head === :(<:)
name = name.args[1]
end
if name isa Expr && name.head === :curly
append!(name.args, newparamtypes)
elseif name isa Symbol
ex.args[2] = Expr(:curly, name, newparamtypes...) # parametrize ex
end
end
function deftype(ex)
# Check ex head
ex isa Expr && ex.head == :struct || error("Invalid source defition")
# Get struct name
name = ex.args[2]
if name isa Expr && name.head === :(<:)
name = name.args[1]
end
# Process struct body
body = ex.args[3]
kwargs = Expr(:parameters)
callargs = Symbol[]
_def!(body, kwargs, callargs)
# struct has no fields
isempty(kwargs.args) && return quote
Base.@__doc__($(esc(ex)))
end
if name isa Symbol
return quote
Base.@__doc__($(esc(ex)))
$(esc(name))($kwargs) = $(esc(name))($(callargs...))
end
elseif name isa Expr && name.head === :curly
_name = name.args[1]
_param_types = name.args[2:end]
__param_types = [_type_ isa Symbol ? _type_ : _type_.args[1] for _type_ in _param_types]
return quote
Base.@__doc__($(esc(ex)))
$(esc(_name))($kwargs) = $(esc(_name))($(callargs...))
$(esc(_name)){$(esc.(__param_types)...)}($kwargs) where {$(esc.(_param_types)...)} =
$(esc(_name)){$(esc.(__param_types)...)}($(callargs...))
end
end
end
function _def!(body, kwargs, callargs)
for i in 1 : length(body.args)
bodyex = body.args[i]
if bodyex isa Symbol # var
push!(kwargs.args, bodyex)
push!(callargs, bodyex)
elseif bodyex isa Expr
if bodyex.head === :(=)
rhs = bodyex.args[2]
lhs = bodyex.args[1]
if lhs isa Expr && lhs.head === :(::) # var::T = 1
var = lhs.args[1]
elseif lhs isa Symbol # var = 1
var = lhs
elseif lhs isa Expr && lhs.head == :call # inner constructors
continue
end
push!(kwargs.args, Expr(:kw, var, esc(rhs)))
push!(callargs, var)
body.args[i] = lhs
elseif bodyex.head === :(::) # var::T
var = bodyex.args[1]
push!(kwargs.args, var)
push!(callargs, var)
end
end
end
end
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 9361 | # This file includes stepping of abstract types.
##### Input-Output reading and writing.
"""
readtime!(comp::AbstractComponent)
Returns current time of `comp` read from its `trigger` link.
!!! note
To read time of `comp`, `comp` must be launched. See also: [`launch(comp::AbstractComponent)`](@ref).
"""
readtime!(comp::AbstractComponent) = take!(comp.trigger)
"""
readstate(comp::AbstractComponent)
Returns the state of `comp` if `comp` is `AbstractDynamicSystem`. Otherwise, returns `nothing`.
"""
readstate(comp::AbstractComponent) = typeof(comp) <: AbstractDynamicSystem ? comp.state : nothing
"""
readinput!(comp::AbstractComponent)
Returns the input value of `comp` if the `input` of `comp` is `Inport`. Otherwise, returns `nothing`.
!!! note
To read input value of `comp`, `comp` must be launched. See also: [`launch(comp::AbstractComponent)`](@ref)
"""
function readinput!(comp::AbstractComponent)
typeof(comp) <: AbstractSource && return nothing
typeof(comp.input) <: Inport ? take!(comp.input) : nothing
end
"""
writeoutput!(comp::AbstractComponent, out)
Writes `out` to the output of `comp` if the `output` of `comp` is `Outport`. Otherwise, does `nothing`.
"""
function writeoutput!(comp::AbstractComponent, out)
typeof(comp) <: AbstractSink && return nothing
typeof(comp.output) <: Outport ? put!(comp.output, out) : nothing
end
"""
computeoutput(comp, x, u, t)
Computes the output of `comp` according to its `readout` if `readout` is not `nothing`. Otherwise, `nothing` is done. `x` is the state, `u` is the value of input, `t` is the time.
"""
function computeoutput end
computeoutput(comp::AbstractSource, x, u, t) = comp.readout(t)
computeoutput(comp::AbstractStaticSystem, x, u, t) =
typeof(comp.readout) <: Nothing ? nothing : comp.readout(u, t)
function computeoutput(comp::AbstractDynamicSystem, x, u, t)
typeof(comp.readout) <: Nothing && return nothing
typeof(u) <: Nothing ? comp.readout(x, u, t) : comp.readout(x, map(uu -> t -> uu, u), t)
end
# typeof(comp.readout) <: Nothing ? nothing : comp.readout(x, constructinput(comp, u, t), t)
computeoutput(comp::AbstractSink, x, u, t) = nothing
"""
evolve!(comp::AbstractSource, u, t)
Does nothing. `u` is the value of `input` and `t` is time.
evolve!(comp::AbstractSink, u, t)
Writes `t` to time buffer `timebuf` and `u` to `databuf` of `comp`. `u` is the value of `input` and `t` is time.
evolve!(comp::AbstractStaticSystem, u, t)
Writes `u` to `buffer` of `comp` if `comp` is an `AbstractMemory`. Otherwise, `nothing` is done. `u` is the value of `input` and `t` is time.
evolve!(comp::AbstractDynamicSystem, u, t)
Solves the differential equation of the system of `comp` for the time interval `(comp.t, t)` for the inital condition `x` where `x` is the current state of `comp` . `u` is the input function defined for `(comp.t, t)`. The `comp` is updated with the computed state and time `t`.
"""
function evolve! end
evolve!(comp::AbstractSource, u, t) = nothing
evolve!(comp::AbstractSink, u, t) = (write!(comp.timebuf, t); write!(comp.databuf, u); comp.sinkcallback(comp); nothing)
function evolve!(comp::AbstractStaticSystem, u, t)
if typeof(comp) <: AbstractMemory
timebuf = comp.timebuf
databuf = comp.databuf
write!(timebuf, t)
write!(databuf, u)
end
end
function evolve!(comp::AbstractDynamicSystem, u, t)
# For DDESystems, the problem for a time span of (t, t) cannot be solved.
# Thus, there will be no evolution in such a case.
integrator = comp.integrator
interpolator = integrator.sol.prob.p
update_interpolator!(interpolator, u, t)
comp.t == t && return comp.state
# Advance the system and update the system.
step!(integrator, t - comp.t, true)
comp.t = integrator.t
comp.state = integrator.u
# Return comp state
return comp.state
end
update_interpolator!(interp::Nothing) = nothing
update_interpolator!(interp::Nothing, u, t) = nothing
function update_interpolator!(interp::Interpolant, u, t)
write!(interp.timebuf, t)
write!(interp.databuf, u)
update!(interp)
end
##### Task management
"""
takestep!(comp::AbstractComponent)
Reads the time `t` from the `trigger` link of `comp`. If `comp` is an `AbstractMemory`, a backward step is taken. Otherwise, a forward step is taken. See also: [`forwardstep`](@ref), [`backwardstep`](@ref).
"""
function takestep!(comp::AbstractComponent)
t = readtime!(comp)
t === NaN && return t
typeof(comp) <: AbstractMemory ? backwardstep(comp, t) : forwardstep(comp, t)
end
"""
forwardstep(comp, t)
Makes `comp` takes a forward step. The input value `u` and state `x` of `comp` are read. Using `x`, `u` and time `t`, `comp` is evolved. The output `y` of `comp` is computed and written into the output bus of `comp`.
"""
function forwardstep(comp, t)
u = readinput!(comp)
x = evolve!(comp, u, t)
y = computeoutput(comp, x, u, t)
writeoutput!(comp, y)
applycallbacks(comp)
return t
end
"""
backwardstep(comp, t)
Reads the state `x`. Using the time `t` and `x`, computes and writes the ouput value `y` of `comp`. Then, the input value `u` is read and `comp` is evolved.
"""
function backwardstep(comp, t)
x = readstate(comp)
y = computeoutput(comp, x, nothing, t)
writeoutput!(comp, y)
u = readinput!(comp)
xn = evolve!(comp, u, t)
applycallbacks(comp)
return t
end
"""
launch(comp::AbstractComponent)
Returns a tuple of tasks so that `trigger` link and `output` bus of `comp` is drivable. When launched, `comp` is ready to be driven from its `trigger` link. See also: [`drive!(comp::AbstractComponent, t)`](@ref)
"""
function launch(comp::AbstractComponent)
@async begin
while true
takestep!(comp) === NaN && break
put!(comp.handshake, true)
end
typeof(comp) <: AbstractSink && close(comp)
end
end
"""
drive!(comp::AbstractComponent, t)
Writes `t` to the `trigger` link of `comp`. When driven, `comp` takes a step. See also: [`takestep!(comp::AbstractComponent)`](@ref)
"""
drive!(comp::AbstractComponent, t) = put!(comp.trigger, t)
"""
approve!(comp::AbstractComponent)
Read `handshake` link of `comp`. When not approved or `false` is read from the `handshake` link, the task launched for the `trigger` link of `comp` gets stuck during `comp` is taking step.
"""
approve!(comp::AbstractComponent) = take!(comp.handshake)
# """
# release(comp::AbstractComponent)
# Releases the `input` and `output` bus of `comp`.
# """
# function release(comp::AbstractComponent)
# typeof(comp) <: AbstractSource || typeof(comp.input) <: Nothing || release(comp.input)
# typeof(comp) <: AbstractSink || typeof(comp.output) <: Nothing || release(comp.output)
# return
# end
"""
terminate!(comp::AbstractComponent)
Closes the `trigger` link and `output` bus of `comp`.
"""
function terminate!(comp::AbstractComponent)
typeof(comp) <: AbstractSink || typeof(comp.output) <: Nothing || close(comp.output)
close(comp.trigger)
return
end
##### SubSystem interface
"""
launch(comp::AbstractSubSystem)
Launches all subcomponents of `comp`. See also: [`launch(comp::AbstractComponent)`](@ref)
"""
function launch(comp::AbstractSubSystem)
comptask = @async begin
while true
if takestep!(comp) === NaN
put!(comp.triggerport, fill(NaN, length(comp.components)))
break
end
put!(comp.handshake, true)
end
end
[launch.(comp.components)..., comptask]
end
"""
takestep!(comp::AbstractSubSystem)
Makes `comp` to take a step by making each subcomponent of `comp` take a step. See also: [`takestep!(comp::AbstractComponent)`](@ref)
"""
function takestep!(comp::AbstractSubSystem)
t = readtime!(comp)
t === NaN && return t
put!(comp.triggerport, fill(t, length(comp.components)))
all(take!(comp.handshakeport)) || @warn "Could not be approved in the subsystem"
# foreach(takestep!, comp.components)
# approve!(comp) || @warn "Could not be approved in the subsystem"
# put!(comp.handshake, true)
end
"""
drive!(comp::AbstractSubSystem, t)
Drives `comp` by driving each subcomponent of `comp`. See also: [`drive!(comp::AbstractComponent, t)`](@ref)
"""
drive!(comp::AbstractSubSystem, t) = foreach(component -> drive!(component, t), comp.components)
"""
approve!(comp::AbstractSubSystem)
Approves `comp` by approving each subcomponent of `comp`. See also: [`approve!(comp::AbstractComponent)`](@ref)
"""
approve!(comp::AbstractSubSystem) = all(approve!.(comp.components))
# """
# release(comp::AbstractSubSystem)
# Releases `comp` by releasing each subcomponent of `comp`. See also: [`release(comp::AbstractComponent)`](@ref)
# """
# function release(comp::AbstractSubSystem)
# foreach(release, comp.components)
# typeof(comp.input) <: Inport && release(comp.input)
# typeof(comp.output) <: Outport && release(comp.output)
# end
"""
terminate!(comp::AbstractSubSystem)
Terminates `comp` by terminating each subcomponent of `comp`. See also: [`terminate!(comp::AbstractComponent)`](@ref)
"""
terminate!(comp::AbstractSubSystem) = foreach(terminate!, comp.components)
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 10611 | # This file constains sink tools for the objects of Jusdl.
"""
@def_sink ex
where `ex` is the expression to define to define a new AbstractSink component type. The usage is as follows:
```julia
@def_sink struct MySink{T1,T2,T3,...,TN, A} <: AbstractSink
param1::T1 = param1_default # optional field
param2::T2 = param2_default # optional field
param3::T3 = param3_default # optional field
⋮
paramN::TN = paramN_default # optional field
action::A = action_function # mandatory field
end
```
Here, `MySink` has `N` parameters and `action` function
!!! warning
`action` function must have a method `action(sink::MySink, t, u)` where `t` is the time data and `u` is the data flowing into the sink.
!!! warning
New static system must be a subtype of `AbstractSink` to function properly.
# Example
```jldoctest
julia> @def_sink struct MySink{A} <: AbstractSink
action::A = actionfunc
end
julia> actionfunc(sink::MySink, t, u) = println(t, u)
actionfunc (generic function with 1 method)
julia> sink = MySink();
julia> sink.action(sink, ones(2), ones(2) * 2)
[1.0, 1.0][2.0, 2.0]
```
"""
macro def_sink(ex)
#= NOTE:
Generate the parameter names TR, HS, CB, ID, IP, PL, TB, DB, SCB of types of trigger, handshake, callbacks, id,
input, plugin, timebuf, databuf, sinkcallback by using `gensym` to avoid duplicate type parameter names so that
the users can parametrizde their types as
@def_sink mutable struct MySink{TR} <: AbstractSink
field::TR = nothing
end
Note that the parameter name of field is TR. But, since the parameter name TR of trigger of the compnent
is generated by `gensym`, we get rid of duplicate parameter names.
=#
ex.args[2].head == :(<:) && ex.args[2].args[2] == :AbstractSink ||
error("Invalid usage. The type should be a subtype of AbstractSink.\n$ex")
TR, HS, CB, ID, IP, PL, TB, DB, SCB = [gensym() for i in 1 : 9]
fields = quote
trigger::$(TR) = Inpin()
handshake::$(HS) = Outpin{Bool}()
callbacks::$(CB) = nothing
name::Symbol = Symbol()
id::$(ID) = Jusdl.uuid4()
input::$(IP) = Inport()
buflen::Int = 64
plugin::$(PL) = nothing
timebuf::$(TB) = Buffer(buflen)
databuf::$(DB) = length(input) == 1 ? Buffer(buflen) : Buffer(length(input), buflen)
sinkcallback::$(SCB) = plugin === nothing ?
Callback(sink->ishit(databuf), sink->action(sink, outbuf(timebuf), outbuf(databuf)), true, id) :
Callback(sink->ishit(databuf), sink->action(sink, outbuf(timebuf), plugin.process(outbuf(databuf))), true, id)
end, [TR, HS, CB, ID, IP, PL, TB, DB, SCB]
_append_common_fields!(ex, fields...)
deftype(ex)
end
##### Define sink library
# ----------------------------- Writer --------------------------------
"""
Writer(input=Inport(); buflen=64, plugin=nothing, callbacks=nothing, name=Symbol(uuid4()),
path=joinpath(tempdir(), string(name)))
Constructs a `Writer` whose input bus is `input`. `buflen` is the length of the internal buffer of `Writer`. If not nothing, `plugin` is used to processes the incomming data. `path` determines the path of the file of `Writer`.
!!! note
The type of `file` of `Writer` is [`JLD2`](https://github.com/JuliaIO/JLD2.jl).
!!! warning
When initialized, the `file` of `Writer` is closed. See [`open(writer::Writer)`](@ref) and [`close(writer::Writer)`](@ref).
"""
@def_sink mutable struct Writer{A, FL} <: AbstractSink
action::A = write!
path::String = joinpath(tempdir(), string(uuid4()))
file::FL = (f = jldopen(path, "w"); close(f); f)
end
"""
write!(writer, td, xd)
Writes `xd` corresponding to `xd` to the file of `writer`.
# Example
```julia
julia> w = Writer(Inport(1))
Writer(path:/tmp/e907d6ad-8db2-4c4a-9959-5b8d33d32156.jld2, nin:1)
julia> open(w)
Writer(path:/tmp/e907d6ad-8db2-4c4a-9959-5b8d33d32156.jld2, nin:1)
julia> write!(w, 0., 10.)
10.0
julia> write!(w, 1., 20.)
20.0
julia> w.file
JLDFile /tmp/e907d6ad-8db2-4c4a-9959-5b8d33d32156.jld2 (read/write)
├─🔢 0.0
└─🔢 1.0
julia> w.file[string(0.)]
10.0
```
"""
write!(writer::Writer, td, xd) = fwrite!(writer.file, td, xd)
fwrite!(file, td, xd) = file[string(td)] = xd
"""
read(writer::Writer, flatten=false)
Read the contents of the file of `writer` and returns the sorted content of the file. If `flatten` is `true`, the content is also flattened.
"""
read(writer::Writer; flatten=true) = fread(writer.file.path, flatten=flatten)
"""
fread(path::String)
Reads the content of `jld2` file and returns the sorted file content.
"""
function fread(path::String; flatten=false)
content = load(path)
data = SortedDict([(eval(Meta.parse(key)), val) for (key, val) in zip(keys(content), values(content))])
if flatten
t = vcat(reverse.(keys(data), dims=1)...)
if typeof(data) <: SortedDict{T1, T2, T3} where {T1, T2<:AbstractVector, T3}
x = vcat(reverse.(values(data), dims=1)...)
elseif typeof(data) <: SortedDict{T1, T2, T3} where {T1, T2<:AbstractMatrix, T3}
x = collect(hcat(reverse.(values(data), dims=2)...)')
end
return t, x
else
return data
end
end
flatten(content) = (collect(vcat(keys(content)...)), collect(vcat(values(content)...)))
"""
mv(writer::Writer, dst; force::Bool=false)
Moves the file of `writer` to `dst`. If `force` is `true`, the if `dst` is not a valid path, it is forced to be constructed.
# Example
```julia
julia> mkdir(joinpath(tempdir(), "testdir1"))
"/tmp/testdir1"
julia> mkdir(joinpath(tempdir(), "testdir2"))
"/tmp/testdir2"
julia> w = Writer(Inport(), path="/tmp/testdir1/myfile.jld2")
Writer(path:/tmp/testdir1/myfile.jld2, nin:1)
julia> mv(w, "/tmp/testdir2")
Writer(path:/tmp/testdir2/myfile.jld2, nin:1)
```
"""
function mv(writer::Writer, dst; force::Bool=false)
# id = writer.id
id = basename(writer.file.path)
dstpath = joinpath(dst, string(id))
srcpath = writer.file.path
mv(srcpath, dstpath, force=force)
writer.file.path = dstpath # Update the file path
writer
end
"""
cp(writer::Writer, dst; force=false, follow_symlinks=false)
Copies the file of `writer` to `dst`. If `force` is `true`, the if `dst` is not a valid path, it is forced to be constructed. If `follow_symlinks` is `true`, symbolinks are followed.
# Example
```julia
julia> mkdir(joinpath(tempdir(), "testdir1"))
"/tmp/testdir1"
julia> mkdir(joinpath(tempdir(), "testdir2"))
"/tmp/testdir2"
julia> w = Writer(Inport(), path="/tmp/testdir1")
Writer(path:/tmp/testdir1.jld2, nin:1)
julia> cp(w, "/tmp/testdir2")
Writer(path:/tmp/testdir2/1e72bad1-9800-4ca0-bccd-702afe75e555, nin:1)
```
"""
function cp(writer::Writer, dst; force=false, follow_symlinks=false)
# id = writer.id
id = basename(writer.file.path)
dstpath = joinpath(dst, string(id))
cp(writer.file.path, dstpath, force=force, follow_symlinks=follow_symlinks)
writer
end
"""
open(writer::Writer)
Opens `writer` by opening the its `file` in `read/write` mode. When `writer` is not openned, it is not possible to write data in `writer`. See also [`close(writer::Writer)`](@ref)
"""
open(writer::Writer) = (writer.file = jldopen(writer.file.path, "a"); writer)
"""
close(writer::Writer)
Closes `writer` by closing its `file`. When `writer` is closed, it is not possible to write data in `writer`. See also [`open(writer::Writer)`](@ref)
"""
close(writer::Writer) = (close(writer.file); writer)
# ----------------------------- Printer --------------------------------
"""
Printer(input=Inport(); buflen=64, plugin=nothing, callbacks=nothing, name=Symbol()) where T
Constructs a `Printer` with input bus `input`. `buflen` is the length of its internal `buflen`. `plugin` is data proccessing tool.
"""
@def_sink mutable struct Printer{A} <: AbstractSink
action::A = print
end
import Base.print
"""
print(printer::Printer, td, xd)
Prints `xd` corresponding to `xd` to the console.
"""
print(printer::Printer, td, xd) = print("For time", "[", td[1], " ... ", td[end], "]", " => ", xd, "\n")
"""
open(printer::Printer)
Does nothing. Just a common interface function ot `AbstractSink` interface.
"""
open(printer::Printer) = printer
"""
close(printer::Printer)
Does nothing. Just a common interface function ot `AbstractSink` interface.
"""
close(printer::Printer) = printer
# ----------------------------- Scope --------------------------------
"""
Scope(input=Inport(), args...; buflen::Int=64, plugin=nothing, callbacks=nothing, name=Symbol(), kwargs...)
Constructs a `Scope` with input bus `input`. `buflen` is the length of the internal buffer of `Scope`. `plugin` is the additional data processing tool. `args`,`kwargs` are passed into `plots(args...; kwargs...))`. See (https://github.com/JuliaPlots/Plots.jl) for more information.
!!! warning
When initialized, the `plot` of `Scope` is closed. See [`open(sink::Scope)`](@ref) and [`close(sink::Scope)`](@ref).
"""
@def_sink mutable struct Scope{A, PA, PK, PLT} <: AbstractSink
action::A = update!
pltargs::PA = ()
pltkwargs::PK = NamedTuple()
plt::PLT = plot(pltargs...; pltkwargs...)
end
"""
update!(s::Scope, x, yi)
Updates the series of the plot windows of `s` with `x` and `yi`.
"""
function update!(s::Scope, x, yi)
y = collect(hcat(yi...)')
plt = s.plt
subplots = plt.subplots
clear.(subplots)
plot!(plt, x, y, xlim=(x[1], x[end]), label="") # Plot the new series
gui()
end
clear(sp::Plots.Subplot) = popfirst!(sp.series_list) # Delete the old series
"""
close(sink::Scope)
Closes the plot window of the plot of `sink`.
"""
close(sink::Scope) = closeall()
"""
open(sink::Scope)
Opens the plot window for the plots of `sink`.
"""
open(sink::Scope) = Plots.isplotnull() ? (@warn "No current plots") : gui()
##### Pretty printing
show(io::IO, writer::Writer) = print(io, "Writer(path:$(writer.file.path), nin:$(length(writer.input)))")
show(io::IO, printer::Printer) = print(io, "Printer(nin:$(length(printer.input)))")
show(io::IO, scp::Scope) = print(io, "Scope(nin:$(length(scp.input)))")
##### Deprecated
# function unfasten!(sink::AbstractSink)
# callbacks = sink.callbacks
# sid = sink.id
# typeof(callbacks) <: AbstractVector && disable!(callbacks[callback.id == sid for callback in callbacks])
# typeof(callbacks) <: Callback && disable!(callbacks)
# sink
# end
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 5068 | # This file constains the Clock tools for time synchronization of DsSimulator.
import Base: iterate, take!, length
Generator(t0, dt, tf) =
Channel{promote_type(typeof(t0),typeof(dt),typeof(tf))}(channel -> foreach(t -> put!(channel, t), t0:dt:tf))
"""
Clock(t::Real, dt::Real, tf::Real)
Constructs a `Clock` with starting time `t`, final time `tf` and sampling inteval `dt`. When iterated, the `Clock` returns its current time.
!!! warning
When constructed, `Clock` is not running. To take clock ticks from `Clock`, the `Clock` must be setted. See [`take!(clk::Clock)`](@ref) and [`set!`](@ref)
"""
mutable struct Clock{T, CB}
t::T
ti::T
dt::T
tf::T
generator::Channel{T}
paused::Bool
callbacks::CB
name::Symbol
uuid::UUID
Clock{T}(ti::T, dt::T, tf::T; callbacks::CB=nothing, name=Symbol()) where {T, CB} =
new{T, CB}(ti, ti, dt, tf, Channel{T}(0), false, callbacks, name, uuid4())
end
Clock(t::T, dt::T, tf::T; kwargs...) where T = Clock{T}(t, dt, tf; kwargs...)
Clock(t=0., dt=0.01, tf=1.; kwargs...) = Clock(promote(t, dt, tf)...; kwargs...)
show(io::IO, clk::Clock) = print(io,
"Clock(t:$(clk.t), dt:$(clk.dt), tf:$(clk.tf), paused:$(clk.paused), isrunning:$(isrunning(clk)))")
##### Reading from clock
"""
take!(clk::Clock)
Takes a values from `clk`.
# Example
```jldoctest
julia> clk = Clock(0., 0.1, 0.5)
Clock(t:0.0, dt:0.1, tf:0.5, paused:false, isrunning:false)
julia> set!(clk)
Clock(t:0.0, dt:0.1, tf:0.5, paused:false, isrunning:true)
julia> for i in 0 : 5
@show take!(clk)
end
take!(clk) = 0.0
take!(clk) = 0.1
take!(clk) = 0.2
take!(clk) = 0.3
take!(clk) = 0.4
take!(clk) = 0.5
```
"""
function take!(clk::Clock)
if ispaused(clk)
@warn "Clock is paused."
return clk.t
end
if isoutoftime(clk)
@warn "Clock is out of time."
return clk.t
end
##
## NOTE: If this code block is uncommented, a bug occurs
## The same clock times is sent multiple time.
##
# if !isrunning(clk)
# @warn "Clock is not running."
# return clk.t
# end
clk.t = take!(clk.generator)
applycallbacks(clk)
clk.t
end
##### Clock state check
"""
isrunning(clk::Clock)
Returns `true` if `clk` if `clk` is running.
"""
isrunning(clk::Clock) = isready(clk.generator)
"""
ispaused(clk::Clock)
Returns `true` if `clk` is paused. When paused, the currnent time of `clk` is not advanced. See also [`pause!(clk::Clock)`](@ref)
"""
ispaused(clk::Clock) = clk.paused
"""
isoutoftime(clk::Clock)
Returns `true` if `clk` is out of time, i.e., the current time of `clk` exceeds its final time.
"""
isoutoftime(clk::Clock) = clk.t >= clk.tf
##### Controlling clock.
"""
set(clk::Clock, t::Real, dt::Real, tf::Real)
Sets `clk` for current clock time `t`, sampling time `dt` and final time `tf`. After the set, it is possible to take clock tick from `clk`. See also [`take!(clk::Clock)`](@ref)
# Example
```jldoctest
julia> clk = Clock(0., 0.1, 0.5)
Clock(t:0.0, dt:0.1, tf:0.5, paused:false, isrunning:false)
julia> set!(clk)
Clock(t:0.0, dt:0.1, tf:0.5, paused:false, isrunning:true)
julia> take!(clk)
0.0
```
"""
function set!(clk::Clock, t::Real=clk.ti, dt::Real=clk.dt, tf::Real=clk.tf)
# set!(clk, Generator(t, dt, tf))
clk.generator = Generator(t, dt, tf)
clk.t = t
clk.dt = dt
clk.tf = tf
clk.paused = false
clk
end
# function set!(clk::Clock, generator::Channel=Generator(clk.ti, clk.dt, clk.tf))
# clk.generator = generator
# clk.paused = false
# clk
# end
"""
stop!(clk::Clock)
Unsets `clk`. After the stpp, it is possible to take clock ticks from `clk`. See also [`take!(clk::Clock)`](@ref)
"""
function stop!(clk::Clock)
set!(clk, Channel{typeof(clk.t)}(0))
clk
end
"""
pause!(clk::Clock)
Pauses `clk`. When paused, the current time of `clk` does not advance.
# Example
```julia
julia> clk = Clock(0., 0.1, 0.5);
julia> set!(clk);
julia> for i = 1 : 5
i > 3 && pause!(clk)
@show take!(clk)
end
take!(clk) = 0.0
take!(clk) = 0.1
take!(clk) = 0.2
┌ Warning: Clock is paused.
└ @ Jusdl ~/.julia/dev/Jusdl/src/components/sources/clock.jl:61
take!(clk) = 0.2
┌ Warning: Clock is paused.
└ @ Jusdl ~/.julia/dev/Jusdl/src/components/sources/clock.jl:61
take!(clk) = 0.2
```
"""
pause!(clk::Clock) = (clk.paused = true; clk)
##### Iterating clock.
"""
iterate(clk::Clock[, t=clk.t)
Iterationk interface for `clk`. `clk` can be iterated in a loop.
# Example
```jldoctest
julia> clk = Clock(0., 0.1, 0.3);
julia> set!(clk)
Clock(t:0.0, dt:0.1, tf:0.3, paused:false, isrunning:true)
julia> for t in clk
@show t
end
t = 0.0
t = 0.1
t = 0.2
t = 0.3
```
"""
iterate(clk::Clock, t=clk.t) = isready(clk.generator) ? (take!(clk), clk.t) : nothing
##### ProgressMeter interface.
### This `length` method is implemented for [ProgressMeter](https://github.com/timholy/ProgressMeter.jl)
length(clk::Clock) = length(clk.t:clk.dt:clk.tf)
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 10843 | # This file contains the function generator tools to drive other tools of DsSimulator.
import UUIDs: uuid4
"""
@def_source ex
where `ex` is the expression to define to define a new AbstractSource component type. The usage is as follows:
```julia
@def_source struct MySource{T1,T2,T3,...,TN,OP, RO} <: AbstractSource
param1::T1 = param1_default # optional field
param2::T2 = param2_default # optional field
param3::T3 = param3_default # optional field
⋮
paramN::TN = paramN_default # optional field
output::OP = output_default # mandatory field
readout::RO = readout_function # mandatory field
end
```
Here, `MySource` has `N` parameters, an `output` port and a `readout` function.
!!! warning
`output` and `readout` are mandatory fields to define a new source. The rest of the fields are the parameters of the source.
!!! warning
`readout` must be a single-argument function, i.e. a fucntion of time `t`.
!!! warning
New source must be a subtype of `AbstractSource` to function properly.
# Example
```jldoctest
julia> @def_source struct MySource{OP, RO} <: AbstractSource
a::Int = 1
b::Float64 = 2.
output::OP = Outport()
readout::RO = t -> (a + b) * sin(t)
end
julia> gen = MySource();
julia> gen.a
1
julia> gen.output
1-element Outport{Outpin{Float64}}:
Outpin(eltype:Float64, isbound:false)
```
"""
macro def_source(ex)
#= NOTE:
Generate the parameter names TR, HS, CB, ID of types of trigger, handshake, callbacks, id by using
`gensym` to avoid duplicate type parameter names so that the users can parametrizde their types as
@def_source struct Mygen{RO, TR} <: AbstractSource
readout::RO = t -> sin(t)
output::TR = Outport()
end
Note that the parameter name of output is TR. But, since the parameter name TR of trigger of the compnent
is generated by `gensym`, we get rid of duplicate parameter names.
=#
ex.args[2].head == :(<:) && ex.args[2].args[2] == :AbstractSource ||
error("Invalid usage. The type should be a subtype of AbstractSource.\n$ex")
TR, HS, CB, ID = [gensym() for i in 1 : 4]
fields = quote
trigger::$(TR) = Inpin()
handshake::$(HS) = Outpin{Bool}()
callbacks::$(CB) = nothing
name::Symbol = Symbol()
id::$(ID) = Jusdl.uuid4()
end, [TR, HS, CB, ID]
_append_common_fields!(ex, fields...)
deftype(ex)
end
##### Define Sources library
"""
FunctionGenerator(; readout, output=Outport())
Constructs a generic function generator with `readout` function and `output` port.
# Example
```jldoctest
julia> gen = FunctionGenerator(readout = t -> [t, 2t], output = Outport(2));
julia> gen.readout(1.)
2-element Array{Float64,1}:
1.0
2.0
```
"""
@def_source struct FunctionGenerator{RO, OP} <: AbstractSource
readout::RO
output::OP = Outport(1)
end
@doc raw"""
SinewaveGenerator(;amplitude=1., frequency=1., phase=0., delay=0., offset=0.)
Constructs a `SinewaveGenerator` with output of the form
```math
x(t) = A sin(2 \pi f (t - \tau) + \phi) + B
```
where ``A`` is `amplitude`, ``f`` is `frequency`, ``\tau`` is `delay` and ``\phi`` is `phase` and ``B`` is `offset`.
"""
@def_source struct SinewaveGenerator{RO, OP} <: AbstractSource
amplitude::Float64 = 1.
frequency::Float64 = 1.
phase::Float64 = 0.
delay::Float64 = 0.
offset::Float64 = 0.
output::OP = Outport()
readout::RO = (t, amplitude=amplitude, frequency=frequency, delay=delay, offset=offset) ->
amplitude * sin(2 * pi * frequency * (t - delay) + phase) + offset
end
@doc raw"""
DampedSinewaveGenerator(;amplitude=1., decay=-0.5, frequency=1., phase=0., delay=0., offset=0.)
Constructs a `DampedSinewaveGenerator` which generates outputs of the form
```math
x(t) = A e^{\alpha t} sin(2 \pi f (t - \tau) + \phi) + B
```
where ``A`` is `amplitude`, ``\alpha`` is `decay`, ``f`` is `frequency`, ``\phi`` is `phase`, ``\tau`` is `delay` and ``B`` is `offset`.
"""
@def_source struct DampedSinewaveGenerator{RO, OP} <: AbstractSource
amplitude::Float64 = 1.
decay::Float64 = 0.5
frequency::Float64 = 1.
phase::Float64 = 0.
delay::Float64 = 0.
offset::Float64 = 0.
output::OP = Outport()
readout::RO = (t, amplitude=amplitude, decay=decay, frequency=frequency, phase=phase, delay=delay, offset=offset) ->
amplitude * exp(decay * t) * sin(2 * pi * frequency * (t - delay)) + offset
end
@doc raw"""
SquarewaveGenerator(;level1=1., level2=0., period=1., duty=0.5, delay=0.)
Constructs a `SquarewaveGenerator` with output of the form
```math
x(t) = \left\{\begin{array}{lr}
A_1 + B, & kT + \tau \leq t \leq (k + \alpha) T + \tau \\
A_2 + B, & (k + \alpha) T + \tau \leq t \leq (k + 1) T + \tau
\end{array} \right. \quad k \in Z
```
where ``A_1``, ``A_2`` is `level1` and `level2`, ``T`` is `period`, ``\tau`` is `delay` ``\alpha`` is `duty`.
"""
@def_source struct SquarewaveGenerator{OP, RO} <: AbstractSource
high::Float64 = 1.
low::Float64 = 0.
period::Float64 = 1.
duty::Float64 = 0.5
delay::Float64 = 0.
output::OP = Outport()
readout::RO = (t, high=high, low=low, period=period, duty=duty, delay=delay) ->
t <= delay ? low : ( ((t - delay) % period <= duty * period) ? high : low )
end
@doc raw"""
TriangularwaveGenerator(;amplitude=1, period=1, duty=0.5, delay=0, offset=0)
Constructs a `TriangularwaveGenerator` with output of the form
```math
x(t) = \left\{\begin{array}{lr}
\dfrac{A t}{\alpha T} + B, & kT + \tau \leq t \leq (k + \alpha) T + \tau \\[0.25cm]
\dfrac{A (T - t)}{T (1 - \alpha)} + B, & (k + \alpha) T + \tau \leq t \leq (k + 1) T + \tau
\end{array} \right. \quad k \in Z
```
where ``A`` is `amplitude`, ``T`` is `period`, ``\tau`` is `delay` ``\alpha`` is `duty`.
"""
@def_source struct TriangularwaveGenerator{OP, RO} <: AbstractSource
amplitude::Float64 = 1.
period::Float64 = 1.
duty::Float64 = 0.5
delay::Float64 = 0.
offset::Float64 = 0.
output::OP = Outport()
readout::RO = (t, amplitude=amplitude, period=period, duty=duty, delay=delay, offset=offset) -> begin
if t <= delay
return offset
else
t = (t - delay) % period
if t <= duty * period
amplitude / (duty * period) * t + offset
else
(amplitude * (period - t)) / (period * (1 - duty)) + offset
end
end
end
end
@doc raw"""
ConstantGenerator(;amplitude=1.)
Constructs a `ConstantGenerator` with output of the form
```math
x(t) = A
```
where ``A`` is `amplitude.
"""
@def_source struct ConstantGenerator{OP, RO} <: AbstractSource
amplitude::Float64 = 1.
output::OP = Outport()
readout::RO = (t, amplitude=amplitude) -> amplitude
end
@doc raw"""
RampGenerator(;scale=1, delay=0.)
Constructs a `RampGenerator` with output of the form
```math
x(t) = \alpha (t - \tau)
```
where ``\alpha`` is the `scale` and ``\tau`` is `delay`.
"""
@def_source struct RampGenerator{OP, RO} <: AbstractSource
scale::Float64 = 1.
delay::Float64 = 0.
offset::Float64 = 0.
output::OP = Outport()
readout::RO = (t, scale=scale, delay=delay, offset=offset) -> scale * (t - delay) + offset
end
@doc raw"""
StepGenerator(;amplitude=1, delay=0, offset=0)
Constructs a `StepGenerator` with output of the form
```math
x(t) = \left\{\begin{array}{lr}
B, & t \leq \tau \\
A + B, & t > \tau
\end{array} \right.
```
where ``A`` is `amplitude`, ``B`` is the `offset` and ``\tau`` is the `delay`.
"""
@def_source struct StepGenerator{OP, RO} <: AbstractSource
amplitude::Float64 = 1.
delay::Float64 = 0.
offset::Float64 = 0.
output::OP = Outport()
readout::RO = (t, amplitude=amplitude, delay=delay, offset=offset) ->
t - delay >= 0 ? amplitude + offset : offset
end
@doc raw"""
ExponentialGenerator(;scale=1, decay=-1, delay=0.)
Constructs an `ExponentialGenerator` with output of the form
```math
x(t) = A e^{\alpha (t - \tau)}
```
where ``A`` is `scale`, ``\alpha`` is `decay` and ``\tau`` is `delay`.
"""
@def_source struct ExponentialGenerator{OP, RO} <: AbstractSource
scale::Float64 = 1.
decay::Float64 = -1.
delay::Float64 = 0.
offset::Float64 = 0.
output::OP = Outport()
readout::RO = (t, scale=scale, decay=decay, delay=delay, offset=offset) -> scale * exp(decay * (t - delay)) + offset
end
@doc raw"""
DampedExponentialGenerator(;scale=1, decay=-1, delay=0.)
Constructs an `DampedExponentialGenerator` with outpsuts of the form
```math
x(t) = A (t - \tau) e^{\alpha (t - \tau)}
```
where ``A`` is `scale`, ``\alpha`` is `decay`, ``\tau`` is `delay`.
"""
@def_source struct DampedExponentialGenerator{OP, RO} <: AbstractSource
scale::Float64 = 1.
decay::Float64 = -1.
delay::Float64 = 0.
offset::Float64 = 0.
output::OP = Outport()
readout::RO = (t, scale=scale, decay=decay, delay=delay, offset=offset) ->
scale * (t - delay) * exp(decay * (t - delay)) + offset
end
##### Pretty-Printing of generators.
show(io::IO, gen::FunctionGenerator) = print(io,
"FunctionGenerator(readout:$(gen.readout), output:$(gen.output))")
show(io::IO, gen::SinewaveGenerator) = print(io,
"SinewaveGenerator(amp:$(gen.amplitude), freq:$(gen.frequency), phase:$(gen.phase), ",
"offset:$(gen.offset), delay:$(gen.delay))")
show(io::IO, gen::DampedSinewaveGenerator) = print(io,
"DampedSinewaveGenerator(amp:$(gen.amplitude), decay:$(gen.delay), freq:$(gen.frequency), ",
"phase:$(gen.phase), delay:$(gen.delay), offset:$(gen.offset))")
show(io::IO, gen::SquarewaveGenerator) = print(io,
"SquarewaveGenerator(high:$(gen.high), low:$(gen.low), period:$(gen.period), duty:$(gen.duty), ",
"delay:$(gen.delay))")
show(io::IO, gen::TriangularwaveGenerator) = print(io,
"TriangularwaveGenerator(amp:$(gen.amplitude), period:$(gen.period), duty:$(gen.duty), ",
"delay:$(gen.delay), offset:$(gen.offset))")
show(io::IO, gen::ConstantGenerator) = print(io,
"ConstantGenerator(amp:$(gen.amplitude))")
show(io::IO, gen::RampGenerator) = print(io, "RampGenerator(scale:$(gen.scale), delay:$(gen.delay))")
show(io::IO, gen::StepGenerator) = print(io,
"StepGenerator(amp:$(gen.amplitude), delay:$(gen.delay), offset:$(gen.offset))")
show(io::IO, gen::ExponentialGenerator) = print(io,
"ExponentialGenerator(scale:$(gen.scale), decay:$(gen.decay), delay:$(gen.delay))")
show(io::IO, gen::DampedExponentialGenerator) = print(io,
"DampedExponentialGenerator(scale:$(gen.scale), decay:$(gen.decay), delay:$(gen.delay))")
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 8983 | # This file includes DAESystems
import DifferentialEquations: DAEProblem
import Sundials: IDA
import UUIDs: uuid4
"""
@def_dae_system ex
where `ex` is the expression to define to define a new AbstractDAESystem component type. The usage is as follows:
```julia
@def_dae_system mutable struct MyDAESystem{T1,T2,T3,...,TN,OP,RH,RO,ST,IP,OP} <: AbstractDAESystem
param1::T1 = param1_default # optional field
param2::T2 = param2_default # optional field
param3::T3 = param3_default # optional field
⋮
paramN::TN = paramN_default # optional field
righthandside::RH = righthandside_function # mandatory field
readout::RO = readout_function # mandatory field
state::ST = state_default # mandatory field
stateder::ST = stateder_default # mandatory field
diffvars::Vector{Bool} = diffvars_default # mandatory field
input::IP = input_default # mandatory field
output::OP = output_default # mandatory field
end
```
Here, `MyDAESystem` has `N` parameters. `MyDAESystem` is represented by the `righthandside` and `readout` function. `state`, 'stateder`, `diffvars`, `input` and `output` is the initial state, initial value of differential variables, vector signifing differetial variables, input port and output port of `MyDAESystem`.
!!! warning
`righthandside` must have the signature
```julia
function righthandside(out, dx, x, u, t, args...; kwargs...)
out .= .... # update out
end
```
and `readout` must have the signature
```julia
function readout(x, u, t)
y = ...
return y
end
```
!!! warning
New DAE system must be a subtype of `AbstractDAESystem` to function properly.
# Example
```jldoctest
julia> @def_dae_system mutable struct MyDAESystem{RH, RO, ST, IP, OP} <: AbstractDAESystem
righthandside::RH = function sfuncdae(out, dx, x, u, t)
out[1] = x[1] + 1 - dx[1]
out[2] = (x[1] + 1) * x[2] + 2
end
readout::RO = (x,u,t) -> x
state::ST = [1., -1]
stateder::ST = [2., 0]
diffvars::Vector{Bool} = [true, false]
input::IP = nothing
output::OP = Outport(1)
end
julia> ds = MyDAESystem();
```
"""
macro def_dae_system(ex)
#= NOTE:
Generate the parameter names TR, HS, CB, ID, MA, MK, SA, SK, AL, IT of types of trigger, handshake, callbacks,
id, modelargs, modelkwargs, solverargs, solverkwargs, alg, integrator by using `gensym` to avoid duplicate type
parameter names so that the users can parametrizde their types as
@def_dae_system mutable struct MyDAESystem{RH, RO, ST, IP, TR} <: AbstractDAESystem
righthandside::RH
readout::RO
state::ST
stateder::ST
diffvars::Vector{Bool}
input::IP
output::TR
end
Note that the parameter name of output is TR. But, since the parameter name TR of trigger of the compnent
is generated by `gensym`, we get rid of duplicate parameter names.
=#
checksyntax(ex, :AbstractDAESystem)
TR, HS, CB, ID, MA, MK, SA, SK, AL, IT = [gensym() for i in 1 : 10]
fields = quote
trigger::$(TR) = Inpin()
handshake::$(HS) = Outpin{Bool}()
callbacks::$(CB) = nothing
name::Symbol = Symbol()
id::$(ID) = Jusdl.uuid4()
t::Float64 = 0.
modelargs::$(MA) = ()
modelkwargs::$(MK) = NamedTuple()
solverargs::$(SA) = ()
solverkwargs::$(SK) = NamedTuple()
alg::$(AL) = Jusdl.IDA()
integrator::$(IT) = Jusdl.construct_integrator(Jusdl.DAEProblem, input, righthandside, state, t, modelargs,
solverargs; alg=alg, stateder=stateder, modelkwargs=(;
zip((keys(modelkwargs)..., :differential_vars), (values(modelkwargs)..., diffvars))...),
solverkwargs=solverkwargs, numtaps=3)
end, [TR, HS, CB, ID, MA, MK, SA, SK, AL, IT]
_append_common_fields!(ex, fields...)
deftype(ex)
end
##### Defien DAE system library
"""
DAESystem(; righthandside, readout, state, stateder, diffvars, input, output)
Constructs a generic DAE system.
# Example
```jldoctest
julia> function sfuncdae(out, dx, x, u, t)
out[1] = x[1] + 1 - dx[1]
out[2] = (x[1] + 1) * x[2] + 2
end;
julia> ofuncdae(x, u, t) = x;
julia> x0 = [1., -1];
julia> dx0 = [2., 0.];
julia> DAESystem(righthandside=sfuncdae, readout=ofuncdae, state=x0, input=nothing, output=Outport(1), diffvars=[true, false], stateder=dx0)
DAESystem(righthandside:sfuncdae, readout:ofuncdae, state:[1.0, -1.0], t:0.0, input:nothing, output:Outport(numpins:1, eltype:Outpin{Float64}))
```
"""
@def_dae_system mutable struct DAESystem{RH, RO, ST, IP, OP} <: AbstractDAESystem
righthandside::RH
readout::RO
state::ST
stateder::ST
diffvars::Vector{Bool}
input::IP
output::OP
end
@doc raw"""
RobertsonSystem()
Constructs a Robertson systme with the dynamcis
```math
\begin{array}{l}
\dot{x}_1 = -k_1 x_1 + k_3 x_2 x_3 \\[0.25cm]
\dot{x}_2 = k_1 x_1 - k_2 x_2^2 - k_3 x_2 x_3 \\[0.25cm]
1 = x_1 + x_2 + x_3
\end{array}
```
"""
@def_dae_system mutable struct RobertsonSystem{RH, RO, IP, OP} <: AbstractDAESystem
k1::Float64 = 0.04
k2::Float64 = 3e7
k3::Float64 = 1e4
righthandside::RH = function robertsonrhs(out, dx, x, u, t)
out[1] = -k1 * x[1] + k3 * x[2] * x[3] - dx[1]
out[2] = k1 * x[1] - k2 * x[2]^2 - k3 * x[2] * x[3] - dx[2]
out[3] = x[1] + x[2] + x[3] - 1
end
rightout::RO = (x, u, t) -> x[1:2]
state::Vector{Float64} = [1., 0., 0.]
stateder::Vector{Float64} = [-k1, k1, 0.]
diffvars::Vector{Bool} = [true, true, false]
input::IP = nothing
output::OP = Outport(2)
end
@doc raw"""
PendulumSystem()
Constructs a Pendulum systme with the dynamics
```math
\begin{array}{l}
\dot{x}_1 = x_3 \\[0.25cm]
\dot{x}_2 = x_4 \\[0.25cm]
\dot{x}_3 = -\dfrac{F}{m l} x_1 \\[0.25cm]
\dot{x}_4 = g \dfrac{F}{l} x_2 \\[0.25cm]
0 = x_1^2 + x_2^2 - l^2
\end{array}
```
where ``F`` is the external force, ``l`` is the length, ``m`` is the mass and ``g`` is the accelaration of gravity.
"""
@def_dae_system mutable struct PendulumSystem{RH, RO, IP, OP} <: AbstractDAESystem
F::Float64 = 1.
l::Float64 = 1.
g::Float64 = 9.8
m::Float64 = 1.
righthandside::RH = function pendulumrhs(out, dx, x, u, t)
out[1] = x[3] - dx[1]
out[2] = x[4] - dx[2]
out[3] = - F / (m * l) * x[1] - dx[3]
out[4] = g * F / l * x[2] - dx[4]
out[5] = x[1]^2 + x[2]^2 - l^2
end
readout::RO = (x, u, t) -> x[1:4]
state::Vector{Float64} = [1., 0., 0., 0., 0.]
stateder::Vector{Float64} = [0., 0., -1., 0., 0.]
diffvars::Vector{Bool} = [true, true, true, true, false]
input::IP = nothing
output::OP = Outport(4)
end
@doc raw"""
RLCSystem()
Construsts a RLC system with the dynamics
```math
\begin{array}{l}
\dot{x}_1 = x_3 \\[0.25cm]
\dot{x}_2 = x_4 \\[0.25cm]
\dot{x}_3 = -\dfrac{F}{m l} x_1 \\[0.25cm]
\dot{x}_4 = g \dfrac{F}{l} x_2 \\[0.25cm]
0 = x_1^2 + x_2^2 - l^2
\end{array}
```
where ``F`` is the external force, ``l`` is the length, ``m`` is the mass and ``g`` is the accelaration of gravity.
"""
@def_dae_system mutable struct RLCSystem{RH, RO, IP, OP} <: AbstractDAESystem
R::Float64 = 1.
L::Float64 = 1.
C::Float64 = 1.
righthandside::RH = function pendulumrhs(out, dx, x, u, t)
out[1] = 1 / C * x[4] - dx[1]
out[2] = 1 / L * x[4] - dx[2]
out[3] = x[3] + R * x[5]
out[4] = x[1] + x[2] + x[3] + u[1](t)
out[5] = x[4] - x[5]
end
readout::RO = (x, u, t) -> x[1:2]
state::Vector{Float64} = [0., 0., 0., 0., 0.]
stateder::Vector{Float64} = [0., 0., 0., 0., 0.]
diffvars::Vector{Bool} = [true, true, false, false, false]
input::IP = Inport(1)
output::OP = Outport(2)
end
##### Pretty printing
show(io::IO, ds::DAESystem) = print(io,
"DAESystem(righthandside:$(ds.righthandside), readout:$(ds.readout), state:$(ds.state), t:$(ds.t), ",
"input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::RobertsonSystem) = print(io,
"RobersonSystem(k1:$(ds.k1), k2:$(ds.k2), k2:$(ds.k3), state:$(ds.state), t:$(ds.t), ",
"input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::PendulumSystem) = print(io,
"PendulumSystem(F:$(ds.F), m:$(ds.m), l:$(ds.l), g:$(ds.g), state:$(ds.state), t:$(ds.t), ",
"input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::RLCSystem) = print(io,
"RLCSystem(R:$(ds.R), L:$(ds.L), C:$(ds.C), state:$(ds.state), t:$(ds.t), ",
"input:$(ds.input), output:$(ds.output))")
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 6655 | # This file includes DDESystems
import DifferentialEquations: MethodOfSteps, Tsit5
import UUIDs: uuid4
"""
@def_dde_system ex
where `ex` is the expression to define to define a new AbstractDDESystem component type. The usage is as follows:
```julia
@def_dde_system mutable struct MyDDESystem{T1,T2,T3,...,TN,OP,RH,RO,ST,IP,OP} <: AbstractDDESystem
param1::T1 = param1_default # optional field
param2::T2 = param2_default # optional field
param3::T3 = param3_default # optional field
⋮
paramN::TN = paramN_default # optional field
constlags::CL = constlags_default # mandatory field
depslags::DL = depslags_default # mandatory field
righthandside::RH = righthandside_function # mandatory field
history::HST = history_function # mandatory field
readout::RO = readout_function # mandatory field
state::ST = state_default # mandatory field
input::IP = input_defauult # mandatory field
output::OP = output_default # mandatory field
end
```
Here, `MyDDESystem` has `N` parameters. `MyDDESystem` is represented by the `righthandside` and `readout` function. `state`, `input` and `output` is the state, input port and output port of `MyDDESystem`.
!!! warning
`righthandside` must have the signature
```julia
function righthandside(dx, x, u, t, args...; kwargs...)
dx .= .... # update dx
end
```
and `readout` must have the signature
```julia
function readout(x, u, t)
y = ...
return y
end
```
!!! warning
New DDE system must be a subtype of `AbstractDDESystem` to function properly.
# Example
```jldoctest
julia> _delay_feedback_system_cache = zeros(1)
1-element Array{Float64,1}:
0.0
julia> _delay_feedback_system_tau = 1.
1.0
julia> _delay_feedback_system_constlags = [1.]
1-element Array{Float64,1}:
1.0
julia> _delay_feedback_system_history(cache, u, t) = (cache .= 1.)
_delay_feedback_system_history (generic function with 1 method)
julia> function _delay_feedback_system_rhs(dx, x, h, u, t,
cache=_delay_feedback_system_cache, τ=_delay_feedback_system_tau)
h(cache, u, t - τ) # Update cache
dx[1] = cache[1] + x[1]
end
_delay_feedback_system_rhs (generic function with 3 methods)
julia> @def_dde_system mutable struct MyDDESystem{RH, HST, RO, IP, OP} <: AbstractDDESystem
constlags::Vector{Float64} = _delay_feedback_system_constlags
depslags::Nothing = nothing
righthandside::RH = _delay_feedback_system_rhs
history::HST = _delay_feedback_system_history
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(1)
input::IP = nothing
output::OP = Outport(1)
end
julia> ds = MyDDESystem();
```
"""
macro def_dde_system(ex)
#= NOTE:
Generate the parameter names TR, HS, CB, ID, MA, MK, SA, SK, AL, IT of types of trigger, handshake, callbacks,
id, modelargs, modelkwargs, solverargs, solverkwargs, alg, integrator by using `gensym` to avoid duplicate type
parameter names so that the users can parametrizde their types as
@def_dde_system mutable struct MyDDESystem{CL, DL, RH, HST, RO, ST, IP, TR} <: AbstractDDESystem
constlags::CL
depslags::DL
righthandside::RH
history::HST
readout::RO
state::ST
input::IP
output::TR
end
Note that the parameter name of output is TR. But, since the parameter name TR of trigger of the compnent
is generated by `gensym`, we get rid of duplicate parameter names.
=#
checksyntax(ex, :AbstractDDESystem)
TR, HS, CB, ID, MA, MK, SA, SK, AL, IT = [gensym() for i in 1 : 10]
fields = quote
trigger::$(TR) = Inpin()
handshake::$(HS) = Outpin{Bool}()
callbacks::$(CB) = nothing
name::Symbol = Symbol()
id::$(ID) = Jusdl.uuid4()
t::Float64 = 0.
modelargs::$(MA) = ()
modelkwargs::$(MK) = NamedTuple()
solverargs::$(SA) = ()
solverkwargs::$(SK) = NamedTuple()
alg::$(AL) = Jusdl.MethodOfSteps(Jusdl.Tsit5())
integrator::$(IT) = Jusdl.construct_integrator(
Jusdl.DDEProblem, input, (righthandside, history), state, t, modelargs, solverargs;
alg=alg, modelkwargs=(;
zip(
(keys(modelkwargs)..., :constant_lags, :dependent_lags),
(values(modelkwargs)..., constlags, depslags))...
),
solverkwargs=solverkwargs, numtaps=3)
end, [TR, HS, CB, ID, MA, MK, SA, SK, AL, IT]
_append_common_fields!(ex, fields...)
deftype(ex)
end
##### Define DDE system library.
"""
DDESystem(; constantlags, depslags, righthandside, history, readout, state, input, output)
Construct a generic DDE system
"""
@def_dde_system mutable struct DDESystem{CL, DL, RH, HST, RO, ST, IP, OP} <: AbstractDDESystem
constlags::CL
depslags::DL
righthandside::RH
history::HST
readout::RO
state::ST
input::IP
output::OP
end
"""
DDESystem(; constantlags, depslags, righthandside, history, readout, state, input, output)
Constructs DelayFeedbackSystem
"""
@def_dde_system mutable struct DelayFeedbackSystem{RH, HST, RO, IP, OP} <: AbstractDDESystem
constlags::Vector{Float64} = Jusdl._delay_feedback_system_constlags
depslags::Nothing = nothing
righthandside::RH = Jusdl._delay_feedback_system_rhs
history::HST = Jusdl._delay_feedback_system_history
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(1)
input::IP = nothing
output::OP = Outport(1)
end
_delay_feedback_system_cache = zeros(1)
_delay_feedback_system_tau = 1.
_delay_feedback_system_constlags = [1.]
_delay_feedback_system_history(cache, u, t) = (cache .= 1.)
function _delay_feedback_system_rhs(dx, x, h, u, t,
cache=Jusdl._delay_feedback_system_cache, τ=Jusdl._delay_feedback_system_tau)
h(cache, u, t - τ) # Update cache
dx[1] = cache[1] + x[1]
end
##### Pretty-printing
show(io::IO, ds::DDESystem) = print(io,
"DDESystem(righthandside:$(ds.righthandside), readout:$(ds.readout), state:$(ds.state), t:$(ds.t), ",
"input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::DelayFeedbackSystem) = print(io,
"DelayFeedbackSystem(state:$(ds.state), t:$(ds.t), input:$(ds.input), output:$(ds.output))")
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 10622 | # This file includes the Discrete Systems
import DifferentialEquations: FunctionMap, DiscreteProblem
import UUIDs: uuid4
"""
@def_discrete_system ex
where `ex` is the expression to define to define a new AbstractDiscreteSystem component type. The usage is as follows:
```julia
@def_discrete_system mutable struct MyDiscreteSystem{T1,T2,T3,...,TN,OP,RH,RO,ST,IP,OP} <: AbstractDiscreteSystem
param1::T1 = param1_default # optional field
param2::T2 = param2_default # optional field
param3::T3 = param3_default # optional field
⋮
paramN::TN = paramN_default # optional field
righthandside::RH = righthandside_function # mandatory field
readout::RO = readout_function # mandatory field
state::ST = state_default # mandatory field
input::IP = input_default # mandatory field
output::OP = output_default # mandatory field
end
```
Here, `MyDiscreteSystem` has `N` parameters. `MyDiscreteSystem` is represented by the `righthandside` and `readout` function. `state`, `input` and `output` is the state, input port and output port of `MyDiscreteSystem`.
!!! warning
`righthandside` must have the signature
```julia
function righthandside(dx, x, u, t, args...; kwargs...)
dx .= .... # update dx
end
```
and `readout` must have the signature
```julia
function readout(x, u, t)
y = ...
return y
end
```
!!! warning
New discrete system must be a subtype of `AbstractDiscreteSystem` to function properly.
# Example
```jldoctest
julia> @def_discrete_system mutable struct MyDiscreteSystem{RH, RO, IP, OP} <: AbstractDiscreteSystem
α::Float64 = 1.
β::Float64 = 2.
righthandside::RH = (dx, x, u, t, α=α) -> (dx[1] = α * x[1] + u[1](t))
state::Vector{Float64} = [1.]
readout::RO = (x, u, t) -> x
input::IP = Inport(1)
output::OP = Outport(1)
end
julia> ds = MyDiscreteSystem();
julia> ds.input
1-element Inport{Inpin{Float64}}:
Inpin(eltype:Float64, isbound:false)
```
"""
macro def_discrete_system(ex)
#= NOTE:
Generate the parameter names TR, HS, CB, ID, MA, MK, SA, SK, AL, IT of types of trigger, handshake, callbacks,
id, modelargs, modelkwargs, solverargs, solverkwargs, alg, integrator by using `gensym` to avoid duplicate type
parameter names so that the users can parametrizde their types as
@def_discrete_system mutable struct MyDiscreteSystem{RH, RO, ST, IP, TR} <: AbstractDiscreteSystem
righthandside::RH
readout::RO
state::ST
input::IP
output::TR
end
Note that the parameter name of output is TR. But, since the parameter name TR of trigger of the compnent
is generated by `gensym`, we get rid of duplicate parameter names.
=#
checksyntax(ex, :AbstractDiscreteSystem)
TR, HS, CB, ID, MA, MK, SA, SK, AL, IT = [gensym() for i in 1 : 10]
fields = quote
trigger::$(TR) = Inpin()
handshake::$(HS) = Outpin{Bool}()
callbacks::$(CB) = nothing
name::Symbol = Symbol()
id::$(ID )= Jusdl.uuid4()
t::Float64 = 0.
modelargs::$(MA) = ()
modelkwargs::$(MK) = NamedTuple()
solverargs::$(SA) = ()
solverkwargs::$(SK) = NamedTuple()
alg::$(AL) = Jusdl.FunctionMap()
integrator::$(IT) = Jusdl.construct_integrator(Jusdl.DiscreteProblem, input, righthandside, state, t,
modelargs, solverargs; alg=alg, modelkwargs=modelkwargs, solverkwargs=solverkwargs, numtaps=3)
end, [TR, HS, CB, ID, MA, MK, SA, SK, AL, IT]
_append_common_fields!(ex, fields...)
deftype(ex)
end
##### Define Discrete system library
"""
DiscreteSystem(; righthandside, readout, state, input, output)
Constructs a generic discrete system
# Example
```jldoctest
julia> sfuncdiscrete(dx,x,u,t) = (dx .= 0.5x);
julia> ofuncdiscrete(x, u, t) = x;
julia> DiscreteSystem(righthandside=sfuncdiscrete, readout=ofuncdiscrete, state=[1.], input=nothing, output=Outport())
DiscreteSystem(righthandside:sfuncdiscrete, readout:ofuncdiscrete, state:[1.0], t:0.0, input:nothing, output:Outport(numpins:1, eltype:Outpin{Float64}))
```
"""
@def_discrete_system mutable struct DiscreteSystem{RH, RO, ST, IP, OP} <: AbstractDiscreteSystem
righthandside::RH
readout::RO
state::ST
input::IP
output::OP
end
@doc raw"""
DiscreteLinearSystem(input, output, modelargs=(), solverargs=();
A=fill(-1, 1, 1), B=fill(0, 1, 1), C=fill(1, 1, 1), D=fill(0, 1, 1), state=rand(size(A,1)), t=0.,
alg=ODEAlg, modelkwargs=NamedTuple(), solverkwargs=NamedTuple())
Constructs a `DiscreteLinearSystem` with `input` and `output`. `state` is the initial state and `t` is the time. `modelargs` and `modelkwargs` are passed into `ODEProblem` and `solverargs` and `solverkwargs` are passed into `solve` method of `DifferentialEquations`. `alg` is the algorithm to solve the differential equation of the system.
The `DiscreteLinearSystem` is represented by the following state and output equations.
```math
\begin{array}{l}
\dot{x} = A x + B u \\[0.25cm]
y = C x + D u
\end{array}
```
where ``x`` is `state`. `solver` is used to solve the above differential equation.
"""
@def_discrete_system mutable struct DiscreteLinearSystem{IP, OP, RH, RO} <: AbstractDiscreteSystem
A::Matrix{Float64} = fill(-1., 1, 1)
B::Matrix{Float64} = fill(0., 1, 1)
C::Matrix{Float64} = fill(1., 1, 1)
D::Matrix{Float64} = fill(-1., 1, 1)
input::IP = Inport(1)
output::OP = nothing
state::Vector{Float64} = rand(size(A, 1))
righthandside::RH = input === nothing ? (dx, x, u, t) -> (dx .= A * x) :
(dx, x, u, t) -> (dx .= A * x + B * map(ui -> ui(t), u.itp))
readout::RO = input === nothing ? (x, u, t) -> (C * x) :
( (C === nothing || D === nothing) ? nothing : (x, u, t) -> (C * x + D * map(ui -> ui(t), u)) )
end
@doc raw"""
Henon()
Constructs a `Henon` system evolving with the dynamics
```math
\begin{array}{l}
\dot{x}_1 = 1 - \alpha (x_1^2) + x_2 \\[0.25cm]
\dot{x}_2 = \beta x_1
\end{array}
```
"""
@def_discrete_system mutable struct HenonSystem{RH, RO, IP, OP} <: AbstractDiscreteSystem
α::Float64 = 1.4
β::Float64 = 0.3
γ::Float64 = 1.
righthandside::RH = function henonrhs(dx, x, u, t, α=α, β=β, γ=γ)
dx[1] = 1 - α * x[1]^2 + x[2]
dx[2] = β * x[1]
dx .*= γ
end
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(2)
input::IP = nothing
output::OP = Outport(2)
end
@doc raw"""
LoziSystem()
Constructs a `Lozi` system evolving with the dynamics
```math
\begin{array}{l}
\dot{x}_1 = 1 - \alpha |x_1| + x_2 \\[0.25cm]
\dot{x}_2 = \beta x_1
\end{array}
```
"""
@def_discrete_system mutable struct LoziSystem{RH, RO, IP, OP} <: AbstractDiscreteSystem
α::Float64 = 1.4
β::Float64 = 0.3
γ::Float64 = 1.
righthandside::RH = function lozirhs(dx, x, u, t, α=α, β=β, γ=γ)
dx[1] = 1 - α * abs(x[1]) + x[2]
dx[2] = β * x[1]
dx .*= γ
end
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(2)
input::IP = nothing
output::OP = Outport(2)
end
@doc raw"""
BogdanovSystem()
Constructs a Bogdanov system with equations
```math
\begin{array}{l}
\dot{x}_1 = x_1 + \dot{x}_2 \\[0.25cm]
\dot{x}_2 = x_2 + \epsilon + x_2 + k x_1 (x_1 - 1) + \mu x_1 x_2
\end{array}
```
"""
@def_discrete_system mutable struct BogdanovSystem{RH, RO, IP, OP} <: AbstractDiscreteSystem
ε::Float64 = 0.
μ::Float64 = 0.
k::Float64 = 1.2
γ::Float64 = 1.
righthandside::RH = function bogdanovrhs(dx, x, u, t, ε=ε, μ=μ, k=k, γ=γ)
dx[2]= x[2] + ε * x[2] + k * x[1] * (x[1] - 1) + μ * x[1] * x[2]
dx[1] = x[1] + dx[2]
dx .*= γ
end
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(2)
input::IP = nothing
output::OP = Outport(2)
end
@doc raw"""
GingerbreadmanSystem()
Constructs a GingerbreadmanSystem with the dynamics
```math
\begin{array}{l}
\dot{x}_1 = 1 - x_2 + |x_1|\\[0.25cm]
\dot{x}_2 = x_1
\end{array}
```
"""
@def_discrete_system mutable struct GingerbreadmanSystem{RH, RO, IP, OP} <: AbstractDiscreteSystem
γ::Float64 = 1.
righthandside::RH = function gingerbreadmanrhs(dx, x, u, t, γ=γ)
dx[1] = 1 - x[2] + abs(x[1])
dx[2] = x[1]
dx .*= γ
end
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(2)
input::IP = nothing
output::OP = Outport(2)
end
@doc raw"""
LogisticSystem()
Constructs a LogisticSystem with the dynamics
```math
\begin{array}{l}
\dot{x} = r x (1 - x)
\end{array}
```
"""
@def_discrete_system mutable struct LogisticSystem{RH, RO, IP, OP} <: AbstractDiscreteSystem
r::Float64 = 1.
γ::Float64 = 1.
righthandside::RH = function logisticrhs(dx, x, u, t, r = r, γ=γ)
dx[1] = r * x[1] * (1 - x[1])
dx[1] *= γ
end
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(1)
input::IP = nothing
output::OP = Outport(1)
end
##### Pretty-printting
show(io::IO, ds::DiscreteSystem) = print(io,
"DiscreteSystem(righthandside:$(ds.righthandside), readout:$(ds.readout), state:$(ds.state), t:$(ds.t), ",
"input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::DiscreteLinearSystem) = print(io,
"DiscreteLinearystem(A:$(ds.A), B:$(ds.B), C:$(ds.C), D:$(ds.D), state:$(ds.state), t:$(ds.t), ",
"input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::HenonSystem) = print(io,
"HenonSystem(α:$(ds.α), β:$(ds.β), γ:$(ds.γ),state:$(ds.state), t:$(ds.t), input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::LoziSystem) = print(io,
"LoziSystem(α:$(ds.α), β:$(ds.β), γ:$(ds.γ), state:$(ds.state), t:$(ds.t), ",
"input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::BogdanovSystem) = print(io,
"BogdanovSystem(ε:$(ds.ε), μ:$(ds.μ), k:$(ds.k), γ:$(ds.γ), state:$(ds.state), t:$(ds.t), ",
"input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::GingerbreadmanSystem) = print(io,
"GingerbreadmanSystem(γ:$(ds.γ), state:$(ds.state), t:$(ds.t), input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::LogisticSystem) = print(io,
"LogisticSystem(r:$(ds.r), γ:$(ds.γ), state:$(ds.state), t:$(ds.t), input:$(ds.input), output:$(ds.output))")
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 1845 | # This file includes intregrator construction
function construct_integrator(deproblem, input, righthandside, state, t, modelargs=(), solverargs=();
alg=nothing, stateder=state, modelkwargs=NamedTuple(), solverkwargs=NamedTuple(), numtaps=3)
# If needed, construct interpolant for input.
interpolant = input === nothing ? nothing : Interpolant(numtaps, length(input))
# Construct the problem
if deproblem == SDEProblem
problem = deproblem(righthandside[1], righthandside[2], state, (t, Inf), interpolant, modelargs...;
modelkwargs...)
elseif deproblem == DDEProblem
problem = deproblem(righthandside[1], state, righthandside[2], (t, Inf), interpolant, modelargs...;
modelkwargs...)
elseif deproblem == DAEProblem
problem = deproblem(righthandside, stateder, state, (t, Inf), interpolant, modelargs...;
modelkwargs...)
else
problem = deproblem(righthandside, state, (t, Inf), interpolant, modelargs...;
modelkwargs...)
end
# Initialize the integrator
init(problem, alg, solverargs...; save_everystep=false, dense=true, solverkwargs...)
end
#= This function checks whether the syntax is of the form
@my_macro_to_define_new_dynamical_system mutable struct NewSystem{T, S} <: SuperTypeName
# fields
end
where @my_macro_to_define_new_dynamical_system is any macro used to define new dynamical system such as @def_ode_system, @def_sde_system, etc.
=#
function checksyntax(ex::Expr, supertypename::Symbol)
ex.head == :struct && ex.args[1] ||
error("Invalid usage. The expression should start with `mutable struct`.\n$ex")
ex.args[2].head == :(<:) && ex.args[2].args[2] == supertypename ||
error("Invalid usage. The type should be a subtype of $supertypename.\n$ex")
end
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 23517 | # This file contains ODESystem prototypes
import DifferentialEquations: Tsit5, ODEProblem
import UUIDs: uuid4
"""
@def_ode_system ex
where `ex` is the expression to define to define a new AbstractODESystem component type. The usage is as follows:
```julia
@def_ode_system mutable struct MyODESystem{T1,T2,T3,...,TN,OP,RH,RO,ST,IP,OP} <: AbstractODESystem
param1::T1 = param1_default # optional field
param2::T2 = param2_default # optional field
param3::T3 = param3_default # optional field
⋮
paramN::TN = paramN_default # optional field
righthandside::RH = righthandeside_function # mandatory field
readout::RO = readout_function # mandatory field
state::ST = state_default # mandatory field
input::IP = input_default # mandatory field
output::OP = output_default # mandatory field
end
```
Here, `MyODESystem` has `N` parameters. `MyODESystem` is represented by the `righthandside` and `readout` function. `state`, `input` and `output` is the state, input port and output port of `MyODESystem`.
!!! warning
`righthandside` must have the signature
```julia
function righthandside(dx, x, u, t, args...; kwargs...)
dx .= .... # update dx
end
```
and `readout` must have the signature
```julia
function readout(x, u, t)
y = ...
return y
end
```
!!! warning
New ODE system must be a subtype of `AbstractODESystem` to function properly.
!!! warning
New ODE system must be mutable type.
# Example
```jldoctest
julia> @def_ode_system mutable struct MyODESystem{RH, RO, IP, OP} <: AbstractODESystem
α::Float64 = 1.
β::Float64 = 2.
righthandside::RH = (dx, x, u, t, α=α) -> (dx[1] = α * x[1] + u[1](t))
readout::RO = (x, u, t) -> x
state::Vector{Float64} = [1.]
input::IP = Inport(1)
output::OP = Outport(1)
end
julia> ds = MyODESystem();
julia> ds.input
1-element Inport{Inpin{Float64}}:
Inpin(eltype:Float64, isbound:false)
```
"""
macro def_ode_system(ex)
#= NOTE:
Generate the parameter names TR, HS, CB, ID, MA, MK, SA, SK, AL, IT of types of trigger, handshake, callbacks,
id, modelargs, modelkwargs, solverargs, solverkwargs, alg, integrator by using `gensym` to avoid duplicate type
parameter names so that the users can parametrizde their types as
@def_discrete_system mutablestruct MyODESystem{RH, RO, ST, IP, TR} <: AbstractODESystem
righthandside::RH
readout::RO
state::ST
input::IP
output::TR
end
Note that the parameter name of output is TR. But, since the parameter name TR of trigger of the compnent
is generated by `gensym`, we get rid of duplicate parameter names.
=#
checksyntax(ex, :AbstractODESystem)
TR, HS, CB, ID, MA, MK, SA, SK, AL, IT = [gensym() for i in 1 : 10]
fields = quote
trigger::$(TR) = Inpin()
handshake::$(HS) = Outpin{Bool}()
callbacks::$(CB) = nothing
name::Symbol = Symbol()
id::$(ID) = Jusdl.uuid4()
t::Float64 = 0.
modelargs::$(MA) = ()
modelkwargs::$(MK) = NamedTuple()
solverargs::$(SA) = ()
solverkwargs::$(SK) = NamedTuple()
alg::$(AL) = Jusdl.Tsit5()
integrator::$(IT) = Jusdl.construct_integrator(Jusdl.ODEProblem, input, righthandside, state, t, modelargs,
solverargs; alg=alg, modelkwargs=modelkwargs, solverkwargs=solverkwargs, numtaps=3)
end, [TR, HS, CB, ID, MA, MK, SA, SK, AL, IT]
_append_common_fields!(ex, fields...)
deftype(ex)
end
#### Define ODE system library.
"""
ODESystem(;righthandside, readout, state, input, output)
Constructs a generic ODE system.
# Example
```jldoctest
julia> ds = ODESystem(righthandside=(dx,x,u,t)->(dx.=-x), readout=(x,u,t)->x, state=[1.],input=nothing, output=Outport(1));
julia> ds.state
1-element Array{Float64,1}:
1.0
```
"""
@def_ode_system mutable struct ODESystem{RH, RO, ST, IP, OP} <: AbstractODESystem
righthandside::RH
readout::RO
state::ST
input::IP
output::OP
end
@doc raw"""
ContinuousLinearSystem(input, output, modelargs=(), solverargs=();
A=fill(-1, 1, 1), B=fill(0, 1, 1), C=fill(1, 1, 1), D=fill(0, 1, 1), state=rand(size(A,1)), t=0.,
alg=ODEAlg, modelkwargs=NamedTuple(), solverkwargs=NamedTuple())
Constructs a `ContinuousLinearSystem` with `input` and `output`. `state` is the initial state and `t` is the time. `modelargs` and `modelkwargs` are passed into `ODEProblem` and `solverargs` and `solverkwargs` are passed into `solve` method of `DifferentialEquations`. `alg` is the algorithm to solve the differential equation of the system.
The `ContinuousLinearSystem` is represented by the following state and output equations.
```math
\begin{array}{l}
\dot{x} = A x + B u \\[0.25cm]
y = C x + D u
\end{array}
```
where ``x`` is `state`. `solver` is used to solve the above differential equation.
"""
@def_ode_system mutable struct ContinuousLinearSystem{IP, OP, RH, RO} <: AbstractODESystem
A::Matrix{Float64} = fill(-1., 1, 1)
B::Matrix{Float64} = fill(1., 1, 1)
C::Matrix{Float64} = fill(1., 1, 1)
D::Matrix{Float64} = fill(0., 1, 1)
input::IP = Inport(1)
output::OP = Outport(1)
state::Vector{Float64} = rand(size(A, 1))
righthandside::RH = input === nothing ? (dx, x, u, t) -> (dx .= A * x) :
(dx, x, u, t) -> (dx .= A * x + B * map(ui -> ui(t), u.itp))
readout::RO = input === nothing ? (x, u, t) -> (C * x) :
( (C === nothing || D === nothing) ? nothing : (x, u, t) -> (C * x + D * map(ui -> ui(t), u)) )
end
@doc raw"""
LorenzSystem(input, output, modelargs=(), solverargs=();
sigma=10, beta=8/3, rho=28, gamma=1, outputfunc=allstates, state=rand(3), t=0.,
alg=ODEAlg, cplmat=diagm([1., 1., 1.]), modelkwargs=NamedTuple(), solverkwargs=NamedTuple())
Constructs a `LorenzSystem` with `input` and `output`. `sigma`, `beta`, `rho` and `gamma` is the system parameters. `state` is the initial state and `t` is the time. `modelargs` and `modelkwargs` are passed into `ODEProblem` and `solverargs` and `solverkwargs` are passed into `solve` method of `DifferentialEquations`. `alg` is the algorithm to solve the differential equation of the system.
If `input` is `nothing`, the state equation of `LorenzSystem` is
```math
\begin{array}{l}
\dot{x}_1 = \gamma (\sigma (x_2 - x_1)) \\[0.25cm]
\dot{x}_2 = \gamma (x_1 (\rho - x_3) - x_2) \\[0.25cm]
\dot{x}_3 = \gamma (x_1 x_2 - \beta x_3)
\end{array}
```
where ``x`` is `state`. `solver` is used to solve the above differential equation. If `input` is not `nothing`, then the state eqaution is
```math
\begin{array}{l}
\dot{x}_1 = \gamma (\sigma (x_2 - x_1)) + \sum_{j = 1}^3 \alpha_{1j} u_j \\[0.25cm]
\dot{x}_2 = \gamma (x_1 (\rho - x_3) - x_2) + \sum_{j = 1}^3 \alpha_{2j} u_j \\[0.25cm]
\dot{x}_3 = \gamma (x_1 x_2 - \beta x_3) + \sum_{j = 1}^3 \alpha_{3j} u_j
\end{array}
```
where ``A = [\alpha_{ij}]`` is `cplmat` and ``u = [u_{j}]`` is the value of the `input`. The output function is
```math
y = g(x, u, t)
```
where ``t`` is time `t`, ``y`` is the value of the `output` and ``g`` is `outputfunc`.
"""
@def_ode_system mutable struct LorenzSystem{RH, RO, IP, OP} <: AbstractODESystem
σ::Float64 = 10.
β::Float64 = 8 / 3
ρ::Float64 = 28.
γ::Float64 = 1.
righthandside::RH = function lorenzrhs(dx, x, u, t, σ=σ, β=β, ρ=ρ, γ=γ)
dx[1] = σ * (x[2] - x[1])
dx[2] = x[1] * (ρ - x[3]) - x[2]
dx[3] = x[1] * x[2] - β * x[3]
dx .*= γ
end
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(3)
input::IP = nothing
output::OP = Outport(3)
end
"""
ForcedLorenzSystem()
Constructs a LorenzSystem that is driven by its inputs.
"""
@def_ode_system mutable struct ForcedLorenzSystem{CM, RH, RO, IP, OP} <: AbstractODESystem
σ::Float64 = 10.
β::Float64 = 8 / 3
ρ::Float64 = 28.
γ::Float64 = 1.
cplmat::CM = I(3)
righthandside::RH = function lorenzrhs(dx, x, u, t, σ=σ, β=β, ρ=ρ, γ=γ, cplmat=cplmat)
dx[1] = σ * (x[2] - x[1])
dx[2] = x[1] * (ρ - x[3]) - x[2]
dx[3] = x[1] * x[2] - β * x[3]
dx .*= γ
dx .+= cplmat * map(ui -> ui(t), u.itp) # Couple inputs
end
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(3)
input::IP = Inport(3)
output::OP = Outport(3)
end
@doc raw"""
ChenSystem(input, output, modelargs=(), solverargs=();
a=35, b=3, c=28, gamma=1, outputfunc=allstates, state=rand(3), t=0.,
alg=ODEAlg, cplmat=diagm([1., 1., 1.]), modelkwargs=NamedTuple(), solverkwargs=NamedTuple())
Constructs a `ChenSystem` with `input` and `output`. `a`, `b`, `c` and `gamma` is the system parameters. `state` is the initial state and `t` is the time. `modelargs` and `modelkwargs` are passed into `ODEProblem` and `solverargs` and `solverkwargs` are passed into `solve` method of `DifferentialEquations`. `alg` is the algorithm to solve the differential equation of the system.
If `input` is `nothing`, the state equation of `ChenSystem` is
```math
\begin{array}{l}
\dot{x}_1 = \gamma (a (x_2 - x_1)) \\[0.25cm]
\dot{x}_2 = \gamma ((c - a) x_1 + c x_2 + x_1 x_3) \\[0.25cm]
\dot{x}_3 = \gamma (x_1 x_2 - b x_3)
\end{array}
```
where ``x`` is `state`. `solver` is used to solve the above differential equation. If `input` is not `nothing`, then the state eqaution is
```math
\begin{array}{l}
\dot{x}_1 = \gamma (a (x_2 - x_1)) + \sum_{j = 1}^3 \alpha_{1j} u_j \\[0.25cm]
\dot{x}_2 = \gamma ((c - a) x_1 + c x_2 + x_1 x_3) + \sum_{j = 1}^3 \alpha_{2j} u_j \\[0.25cm]
\dot{x}_3 = \gamma (x_1 x_2 - b x_3) + \sum_{j = 1}^3 \alpha_{3j} u_j
\end{array}
```
where ``A = [\alpha_{ij}]`` is `cplmat` and ``u = [u_{j}]`` is the value of the `input`. The output function is
```math
y = g(x, u, t)
```
where ``t`` is time `t`, ``y`` is the value of the `output` and ``g`` is `outputfunc`.
"""
@def_ode_system mutable struct ChenSystem{RH, RO, IP, OP} <: AbstractODESystem
a::Float64 = 35.
b::Float64 = 3.
c::Float64 = 28.
γ::Float64 = 1.
righthandside::RH = function chenrhs(dx, x, u, t, a=a, b=b, c=c, γ=γ)
dx[1] = a * (x[2] - x[1])
dx[2] = (c - a) * x[1] + c * x[2] - x[1] * x[3]
dx[3] = x[1] * x[2] - b * x[3]
dx .*= γ
end
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(3)
input::IP = nothing
output::OP = Outport(3)
end
"""
ForcedChenSystem()
Constructs Chen system driven by its inputs.
"""
@def_ode_system mutable struct ForcedChenSystem{CM, RH, RO, IP, OP} <: AbstractODESystem
a::Float64 = 35.
b::Float64 = 3.
c::Float64 = 28.
γ::Float64 = 1.
cplmat::CM = I(3)
righthandside::RH = function chenrhs(dx, x, u, t, a=a, b=b, c=c, γ=γ)
dx[1] = a * (x[2] - x[1])
dx[2] = (c - a) * x[1] + c * x[2] - x[1] * x[3]
dx[3] = x[1] * x[2] - b * x[3]
dx .*= γ
dx .+= cplmat * map(ui -> ui(t), u.itp) # Couple inputs
end
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(3)
input::IP = Inport(3)
output::OP = Outport(3)
end
Base.@kwdef struct PiecewiseLinearDiode
m0::Float64 = -1.143
m1::Float64 = -0.714
m2::Float64 = 5.
bp1::Float64 = 1.
bp2::Float64 = 5.
end
@inline function (d::PiecewiseLinearDiode)(x)
m0, m1, m2, bp1, bp2 = d.m0, d.m1, d.m2, d.bp1, d.bp2
if x < -bp2
return m2 * x + (m2 - m1) * bp2 + (m1 - m0) * bp1
elseif -bp2 <= x < -bp1
return m1 * x + (m1 - m0) * bp1
elseif -bp1 <= x < bp1
return m0 * x
elseif bp1 <= x < bp2
return m1 * x + (m0 - m1) * bp1
else
return m2 * x + (m1 - m2) * bp2 + (m0 - m1) * bp1
end
end
Base.@kwdef struct PolynomialDiode
a::Float64 = 1 / 16
b::Float64 = - 1 / 6
end
(d::PolynomialDiode)(x) = d.a * x^3 + d.b * x
@doc raw"""
ChuaSystem(input, output, modelargs=(), solverargs=();
diode=PiecewiseLinearDiode(), alpha=15.6, beta=28., gamma=1., outputfunc=allstates, state=rand(3), t=0.,
alg=ODEAlg, cplmat=diagm([1., 1., 1.]), modelkwargs=NamedTuple(), solverkwargs=NamedTuple())
Constructs a `ChuaSystem` with `input` and `output`. `diode`, `alpha`, `beta` and `gamma` is the system parameters. `state` is the initial state and `t` is the time. `modelargs` and `modelkwargs` are passed into `ODEProblem` and `solverargs` and `solverkwargs` are passed into `solve` method of `DifferentialEquations`. `alg` is the algorithm to solve the differential equation of the system.
If `input` is `nothing`, the state equation of `ChuaSystem` is
```math
\begin{array}{l}
\dot{x}_1 = \gamma (\alpha (x_2 - x_1 - h(x_1))) \\[0.25cm]
\dot{x}_2 = \gamma (x_1 - x_2 + x_3 ) \\[0.25cm]
\dot{x}_3 = \gamma (-\beta x_2)
\end{array}
```
where ``x`` is `state`. `solver` is used to solve the above differential equation. If `input` is not `nothing`, then the state eqaution is
```math
\begin{array}{l}
\dot{x}_1 = \gamma (\alpha (x_2 - x_1 - h(x_1))) + \sum_{j = 1}^3 \theta_{1j} u_j \\[0.25cm]
\dot{x}_2 = \gamma (x_1 - x_2 + x_3 ) + \sum_{j = 1}^3 \theta_{2j} u_j \\[0.25cm]
\dot{x}_3 = \gamma (-\beta x_2) + \sum_{j = 1}^3 \theta_{3j} u_j
\end{array}
```
where ``\Theta = [\theta_{ij}]`` is `cplmat` and ``u = [u_{j}]`` is the value of the `input`. The output function is
```math
y = g(x, u, t)
```
where ``t`` is time `t`, ``y`` is the value of the `output` and ``g`` is `outputfunc`.
"""
@def_ode_system mutable struct ChuaSystem{DT,RH, RO, IP, OP} <: AbstractODESystem
diode::DT = PiecewiseLinearDiode()
α::Float64 = 15.6
β::Float64 = 28.
γ::Float64 = 1.
righthandside::RH = function chuarhs(dx, x, u, t, diode=diode, α=α, β=β, γ=γ)
dx[1] = α * (x[2] - x[1] - diode(x[1]))
dx[2] = x[1] - x[2] + x[3]
dx[3] = -β * x[2]
dx .*= γ
end
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(3)
input::IP = nothing
output::OP = Outport(3)
end
"""
ForcedChuaSystem()
Constructs a Chua system with inputs.
"""
@def_ode_system mutable struct ForcedChuaSystem{DT, CM, RH, RO, IP, OP} <: AbstractODESystem
diode::DT = PiecewiseLinearDiode()
α::Float64 = 15.6
β::Float64 = 28.
γ::Float64 = 1.
cplmat::CM = I(3)
righthandside::RH = function chuarhs(dx, x, u, t, diode=diode, α=α, β=β, γ=γ)
dx[1] = α * (x[2] - x[1] - diode(x[1]))
dx[2] = x[1] - x[2] + x[3]
dx[3] = -β * x[2]
dx .*= γ
dx .+= cplmat * map(ui -> ui(t), u.itp) # Couple inputs
end
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(3)
input::IP = Inport(3)
output::OP = Outport(3)
end
@doc raw"""
RosslerSystem(input, output, modelargs=(), solverargs=();
a=0.38, b=0.3, c=4.82, gamma=1., outputfunc=allstates, state=rand(3), t=0.,
alg=ODEAlg, cplmat=diagm([1., 1., 1.]), modelkwargs=NamedTuple(), solverkwargs=NamedTuple())
Constructs a `RosllerSystem` with `input` and `output`. `a`, `b`, `c` and `gamma` is the system parameters. `state` is the initial state and `t` is the time. `modelargs` and `modelkwargs` are passed into `ODEProblem` and `solverargs` and `solverkwargs` are passed into `solve` method of `DifferentialEquations`. `alg` is the algorithm to solve the differential equation of the system.
If `input` is `nothing`, the state equation of `RosslerSystem` is
```math
\begin{array}{l}
\dot{x}_1 = \gamma (-x_2 - x_3) \\[0.25cm]
\dot{x}_2 = \gamma (x_1 + a x_2) \\[0.25cm]
\dot{x}_3 = \gamma (b + x_3 (x_1 - c))
\end{array}
```
where ``x`` is `state`. `solver` is used to solve the above differential equation. If `input` is not `nothing`, then the state eqaution is
```math
\begin{array}{l}
\dot{x}_1 = \gamma (-x_2 - x_3) + \sum_{j = 1}^3 \theta_{1j} u_j \\[0.25cm]
\dot{x}_2 = \gamma (x_1 + a x_2 ) + \sum_{j = 1}^3 \theta_{2j} u_j \\[0.25cm]
\dot{x}_3 = \gamma (b + x_3 (x_1 - c)) + \sum_{j = 1}^3 \theta_{3j} u_j
\end{array}
```
where ``\Theta = [\theta_{ij}]`` is `cplmat` and ``u = [u_{j}]`` is the value of the `input`. The output function is
```math
y = g(x, u, t)
```
where ``t`` is time `t`, ``y`` is the value of the `output` and ``g`` is `outputfunc`.
"""
@def_ode_system mutable struct RosslerSystem{RH, RO, IP, OP} <: AbstractODESystem
a::Float64 = 0.38
b::Float64 = 0.3
c::Float64 = 4.82
γ::Float64 = 1.
righthandside::RH = function rosslerrhs(dx, x, u, t, a=a, b=b, c=c, γ=γ)
dx[1] = -x[2] - x[3]
dx[2] = x[1] + a * x[2]
dx[3] = b + x[3] * (x[1] - c)
dx .*= γ
end
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(3)
input::IP = nothing
output::OP = Outport(3)
end
"""
ForcedRosslerSystem()
Constructs a Rossler system driven by its input.
"""
@def_ode_system mutable struct ForcedRosslerSystem{CM, RH, RO, IP, OP} <: AbstractODESystem
a::Float64 = 0.38
b::Float64 = 0.3
c::Float64 = 4.82
γ::Float64 = 1.
cplmat::CM = I(3)
righthandside::RH = function rosslerrhs(dx, x, u, t, a=a, b=b, c=c, γ=γ)
dx[1] = -x[2] - x[3]
dx[2] = x[1] + a * x[2]
dx[3] = b + x[3] * (x[1] - c)
dx .*= γ
dx .+= cplmat * map(ui -> ui(t), u.itp) # Couple inputs
end
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(3)
input::IP = Inport(3)
output::OP = Outport(3)
end
@doc raw"""
VanderpolSystem(input, output, modelargs=(), solverargs=();
mu=5., gamma=1., outputfunc=allstates, state=rand(2), t=0.,
alg=ODEAlg, cplmat=diagm([1., 1]), modelkwargs=NamedTuple(), solverkwargs=NamedTuple())
Constructs a `VanderpolSystem` with `input` and `output`. `mu` and `gamma` is the system parameters. `state` is the initial state and `t` is the time. `modelargs` and `modelkwargs` are passed into `ODEProblem` and `solverargs` and `solverkwargs` are passed into `solve` method of `DifferentialEquations`. `alg` is the algorithm to solve the differential equation of the system.
If `input` is `nothing`, the state equation of `VanderpolSystem` is
```math
\begin{array}{l}
\dot{x}_1 = \gamma (x_2) \\[0.25cm]
\dot{x}_2 = \gamma (\mu (x_1^2 - 1) x_2 - x_1 )
\end{array}
```
where ``x`` is `state`. `solver` is used to solve the above differential equation. If `input` is not `nothing`, then the state eqaution is
```math
\begin{array}{l}
\dot{x}_1 = \gamma (x_2) + \sum_{j = 1}^3 \theta_{1j} u_j \\[0.25cm]
\dot{x}_2 = \gamma (\mu (x_1^2 - 1) x_2 - x_1) + \sum_{j = 1}^3 \theta_{2j} u_j
\end{array}
```
where ``\Theta = [\theta_{ij}]`` is `cplmat` and ``u = [u_{j}]`` is the value of the `input`. The output function is
```math
y = g(x, u, t)
```
where ``t`` is time `t`, ``y`` is the value of the `output` and ``g`` is `outputfunc`.
"""
@def_ode_system mutable struct VanderpolSystem{RH, RO, IP, OP} <: AbstractODESystem
μ::Float64 = 5.
γ::Float64 = 1.
righthandside::RH = function vanderpolrhs(dx, x, u, t, μ=μ, γ=γ)
dx[1] = x[2]
dx[2] = -μ * (x[1]^2 - 1) * x[2] - x[1]
dx .*= γ
end
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(2)
input::IP = nothing
output::OP = Outport(3)
end
"""
ForcedVanderpolSystem()
Constructs a Vanderpol system driven by its input.
"""
@def_ode_system mutable struct ForcedVanderpolSystem{CM, RH, RO, IP, OP} <: AbstractODESystem
μ::Float64 = 5.
γ::Float64 = 1.
cplmat::CM = I(2)
righthandside::RH = function vanderpolrhs(dx, x, u, t, μ=μ, γ=γ)
dx[1] = x[2]
dx[2] = -μ * (x[1]^2 - 1) * x[2] - x[1]
dx .*= γ
dx .+= cplmat * map(ui -> ui(t), u.itp) # Couple inputs
end
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(2)
input::IP = Inport(2)
output::OP = Outport(3)
end
@doc raw"""
Integrator(state=zeros(0), t=0., modelargs=(), solverargs=();
alg=ODEAlg, modelkwargs=NamedTuple(), solverkwargs=NamedTuple(), numtaps=numtaps, callbacks=nothing,
name=Symbol())
Constructs an integrator whose input output relation is given by
```math
u(t) = ki * \int_{0}^{t} u(\tau) d\tau
```
where ``u(t)`` is the input, ``y(t)`` is the output and ``ki`` is the integration constant.
"""
@def_ode_system mutable struct Integrator{RH, RO, IP, OP} <: AbstractODESystem
ki::Float64 = 1.
righthandside::RH = (dx, x, u, t) -> (dx[1] = ki * u[1](t))
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(1)
input::IP = Inport()
output::OP = Outport()
end
##### Pretty-printing
show(io::IO, ds::ODESystem) = print(io,
"ODESystem(righthandside:$(ds.righthandside), readout:$(ds.readout), state:$(ds.state), t:$(ds.t), ",
"input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::ContinuousLinearSystem) = print(io,
"ContinuousLinearSystem(A:$(ds.A), B:$(ds.B), C:$(ds.C), D:$(ds.D), state:$(ds.state), t:$(ds.t), ",
"input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::LorenzSystem) = print(io,
"LorenzSystem(σ:$(ds.σ), β:$(ds.β), ρ:$(ds.ρ), γ:$(ds.γ), state:$(ds.state), t:$(ds.t), ",
"input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::ForcedLorenzSystem) = print(io,
"LorenzSystem(σ:$(ds.σ), β:$(ds.β), ρ:$(ds.ρ), γ:$(ds.γ), cplmat:$(ds.cplmat), state:$(ds.state), t:$(ds.t), ",
"input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::ChenSystem) = print(io,
"ChenSystem(a:$(ds.a), b:$(ds.b), c:$(ds.c), γ:$(ds.γ), state:$(ds.state), t:$(ds.t), ",
"input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::ForcedChenSystem) = print(io,
"ChenSystem(a:$(ds.a), b:$(ds.b), c:$(ds.c), γ:$(ds.γ), cplmat:$(ds.cplmat), state:$(ds.state), t:$(ds.t), ",
"input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::ChuaSystem) = print(io,
"ChuaSystem(diode:$(ds.diode), α:$(ds.α), β:$(ds.β), γ:$(ds.γ), state:$(ds.state), ",
"t:$(ds.t), input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::ForcedChuaSystem) = print(io,
"ChuaSystem(diode:$(ds.diode), α:$(ds.α), β:$(ds.β), γ:$(ds.γ), cplmat:$(ds.cplmat), state:$(ds.state), ",
"t:$(ds.t), input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::RosslerSystem) = print(io,
"RosslerSystem(a:$(ds.a), b:$(ds.b), c:$(ds.c), γ:$(ds.γ), state:$(ds.state), t:$(ds.t), ",
"input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::ForcedRosslerSystem) = print(io,
"RosslerSystem(a:$(ds.a), b:$(ds.b), c:$(ds.c), γ:$(ds.γ), cplmat:$(ds.cplmat), state:$(ds.state), t:$(ds.t), ",
"input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::VanderpolSystem) = print(io,
"VanderpolSystem(μ:$(ds.μ), γ:$(ds.γ), state:$(ds.state), t:$(ds.t), ",
"input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::ForcedVanderpolSystem) = print(io,
"VanderpolSystem(μ:$(ds.μ), γ:$(ds.γ), cplmat:$(ds.cplmat), state:$(ds.state), t:$(ds.t), ",
"input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::Integrator) = print(io,
"Integrator(ki:$(ds.ki), state:$(ds.state), t:$(ds.t), input:$(ds.input), output:$(ds.output))")
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 4951 | # This file includes RODESystems
import DifferentialEquations: RandomEM, RODEProblem
import UUIDs: uuid4
"""
@def_rode_system ex
where `ex` is the expression to define to define a new AbstractRODESystem component type. The usage is as follows:
```julia
@def_rode_system mutable struct MyRODESystem{T1,T2,T3,...,TN,OP,RH,RO,ST,IP,OP} <: AbstractRODESystem
param1::T1 = param1_default # optional field
param2::T2 = param2_default # optional field
param3::T3 = param3_default # optional field
⋮
paramN::TN = paramN_default # optional field
righthandside::RH = righthandside_function # mandatory field
readout::RO = readout_function # mandatory field
state::ST = state_default # mandatory field
input::IP = input_default # mandatory field
output::OP = output_default # mandatory field
end
```
Here, `MyRODESystem` has `N` parameters. `MyRODESystem` is represented by the `righthandside` and `readout` function. `state`, `input` and `output` is the initial state, input port and output port of `MyRODESystem`.
!!! warning
`righthandside` must have the signature
```julia
function righthandside((dx, x, u, t, W, args...; kwargs...)
dx .= .... # update dx
end
```
and `readout` must have the signature
```julia
function readout(x, u, t)
y = ...
return y
end
```
!!! warning
New RODE system must be a subtype of `AbstractRODESystem` to function properly.
# Example
```jldoctest
julia> @def_rode_system mutable struct MySystem{RH, RO, IP, OP} <: AbstractRODESystem
A::Matrix{Float64} = [2. 0.; 0 -2]
righthandside::RH = (dx, x, u, t, W) -> (dx .= A * x * W)
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(2)
input::IP = nothing
output::OP = Outport(2)
end
julia> ds = MySystem();
```
"""
macro def_rode_system(ex)
#= NOTE:
Generate the parameter names TR, HS, CB, ID, MA, MK, SA, SK, AL, IT of types of trigger, handshake, callbacks,
id, modelargs, modelkwargs, solverargs, solverkwargs, alg, integrator by using `gensym` to avoid duplicate type
parameter names so that the users can parametrizde their types as
@def_rode_system mutable struct MyRODESystem{RH, RO, ST, IP, TR} <: AbstractRODESystem
righthandside::RH
readout::RO
state::ST
input::IP
output::TR
end
Note that the parameter name of output is TR. But, since the parameter name TR of trigger of the compnent
is generated by `gensym`, we get rid of duplicate parameter names.
=#
checksyntax(ex, :AbstractRODESystem)
TR, HS, CB, ID, MA, MK, SA, SK, AL, IT = [gensym() for i in 1 : 10]
fields = quote
trigger::$(TR) = Inpin()
handshake::$(HS) = Outpin{Bool}()
callbacks::$(CB) = nothing
name::Symbol = Symbol()
id::$(ID) = Jusdl.uuid4()
t::Float64 = 0.
modelargs::$(MA) = ()
modelkwargs::$(MK) = NamedTuple()
solverargs::$(SA) = ()
solverkwargs::$(SK) = (dt=0.01, )
alg::$(AL) = Jusdl.RandomEM()
integrator::$(IT) = Jusdl.construct_integrator(Jusdl.RODEProblem, input, righthandside, state, t, modelargs,
solverargs; alg=alg, modelkwargs=modelkwargs, solverkwargs=solverkwargs, numtaps=3)
end, [TR, HS, CB, ID, MA, MK, SA, SK, AL, IT]
_append_common_fields!(ex, fields...)
deftype(ex)
end
##### Define RODE sytem library
"""
RODESystem(; righthandside, readout, state, input, output)
Constructs a generic RODE system
"""
@def_rode_system mutable struct RODESystem{RH, RO, ST, IP, OP} <: AbstractRODESystem
righthandside::RH
readout::RO
state::ST
input::IP
output::OP
end
@doc raw"""
MultiplicativeNoiseLinearSystem()
Constructs a `MultiplicativeNoiseLinearSystem` with the dynamics
```math
\begin{array}{l}
\dot{x} = A x W
\end{array}
where `W` is the noise process.
```
"""
@def_rode_system mutable struct MultiplicativeNoiseLinearSystem{RH, RO, IP, OP} <: AbstractRODESystem
A::Matrix{Float64} = [2. 0.; 0 -2]
righthandside::RH = (dx, x, u, t, W) -> (dx .= A * x * W)
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(2)
input::IP = nothing
output::OP = Outport(2)
end
##### Pretty printing
show(io::IO, ds::RODESystem) = print(io,
"RODESystem(righthandside:$(ds.righthandside), readout:$(ds.readout), state:$(ds.state), t:$(ds.t), input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::MultiplicativeNoiseLinearSystem) = print(io,
"MultiplicativeNoiseLinearSystem(A:$(ds.A), state:$(ds.state), t:$(ds.t), input:$(ds.input), output:$(ds.output))")
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 6405 | # This file contains SDESystem prototypes
import DifferentialEquations: LambaEM, SDEProblem
import UUIDs: uuid4
"""
@def_sde_system ex
where `ex` is the expression to define to define a new AbstractSDESystem component type. The usage is as follows:
```julia
@def_sde_system mutable struct MySDESystem{T1,T2,T3,...,TN,OP,RH,RO,ST,IP,OP} <: AbstractSDESystem
param1::T1 = param1_default # optional field
param2::T2 = param2_default # optional field
param3::T3 = param3_default # optional field
⋮
paramN::TN = paramN_default # optional field
drift::DR = drift_function # mandatory field
diffusion::DF = diffusion_function # mandatory field
readout::RO = readout_functtion # mandatory field
state::ST = state_default # mandatory field
input::IP = input_default # mandatory field
output::OP = output_default # mandatory field
end
```
Here, `MySDESystem` has `N` parameters. `MySDESystem` is represented by the `drift`, `diffusion` and `readout` function. `state`, `input` and `output` is the initial state, input port and output port of `MySDESystem`.
!!! warning
`drift` must have the signature
```julia
function drift((dx, x, u, t, args...; kwargs...)
dx .= .... # update dx
end
```
and `diffusion` must have the signature
```julia
function diffusion((dx, x, u, t, args...; kwargs...)
dx .= .... # update dx
end
```
and `readout` must have the signature
```julia
function readout(x, u, t)
y = ...
return y
end
```
!!! warning
New SDE system must be a subtype of `AbstractSDESystem` to function properly.
# Example
```jldoctest
julia> @def_sde_system mutable struct MySDESystem{DR, DF, RO, IP, OP} <: AbstractSDESystem
η::Float64 = 1.
drift::DR = (dx, x, u, t) -> (dx .= x)
diffusion::DF = (dx, x, u, t, η=η) -> (dx .= η)
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(2)
input::IP = nothing
output::OP = Outport(2)
end
julia> ds = MySDESystem();
```
"""
macro def_sde_system(ex)
#= NOTE:
Generate the parameter names TR, HS, CB, ID, MA, MK, SA, SK, AL, IT of types of trigger, handshake, callbacks,
id, modelargs, modelkwargs, solverargs, solverkwargs, alg, integrator by using `gensym` to avoid duplicate type
parameter names so that the users can parametrizde their types as
@def_sde_system mutable struct MySDESystem{DR, DF, RO, ST, IP, TR} <: AbstractSDESystem
drift::DR
diffusion::DF
readout::RO
state::ST
input::IP
output::TR
end
Note that the parameter name of output is TR. But, since the parameter name TR of trigger of the compnent
is generated by `gensym`, we get rid of duplicate parameter names.
=#
checksyntax(ex, :AbstractSDESystem)
TR, HS, CB, ID, MA, MK, SA, SK, AL, IT = [gensym() for i in 1 : 10]
fields = quote
trigger::$(TR) = Inpin()
handshake::$(HS) = Outpin{Bool}()
callbacks::$(CB) = nothing
name::Symbol = Symbol()
id::$(ID) = Jusdl.uuid4()
t::Float64 = 0.
modelargs::$(MA) = ()
modelkwargs::$(MK) = NamedTuple()
solverargs::$(SA) = ()
solverkwargs::$(SK) = NamedTuple()
alg::$(AL) = Jusdl.LambaEM{true}()
integrator::$(IT) = Jusdl.construct_integrator(Jusdl.SDEProblem, input, (drift, diffusion), state,
t, modelargs, solverargs; alg=alg, modelkwargs=modelkwargs, solverkwargs=solverkwargs, numtaps=3)
end, [TR, HS, CB, ID, MA, MK, SA, SK, AL, IT]
_append_common_fields!(ex, fields...)
deftype(ex)
end
##### Define SDE system library
"""
SDESystem(; drift, diffusion, readout, state, input, output)
Constructs a SDE system.
"""
@def_sde_system mutable struct SDESystem{DR, DF, RO, ST, IP, OP} <: AbstractSDESystem
drift::DR
diffusion::DF
readout::RO
state::ST
input::IP
output::OP
end
@doc raw"""
NoisyLorenzSystem()
Constructs a noisy Lorenz system
"""
@def_sde_system mutable struct NoisyLorenzSystem{ET, DR, DF, RO, IP, OP} <: AbstractSDESystem
σ::Float64 = 10.
β::Float64 = 8 / 3
ρ::Float64 = 28.
η::ET = 1.
γ::Float64 = 1.
drift::DR = function lorenzdrift(dx, x, u, t, σ=σ, β=β, ρ=ρ, γ=γ)
dx[1] = σ * (x[2] - x[1])
dx[2] = x[1] * (ρ - x[3]) - x[2]
dx[3] = x[1] * x[2] - β * x[3]
dx .*= γ
end
diffusion::DF = (dx, x, u, t, η=η) -> (dx .= η)
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(3)
input::IP = nothing
output::OP = Outport(3)
end
@doc raw"""
NoisyLorenzSystem()
Constructs a noisy Lorenz system
"""
@def_sde_system mutable struct ForcedNoisyLorenzSystem{ET, CM, DR, DF, RO, IP, OP} <: AbstractSDESystem
σ::Float64 = 10.
β::Float64 = 8 / 3
ρ::Float64 = 28.
η::ET = 1.
cplmat::CM = I(3)
γ::Float64 = 1.
drift::DR = function forcedlorenzdrift(dx, x, u, t, σ=σ, β=β, ρ=ρ, γ=γ, cplmat=cplmat)
dx[1] = σ * (x[2] - x[1])
dx[2] = x[1] * (ρ - x[3]) - x[2]
dx[3] = x[1] * x[2] - β * x[3]
dx .*= γ
dx .+= cplmat * map(ui -> ui(t), u.itp) # Couple inputs
end
diffusion::DF = (dx, x, u, t, η=η) -> (dx .= η)
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(3)
input::IP = Inport(3)
output::OP = Outport(3)
end
##### Pretty printing
show(io::IO, ds::SDESystem) = print(io,
"SDESystem(drift:$(ds.drift), diffusion:$(ds.diffusion), readout:$(ds.readout), state:$(ds.state), t:$(ds.t), ",
"input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::NoisyLorenzSystem) = print(io,
"NoisyLorenzSystem(σ:$(ds.σ), β:$(ds.β), ρ:$(ds.ρ), η:$(ds.η), γ:$(ds.γ), state:$(ds.state), t:$(ds.t), ",
"input:$(ds.input), output:$(ds.output))")
show(io::IO, ds::ForcedNoisyLorenzSystem) = print(io,
"ForcedNoisyLorenzSystem(σ:$(ds.σ), β:$(ds.β), ρ:$(ds.ρ), η:$(ds.η), γ:$(ds.γ), cplmat:$(ds.cplmat), ",
"state:$(ds.state), t:$(ds.t), input:$(ds.input), output:$(ds.output))")
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 10505 | # This file contains the static systems of Jusdl.
import UUIDs: uuid4
"""
@def_static_system ex
where `ex` is the expression to define to define a new AbstractStaticSystem component type. The usage is as follows:
```julia
@def_source struct MyStaticSystem{T1,T2,T3,...,TN,OP, RO} <: AbstractStaticSystem
param1::T1 = param1_default # optional field
param2::T2 = param2_default # optional field
param3::T3 = param3_default # optional field
⋮
paramN::TN = paramN_default # optional field
input::IP = input_default # mandatory field
output::OP = output_default # mandatory field
readout::RO = readout_function # mandatory field
end
```
Here, `MyStaticSystem` has `N` parameters, an `output` port, an `input` port and a `readout` function.
!!! warning
`input`, `output` and `readout` are mandatory fields to define a new static system. The rest of the fields are the parameters of the system.
!!! warning
`readout` must be a two-argument function, i.e. a function of time `t` and input value `u`.
!!! warning
New static system must be a subtype of `AbstractStaticSystem` to function properly.
# Example
```jldoctest
julia> @def_static_system struct MyStaticSystem{IP, OP, RO} <: AbstractStaticSystem
α::Float64 = 1.
β::Float64 = 2.
input::IP = Inport()
output::OP = Outport()
readout::RO = (t,u) -> α * u[1] + β * u[2]
end
julia> sys = MyStaticSystem();
julia> sys.α
1.0
julia> sys.input
1-element Inport{Inpin{Float64}}:
Inpin(eltype:Float64, isbound:false)
```
"""
macro def_static_system(ex)
#= NOTE:
Generate the parameter names TR, HS, CB, ID of types of trigger, handshake, callbacks, id by using
`gensym` to avoid duplicate type parameter names so that the users can parametrizde their types as
@def_static_system struct MyStaticSystem{RO, IP, TR} <: AbstractStaticSystem
readout::RO
input::IP
output::TR
end
Note that the parameter name of output is TR. But, since the parameter name TR of trigger of the compnent
is generated by `gensym`, we get rid of duplicate parameter names.
=#
ex.args[2].head == :(<:) && ex.args[2].args[2] in [:AbstractStaticSystem, :AbstractMemory] ||
error("Invalid usage. The type should be a subtype of AbstractStaticSystem or AbstractMemory.\n$ex")
TR, HS, CB, ID = [gensym() for i in 1 : 4]
fields = quote
trigger::$(TR) = Inpin()
handshake::$(HS) = Outpin{Bool}()
callbacks::$(CB) = nothing
name::Symbol = Symbol()
id::$(ID) = Jusdl.uuid4()
end, [TR, HS, CB, ID]
_append_common_fields!(ex, fields...)
deftype(ex)
end
##### Define prototipical static systems.
"""
StaticSystem(; readout, input, output)
Consructs a generic static system with `readout` function, `input` port and `output` port.
# Example
```jldoctest
julia> ss = StaticSystem(readout = (t,u) -> u[1] + u[2], input=Inport(2), output=Outport(1));
julia> ss.readout(0., ones(2))
2.0
```
"""
@def_static_system struct StaticSystem{RO, IP, OP} <: AbstractStaticSystem
readout::RO
input::IP
output::OP
end
@doc raw"""
Adder(signs=(+,+))
Construts an `Adder` with input bus `input` and signs `signs`. `signs` is a tuplle of `+` and/or `-`. The output function `g` of `Adder` is of the form,
```math
y = g(u, t) = \sum_{j = 1}^n s_k u_k
```
where `n` is the length of the `input`, ``s_k`` is the `k`th element of `signs`, ``u_k`` is the `k`th value of `input` and ``y`` is the value of `output`. The default value of `signs` is all `+`.
# Example
```jldoctest
julia> adder = Adder(signs=(+, +, -));
julia> adder.readout([3, 4, 5], 0.) == 3 + 4 - 5
true
```
"""
@def_static_system struct Adder{S, IP, OP, RO} <: AbstractStaticSystem
signs::S = (+, +)
input::IP = Inport(length(signs))
output::OP = Outport()
readout::RO = (u, t, signs=signs) -> sum([sign(val) for (sign, val) in zip(signs, u)])
end
@doc raw"""
Multiplier(ops=(*,*))
Construts an `Multiplier` with input bus `input` and signs `signs`. `signs` is a tuplle of `*` and/or `/`. The output function `g` of `Multiplier` is of the form,
```math
y = g(u, t) = \prod_{j = 1}^n s_k u_k
```
where `n` is the length of the `input`, ``s_k`` is the `k`th element of `signs`, ``u_k`` is the `k`th value of `input` and ``y`` is the value of the `output`. The default value of `signs` is all `*`.
# Example
```jldoctest
julia> mlt = Multiplier(ops=(*, *, /));
julia> mlt.readout([3, 4, 5], 0.) == 3 * 4 / 5
true
```
"""
@def_static_system struct Multiplier{S, IP, OP, RO} <: AbstractStaticSystem
ops::S = (*,*)
input::IP = Inport(length(ops))
output::OP = Outport()
readout::RO = (u, t, ops=ops) -> begin
ops = ops
val = 1
for i = 1 : length(ops)
val = ops[i](val, u[i])
end
val
end
end
@doc raw"""
Gain(input; gain=1.)
Constructs a `Gain` whose output function `g` is of the form
```math
y = g(u, t) = K u
```
where ``K`` is `gain`, ``u`` is the value of `input` and `y` is the value of `output`.
# Example
```jldoctest
julia> K = [1. 2.; 3. 4.];
julia> sfunc = Gain(input=Inport(2), gain=K);
julia> sfunc.readout([1., 2.], 0.) == K * [1., 2.]
true
```
"""
@def_static_system struct Gain{G, IP, OP, RO} <: AbstractStaticSystem
gain::G = 1.
input::IP = Inport()
output::OP = Outport(length(gain * zeros(length(input))))
readout::RO = (u, t, gain=gain) -> gain * u
end
@doc raw"""
Terminator(input::Inport)
Constructs a `Terminator` with input bus `input`. The output function `g` is eqaul to `nothing`. A `Terminator` is used just to sink the incomming data flowing from its `input`.
"""
@def_static_system struct Terminator{IP, OP, RO} <: AbstractStaticSystem
input::IP = Inport()
output::OP = nothing
readout::RO = nothing
end
"""
Memory(delay=1.; initial::AbstractVector{T}=zeros(1), numtaps::Int=5, t0=0., dt=0.01, callbacks=nothing,
name=Symbol()) where T
Constructs a 'Memory` with input bus `input`. A 'Memory` delays the values of `input` by an amount of `numdelay`.
`initial` determines the transient output from the `Memory`, that is, until the internal buffer of `Memory` is full,
the values from `initial` is returned.
# Example
```jldoctest
julia> Memory(delay=0.1)
Memory(delay:0.1, numtaps:5, input:Inport(numpins:1, eltype:Inpin{Float64}), output:Outport(numpins:1, eltype:Outpin{Float64}))
julia> Memory(delay=0.1, numtaps=5)
Memory(delay:0.1, numtaps:5, input:Inport(numpins:1, eltype:Inpin{Float64}), output:Outport(numpins:1, eltype:Outpin{Float64}))
```
"""
@def_static_system struct Memory{D, IN, TB, DB, IP, OP, RO} <: AbstractMemory
delay::D = 1.
initial::IN = zeros(1)
numtaps::Int = 5
timebuf::TB = Buffer(numtaps)
databuf::DB = length(initial) == 1 ? Buffer(numtaps) : Buffer(length(initial), numtaps)
input::IP = Inport(length(initial))
output::OP = Outport(length(initial))
readout::RO = (u, t, delay=delay, initial=initial, numtaps=numtaps, timebuf=timebuf, databuf=databuf) -> begin
if t <= delay
return initial
else
tt = content(timebuf, flip=false)
uu = content(databuf, flip=false)
if length(tt) == 1
return uu[1]
end
if ndims(databuf) == 1
itp = CubicSplineInterpolation(range(tt[end], tt[1], length=length(tt)), reverse(uu), extrapolation_bc=Line())
return itp(t - delay)
else
itp = map(row -> CubicSplineInterpolation(range(tt[end], tt[1], length=length(tt)), reverse(row), extrapolation_bc=Line()), eachrow(uu))
return map(f -> f(t - delay), itp)
end
end
end
end
@doc raw"""
Coupler(conmat::AbstractMatrix, cplmat::AbstractMatrix)
Constructs a coupler from connection matrix `conmat` of size ``n \times n`` and coupling matrix `cplmat` of size ``d \times d``. The output function `g` of `Coupler` is of the form
```math
y = g(u, t) = (E \otimes P) u
```
where ``\otimes`` is the Kronecker product, ``E`` is `conmat` and ``P`` is `cplmat`, ``u`` is the value of `input` and `y` is the value of `output`.
"""
@def_static_system struct Coupler{C1, C2, IP, OP, RO} <: AbstractStaticSystem
conmat::C1 = [-1. 1; 1. 1.]
cplmat::C2 = [1 0 0; 0 0 0; 0 0 0]
input::IP = Inport(size(conmat, 1) * size(cplmat, 1))
output::OP = Outport(size(conmat, 1) * size(cplmat, 1))
readout::RO = typeof(conmat) <: AbstractMatrix{<:Real} ?
( (u, t, conmat=conmat, cplmat=cplmat) -> kron(conmat, cplmat) * u ) :
( (u, t, conmat=conmat, cplmat=cplmat) -> kron(map(f -> f(t), conmat), cplmat) * u )
end
@doc raw"""
Differentiator(kd=1; callbacks=nothing, name=Symbol())
Consructs a `Differentiator` whose input output relation is of the form
```math
y(t) = k_d \dot{u}(t)
```
where ``u(t)`` is the input and ``y(t)`` is the output and ``kd`` is the differentiation constant.
"""
@def_static_system struct Differentiator{IP, OP, RO} <: AbstractStaticSystem
kd::Float64 = 1.
t::Float64 = zeros(0.)
u::Float64 = zeros(0.)
input::IP = Inport()
output::OP = Outport()
readout::RO = (uu, tt, t=t, u=u, kd=kd) -> begin
val = only(uu)
sst = t[1]
ssu = u[1]
out = tt ≤ sst ? ssu : (val - ssu) / (tt - sst)
t .= t
u .= val
kd * out
end
end
##### Pretty-printing
show(io::IO, ss::StaticSystem) = print(io,"StaticSystem(readout:$(ss.readout), input:$(ss.input), output:$(ss.output))")
show(io::IO, ss::Adder) = print(io, "Adder(signs:$(ss.signs), input:$(ss.input), output:$(ss.output))")
show(io::IO, ss::Multiplier) = print(io, "Multiplier(ops:$(ss.ops), input:$(ss.input), output:$(ss.output))")
show(io::IO, ss::Gain) = print(io, "Gain(gain:$(ss.gain), input:$(ss.input), output:$(ss.output))")
show(io::IO, ss::Terminator) = print(io, "Terminator(input:$(ss.input), output:$(ss.output))")
show(io::IO, ss::Memory) =
print(io, "Memory(delay:$(ss.delay), numtaps:$(length(ss.timebuf)), input:$(ss.input), output:$(ss.output))")
show(io::IO, ss::Coupler) = print(io, "Coupler(conmat:$(ss.conmat), cplmat:$(ss.cplmat))")
show(io::IO, ss::Differentiator) = print(io, "Differentiator(kd:$(ss.kd))")
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 5956 | # This file contains the links to connect together the tools of DsSimulator.
import Base: put!, take!, close, isready, eltype, isopen, isreadable, iswritable, bind, collect, iterate
"""
Link{T}(ln::Int=64) where {T}
Constructs a `Link` with element type `T` and buffer length `ln`. The buffer element type is `T` and mode is `Cyclic`.
Link(ln::Int=64)
Constructs a `Link` with element type `Float64` and buffer length `ln`. The buffer element type is `Float64` and mode is `Cyclic`.
# Example
```jldoctest
julia> l = Link{Int}(5)
Link(state:open, eltype:Int64, isreadable:false, iswritable:false)
julia> l = Link{Bool}()
Link(state:open, eltype:Bool, isreadable:false, iswritable:false)
```
"""
mutable struct Link{T}
buffer::Buffer{Cyclic, T, 1}
channel::Channel{T}
masterid::UUID
slaveid::UUID
id::UUID
Link{T}(ln::Int=64) where {T} = new{T}(Buffer(T, ln), Channel{T}(0), uuid4(), uuid4(), uuid4())
end
Link(ln::Int=64) = Link{Float64}(ln)
show(io::IO, link::Link) = print(io, "Link(state:$(isopen(link) ? :open : :closed), eltype:$(eltype(link)), ",
"isreadable:$(isreadable(link)), iswritable:$(iswritable(link)))")
"""
eltype(link::Link)
Returns element type of `link`.
"""
eltype(link::Link{T}) where {T} = T
##### Link reading writing.
"""
put!(link::Link, val)
Puts `val` to `link`. `val` is handed over to the `channel` of `link`. `val` is also written in to the `buffer` of `link`.
!!! warning
`link` must be writable to put `val`. That is, a runnable task that takes items from the link must be bounded to `link`.
# Example
```jldoctest
julia> l = Link();
julia> t = @async while true
item = take!(l)
item === NaN && break
println("Took " * string(item))
end;
julia> bind(l, t);
julia> put!(l, 1.)
Took 1.0
1.0
julia> put!(l, 2.)
Took 2.0
2.0
julia> put!(l, NaN)
NaN
```
"""
function put!(link::Link, val)
write!(link.buffer, val)
put!(link.channel, val)
end
"""
take!(link::Link)
Take an element from `link`.
!!! warning
`link` must be readable to take value. That is, a runnable task that puts items from the link must be bounded to `link`.
# Example
```jldoctest
julia> l = Link(5);
julia> t = @async for item in 1. : 5.
put!(l, item)
end;
julia> bind(l, t);
julia> take!(l)
1.0
julia> take!(l)
2.0
```
"""
function take!(link::Link)
val = take!(link.channel)
return val
end
"""
close(link)
Closes `link`. All the task bound the `link` is also terminated safely. When closed, it is not possible to take and put element from the `link`. See also: [`take!(link::Link)`](@ref), [`put!(link::Link, val)`](@ref)
```
"""
function close(link::Link)
channel = link.channel
iswritable(link) && put!(link, NaN) # Terminate taker task
isreadable(link) && collect(link.channel) # Terminater putter task
isopen(link) && close(link.channel) # Close link channel if it is open.
return
end
##### State check of link.
"""
isopen(link::Link)
Returns `true` if `link` is open. A `link` is open if its `channel` is open.
"""
isopen(link::Link) = isopen(link.channel)
"""
isreadable(link::Link)
Returns `true` if `link` is readable. When `link` is readable, data can be read from `link` with `take` function.
"""
isreadable(link::Link) = length(link.channel.cond_put.waitq) > 0
"""
writable(link::Link)
Returns `true` if `link` is writable. When `link` is writable, data can be written into `link` with `put` function.
"""
iswritable(link::Link) = length(link.channel.cond_take.waitq) > 0
"""
isfull(link::Link)
Returns `true` if the `buffer` of `link` is full.
"""
isfull(link::Link) = isfull(link.buffer)
"""
snapshot(link::Link)
Returns all the data of the `buffer` of `link`.
"""
snapshot(link::Link) = link.buffer.data
##### Launching links.
##### Auxilary functions to launch links.
### The `taker` and `puter` functions are just used for troubleshooting purpose.
function taker(link::Link)
while true
val = take!(link)
val === NaN && break # Poison-pill the tasks to terminate safely.
@info "Took " val
end
end
function putter(link::Link, vals)
for val in vals
put!(link, val)
end
end
"""
bind(link::Link, task::Task)
Binds `task` to `link`. When `task` is done `link` is closed.
"""
bind(link::Link, task::Task) = bind(link.channel, task)
"""
collect(link::Link)
Collects all the available data on the `link`.
!!! warning
To collect all available data from `link`, a task must be bounded to it.
# Example
```jldoctest
julia> l = Link(); # Construct a link.
julia> t = @async for item in 1 : 5 # Construct a task
put!(l, item)
end;
julia> bind(l, t); # Bind it to the link.
julia> take!(l) # Take element from link.
1.0
julia> take!(l) # Take again ...
2.0
julia> collect(l) # Collect remaining data.
3-element Array{Float64,1}:
3.0
4.0
5.0
```
"""
collect(link::Link) = collect(link.channel)
"""
launch(link::Link)
Constructs a `taker` task and binds it to `link`. The `taker` task reads the data and prints an info message until `missing` is read from the `link`.
"""
function launch(link::Link)
task = @async taker(link)
bind(link.channel, task)
task
end
"""
launch(link:Link, valrange)
Constructs a `putter` task and binds it to `link`. `putter` tasks puts the data in `valrange`.
"""
function launch(link::Link, valrange)
task = @async putter(link, valrange)
bind(link.channel, task)
task
end
function launch(link::Link, taskname::Symbol, valrange)
msg = "`launch(link, taskname, valrange)` has been deprecated."
msg *= "Use `launch(link)` to launch taker task, `launch(link, valrange)` to launch putter task"
@warn msg
end
"""
refresh!(link::Link)
Reconstructst the channel of `link` is its channel is closed.
"""
refresh!(l::Link{T}) where {T} = (l.channel = Channel{T}(); l)
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 6439 | # This file contains the Pins to connect the links
"""
AbstractPin{T}
Abstract type of `Outpin` and `Inpin`. See also: [`Outpin`](@ref), [`Inpin`](@ref)
"""
abstract type AbstractPin{T} end
"""
Outpin{T}()
Constructs and `OutPut` pin. The data flow from `Outpin` is outwards from the pin i.e., data is written from `OutPort` to its links.
"""
mutable struct Outpin{T} <: AbstractPin{T}
links::Union{Vector{Link{T}}, Missing}
id::UUID
# NOTE: When Outpin is initialized, its links are missing.
# The existance of links of Outpin is used to determine
# whether the Outpin is bound or not.
Outpin{T}() where {T} = new{T}(missing, uuid4())
end
Outpin() = Outpin{Float64}()
show(io::IO, outpin::Outpin) = print(io, "Outpin(eltype:$(eltype(outpin)), isbound:$(isbound(outpin)))")
"""
Inpin{T}()
Constructs and `InPut` pin. The data flow from `Inpin` is inwards to the pin i.e., data is read from links of `InPort`.
"""
mutable struct Inpin{T} <: AbstractPin{T}
link::Union{Link{T}, Missing}
id::UUID
# NOTE: When an Inpin is initialized, its link is missing.
# The state of link of the Inpin is used to decide whether the Inpin is bound or not.
Inpin{T}() where {T} = new{T}(missing, uuid4())
end
Inpin() = Inpin{Float64}()
show(io::IO, inpin::Inpin) = print(io, "Inpin(eltype:$(eltype(inpin)), isbound:$(isbound(inpin)))")
"""
bind(link::Link, pin)
Binds `link` to `pin`. When bound, data written into or read from `pin` is written into or read from `link`.
"""
bind(link::Link, inpin::Inpin) = (inpin.link = link; link.slaveid = inpin.id)
bind(link::Link, outpin::Outpin) = (outpin.links === missing ? (outpin.links = [link]) : push!(outpin.links, link); link.masterid = outpin.id)
"""
isbound(pin::AbstractPin)
Returns `true` if `pin` is bound to other pins.
"""
function isbound(outpin::Outpin)
outpin.links === missing && return false
!isempty(outpin.links)
end
isbound(inpin::Inpin) = inpin.link !== missing
"""
eltype(pin::AbstractPin)
Returns element typef of pin.
"""
eltype(pin::AbstractPin{T}) where T = T
"""
take!(pin::Inpin)
Takes data from `pin`. The data is taken from the links of `pin`.
!!! warning
To take data from `pin`, a running task that puts data must be bound to `link` of `pin`.
# Example
```jldoctest
julia> ip = Inpin();
julia> l = Link();
julia> bind(l, ip);
julia> t = @async for item in 1 : 5
put!(l, item)
end;
julia> take!(ip)
1.0
julia> take!(ip)
2.0
```
"""
take!(pin::Inpin) = take!(pin.link)
"""
put!(pin::Outpin, val)
Puts `val` to `pin`. `val` is put into the links of `pin`.
!!! warning
To take data from `pin`, a running task that puts data must be bound to `link` of `pin`.
# Example
```jldoctest
julia> op = Outpin();
julia> l = Link();
julia> bind(l, op);
julia> t = @async while true
val = take!(l)
val === NaN && break
println("Took " * string(val))
end;
julia> put!(op, 1.)
Took 1.0
julia> put!(op, 3.)
Took 3.0
julia> put!(op, NaN)
```
"""
put!(pin::Outpin, val) = foreach(link -> put!(link, val), pin.links)
##### Connecting and disconnecting links
# #
# # This `iterate` function is dummy. It is defined just for `[l...]` to be written.
# #
# iterate(l::AbstractPin, i=1) = i > 1 ? nothing : (l, i + 1)
"""
connect!(outpin::Link, inpin::Link)
Connects `outpin` to `inpin`. When connected, any element that is put into `outpin` is also put into `inpin`.
connect!(outpin::AbstractVector{<:Link}, inpin::AbstractVector{<:Link})
Connects each link in `outpin` to each link in `inpin` one by one. See also: [`disconnect!`](@ref)
# Example
```jldoctest
julia> op, ip = Outpin(), Inpin();
julia> l = connect!(op, ip)
Link(state:open, eltype:Float64, isreadable:false, iswritable:false)
julia> l in op.links
true
julia> ip.link === l
true
```
"""
function connect!(outpin::Outpin, inpin::Inpin)
# NOTE: The connecion of an `Outpin` to multiple `Inpin`s is possible since an `Outpin` may drive multiple
# `Inpin`s. However, the connection of multiple `Outpin`s to the same `Inpin` is NOT possible since an `Inpin`
# can be driven by a single `Outpin`.
isbound(inpin) && error("$inpin is already bound. No new connections.")
isconnected(outpin, inpin) && (@warn "$outpin and $inpin are already connected."; return)
link = Link{promote_type(eltype(outpin), eltype(inpin))}()
bind(link, outpin)
bind(link, inpin)
return link
end
connect!(outpins::AbstractVector{<:Outpin}, inpins::AbstractVector{<:Inpin}) = connect!.(outpins, inpins)
"""
disconnect!(link1::Link, link2::Link)
Disconnects `link1` and `link2`. The order of arguments is not important. See also: [`connect!`](@ref)
"""
function disconnect!(outpin::Outpin, inpin::Inpin)
outpin.links === missing || deleteat!(outpin.links, findall(link -> link == inpin.link, outpin.links))
inpin.link = missing
# inpin.link = Link{eltype(inpin)}()
end
disconnect!(outpins::AbstractVector{<:Outpin}, inpins::AbstractVector{<:Inpin}) = (disconnect!.(outpins, inpins); nothing)
"""
isconnected(link1, link2)
Returns `true` if `link1` is connected to `link2`. The order of the arguments are not important.
See also [`connect!`](@ref), [`disconnect!`](@ref)
"""
function isconnected(outpin::Outpin, inpin::Inpin)
if !isbound(outpin) || !isbound(inpin)
return false
else
inpin.link in [link for link in outpin.links]
end
end
isconnected(outpins::AbstractVector{<:Outpin}, inpins::AbstractVector{<:Inpin}) = all(isconnected.(outpins, inpins))
# ------------------------ Deprecations -----------------------
#= NOTE:
The methods
connect!(outpins, inpins) = connect!([outpins...], [inpins...])
disconnect!(outpins, inpins) = disconnect!([outpins...], [inpins...])
isconnected(outpins, inpins) = isconnected([outpins...], [inpins...])
are ambiguis. Since these methods throws StackOverflowError when called with `outpins` are `Inpin`s and
inpins are `Outpin`s. So, there is not need for
iterate(l::AbstractPin, i=1) = i > 1 ? nothing : (l, i + 1)
method-
=#
# """
# UnconnectedLinkError <: Exception
# Exception thrown when the links are not connected to each other.
# """
# struct UnconnectedLinkError <: Exception
# msg::String
# end
# Base.showerror(io::IO, err::UnconnectedLinkError) = print(io, "UnconnectedLinkError:\n $(err.msg)")
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 6138 | # This file contains the Port tool for connecting the tools of Jusdl
"""
AbstractPort{P}
Abstract type of [`Outport`](@ref) and [`Inport`](@ref). See also: [`Outport`](@ref), [`Inport`](@ref).
"""
abstract type AbstractPort{P} <: AbstractVector{P} end
"""
Outport{T}(numpins=1)
Constructs an `Outport` with `numpins` [`Outpin`](@ref).
!!! warning
Element type of an `Outport` must be `Outpin`. See also [`Outpin`](@ref)
# Example
```jldoctest
julia> Outport{Int}(2)
2-element Outport{Outpin{Int64}}:
Outpin(eltype:Int64, isbound:false)
Outpin(eltype:Int64, isbound:false)
julia> Outport()
1-element Outport{Outpin{Float64}}:
Outpin(eltype:Float64, isbound:false)
```
"""
struct Outport{P} <: AbstractPort{P}
pins::Vector{P}
id::UUID
Outport(pins::AbstractVector{P}) where {T, P<:Outpin{T}} = new{P}(pins, uuid4())
end
Outport(pin::Outpin) = Outport([pin])
Outport{T}(numpins::Int=1) where T = Outport([Outpin{T}() for i = 1 : numpins])
Outport(numpins::Int=1) = Outport{Float64}(numpins)
show(io::IO, outport::Outport) = print(io, "Outport(numpins:$(length(outport)), eltype:$(eltype(outport)))")
# display(outport::Outport) = println("Outport(numpins:$(length(outport)), eltype:$(eltype(outport)))")
"""
Inport{T}(numpins=1)
Constructs an `Inport` with `numpins` [`Inpin`](@ref).
!!! warning
Element type of an `Inport` must be `Inpin`. See also [`Inpin`](@ref)
# Example
```jldoctest
julia> Inport{Int}(2)
2-element Inport{Inpin{Int64}}:
Inpin(eltype:Int64, isbound:false)
Inpin(eltype:Int64, isbound:false)
julia> Inport()
1-element Inport{Inpin{Float64}}:
Inpin(eltype:Float64, isbound:false)
```
"""
struct Inport{P} <: AbstractPort{P}
pins::Vector{P}
Inport(pins::AbstractVector{P}) where {T, P<:Inpin{T}} = new{P}(pins)
end
Inport(pin::Inpin) = Inport([pin])
Inport{T}(numpins::Int=1) where T = Inport([Inpin{T}() for i = 1 : numpins])
Inport(numpins::Int=1) = Inport{Float64}(numpins)
show(io::IO, inport::Inport) = print(io, "Inport(numpins:$(length(inport)), eltype:$(eltype(inport)))")
# display(inport::Inport) = println("Inport(numpins:$(length(inport)), eltype:$(eltype(inport)))")
"""
datatype(port::AbstractPort)
Returns the data type of `port`.
"""
datatype(port::AbstractPort{<:AbstractPin{T}}) where T = T
##### AbstractVector interface
"""
size(port::AbstractPort)
Retruns size of `port`.
"""
size(port::AbstractPort) = size(port.pins)
"""
getindex(port::AbstractPort, idx::Vararg{Int, N}) where N
Returns elements from `port` at index `idx`. Same as `port[idx]`.
# Example
```jldoctest
julia> op = Outport(3)
3-element Outport{Outpin{Float64}}:
Outpin(eltype:Float64, isbound:false)
Outpin(eltype:Float64, isbound:false)
Outpin(eltype:Float64, isbound:false)
julia> op[1]
Outpin(eltype:Float64, isbound:false)
julia> op[end]
Outpin(eltype:Float64, isbound:false)
julia> op[:]
3-element Array{Outpin{Float64},1}:
Outpin(eltype:Float64, isbound:false)
Outpin(eltype:Float64, isbound:false)
Outpin(eltype:Float64, isbound:false)
```
"""
getindex(port::AbstractPort, idx::Vararg{Int, N}) where N = port.pins[idx...]
"""
setindex!(port::AbstractPort, item, idx::Vararg{Int, N}) where N
Sets `item` to `port` at index `idx`. Same as `port[idx] = item`.
# Example
```jldoctest
julia> op = Outport(3)
3-element Outport{Outpin{Float64}}:
Outpin(eltype:Float64, isbound:false)
Outpin(eltype:Float64, isbound:false)
Outpin(eltype:Float64, isbound:false)
julia> op[1] = Outpin()
Outpin(eltype:Float64, isbound:false)
julia> op[end] = Outpin()
Outpin(eltype:Float64, isbound:false)
julia> op[1:2] = [Outpin(), Outpin()]
2-element Array{Outpin{Float64},1}:
Outpin(eltype:Float64, isbound:false)
Outpin(eltype:Float64, isbound:false)
```
"""
setindex!(port::AbstractPort, item, idx::Vararg{Int, N}) where N = port.pins[idx...] = item
##### Reading from and writing into from buses
"""
take!(inport::Inport)
Takes an element from `inport`. Each link of the `inport` is a read and a vector containing the results is returned.
!!! warning
The `inport` must be readable to be read. That is, there must be a runnable tasks bound to links of the `inport` that writes data to `inport`.
# Example
```jldoctest
julia> op, ip = Outport(), Inport()
(Outport(numpins:1, eltype:Outpin{Float64}), Inport(numpins:1, eltype:Inpin{Float64}))
julia> ls = connect!(op, ip)
1-element Array{Link{Float64},1}:
Link(state:open, eltype:Float64, isreadable:false, iswritable:false)
julia> t = @async for val in 1 : 5
put!(op, [val])
end;
julia> take!(ip)
1-element Array{Float64,1}:
1.0
julia> take!(ip)
1-element Array{Float64,1}:
2.0
```
"""
take!(inport::Inport) = take!.(inport[:])
"""
put!(outport::Outport, vals)
Puts `vals` to `outport`. Each item in `vals` is putted to the `links` of the `outport`.
!!! warning
The `outport` must be writable to be read. That is, there must be a runnable tasks bound to links of the `outport` that reads data from `outport`.
# Example
```jldoctest
julia> op, ip = Outport(), Inport()
(Outport(numpins:1, eltype:Outpin{Float64}), Inport(numpins:1, eltype:Inpin{Float64}))
julia> ls = connect!(op, ip)
1-element Array{Link{Float64},1}:
Link(state:open, eltype:Float64, isreadable:false, iswritable:false)
julia> t = @async while true
val = take!(ip)
all(val .=== NaN) && break
println("Took " * string(val))
end;
julia> put!(op, [1.])
Took [1.0]
1-element Array{Float64,1}:
1.0
julia> put!(op, [NaN])
1-element Array{Float64,1}:
NaN
```
"""
function put!(outport::Outport, vals)
put!.(outport[:], vals)
vals
end
##### Interconnection of busses.
"""
similar(port, numpins::Int=length(outport)) where {P<:Outpin{T}} where {T}
Returns a new port that is similar to `port` with the same element type. The number of links in the new port is `nlinks` and data buffer length is `ln`.
"""
similar(outport::Outport{P}, numpins::Int=length(outport)) where {P<:Outpin{T}} where {T} = Outport{T}(numpins)
similar(inport::Inport{P}, numpins::Int=length(inport)) where {P<:Inpin{T}} where {T} = Inport{T}(numpins)
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 26202 | # This file includes the Model object
"""
Node(component, idx, label)
Constructs a model `Node` with `component`. `idx` is the index and `label` is label of `Node`.
"""
struct Node{CP, L}
component::CP
idx::Int
label::L
end
show(io::IO, node::Node) = print(io, "Node(component:$(node.component), idx:$(node.idx), label:$(node.label))")
"""
Branch(nodepair, indexpair, links)
Constructs a `Branch` connecting the first and second element of `nodepair` with `links`. `indexpair` determines the subindices by which the elements of `nodepair` are connected.
"""
struct Branch{NP, IP, LN<:AbstractVector{<:Link}}
nodepair::NP
indexpair::IP
links::LN
end
show(io::IO, branch::Branch) = print(io, "Branch(nodepair:$(branch.nodepair), indexpair:$(branch.indexpair), ",
"links:$(branch.links))")
"""
Model(components::AbstractVector)
Constructs a `Model` whose with components `components` which are of type `AbstractComponent`.
Model()
Constructs a `Model` with empty components. After the construction, components can be added to `Model`.
!!! warning
`Model`s are units that can be simulated. As the data flows through the branches i.e. input output busses of the components, its is important that the components must be connected to each other. See also: [`simulate!`](@ref)
"""
struct Model{GR, ND, BR, CK, TM, CB}
graph::GR
nodes::ND
branches::BR
clock::CK
taskmanager::TM
callbacks::CB
name::Symbol
id::UUID
function Model(nodes::AbstractVector=[], branches::AbstractVector=[];
clock=Clock(0, 0.01, 1.), callbacks=nothing, name=Symbol())
graph = SimpleDiGraph()
taskmanager = TaskManager()
new{typeof(graph), typeof(nodes), typeof(branches), typeof(clock), typeof(taskmanager),
typeof(callbacks)}(graph, nodes, branches, clock, taskmanager, callbacks, name, uuid4())
end
end
show(io::IO, model::Model) = print(io, "Model(numnodes:$(length(model.nodes)), ",
"numedges:$(length(model.branches)), timesettings=($(model.clock.t), $(model.clock.dt), $(model.clock.tf)))")
##### Addinng nodes and branches.
"""
addnode!(model, component; label=nothing)
Adds a node to `model`. Component is `component` and `label` is `label` the label of node. Returns added node.
# Example
```jldoctest
julia> model = Model()
Model(numnodes:0, numedges:0, timesettings=(0.0, 0.01, 1.0))
julia> addnode!(model, SinewaveGenerator(), label=:gen)
Node(component:SinewaveGenerator(amp:1.0, freq:1.0, phase:0.0, offset:0.0, delay:0.0), idx:1, label:gen)
```
"""
function addnode!(model::Model, component::AbstractComponent; label=nothing)
label === nothing || label in [node.label for node in model.nodes] && error(label," is already assigned.")
node = Node(component, length(model.nodes) + 1, label)
push!(model.nodes, node)
register(model.taskmanager, component)
add_vertex!(model.graph)
node
end
"""
getnode(model, idx::Int)
Returns node of `model` whose index is `idx`.
getnode(model, label)
Returns node of `model` whose label is `label`.
# Example
```jldoctest
julia> model = Model()
Model(numnodes:0, numedges:0, timesettings=(0.0, 0.01, 1.0))
julia> addnode!(model, SinewaveGenerator(), label=:gen)
Node(component:SinewaveGenerator(amp:1.0, freq:1.0, phase:0.0, offset:0.0, delay:0.0), idx:1, label:gen)
julia> addnode!(model, Gain(), label=:gain)
Node(component:Gain(gain:1.0, input:Inport(numpins:1, eltype:Inpin{Float64}), output:Outport(numpins:1, eltype:Outpin{Float64})), idx:2, label:gain)
julia> getnode(model, :gen)
Node(component:SinewaveGenerator(amp:1.0, freq:1.0, phase:0.0, offset:0.0, delay:0.0), idx:1, label:gen)
julia> getnode(model, 2)
Node(component:Gain(gain:1.0, input:Inport(numpins:1, eltype:Inpin{Float64}), output:Outport(numpins:1, eltype:Outpin{Float64})), idx:2, label:gain)
```
"""
getnode(model::Model, idx::Int) = model.nodes[idx]
getnode(model::Model, label) = filter(node -> node.label === label, model.nodes)[1]
function register(taskmanager, component)
triggerport, handshakeport = taskmanager.triggerport, taskmanager.handshakeport
triggerpin, handshakepin = Outpin(), Inpin{Bool}()
connect!(triggerpin, component.trigger)
connect!(component.handshake, handshakepin)
push!(triggerport.pins, triggerpin)
push!(handshakeport.pins, handshakepin)
taskmanager.pairs[component] = nothing
end
"""
addbranch!(model::Model, branch::Branch)
Adds `branch` to branched of `model`.
"""
function addbranch!(model::Model, nodepair::Pair, indexpair::Pair=(:)=>(:))
srcnode, dstnode = getnode(model, nodepair.first), getnode(model, nodepair.second)
links = connect!(srcnode.component.output[indexpair.first], dstnode.component.input[indexpair.second])
typeof(links) <: AbstractVector{<:Link} || (links = [links])
srcidx, dstidx = srcnode.idx, dstnode.idx
branch = Branch(srcidx => dstidx, indexpair, links)
push!(model.branches, branch)
add_edge!(model.graph, srcidx, dstidx)
branch
end
getbranch(model::Model, nodepair::Pair{Int, Int}) = filter(branch -> branch.nodepair == nodepair, model.branches)[1]
getbranch(model::Model, nodepair::Pair{Symbol, Symbol}) =
getbranch(model, getnode(model, nodepair.first).idx => getnode(model, nodepair.second).idx)
"""
deletebranch!(model::Model, branch::Branch)
Deletes `branch` from branched of `model`.
deletebranch!(model::Model, srcnode::Node, dstnode::Node)
Deletes branch between `srcnode` and `dstnode` of the `model`.
"""
function deletebranch!(model::Model, nodepair::Pair{Int, Int})
srcnode, dstnode = getnode(model, nodepair.first), getnode(model, nodepair.second)
branch = getbranch(model, nodepair)
srcidx, dstidx = branch.indexpair
disconnect!(srcnode.component.output[srcidx], dstnode.component.input[dstidx])
deleteat!(model.branches, findall(br -> br == branch, model.branches))
rem_edge!(model.graph, srcnode.idx, dstnode.idx)
branch
end
deletebranch!(model::Model, nodepair::Pair{Symbol, Symbol}) =
deletebranch!(model, getnode(model, nodepair.first).idx, getnode(model, nodepair.second).idx)
##### Model inspection.
"""
inspect!(model::Model)
Inspects the `model`. If `model` has some inconsistencies such as including algebraic loops or unterminated busses and
error is thrown.
"""
function inspect!(model, breakpoints::Vector{Int}=Int[])
# Check unbound pins in ports of componensts
checknodeports(model)
# Check links of the model
checkchannels(model)
# Break algebraic loops if there exits.
loops = getloops(model)
if !isempty(loops)
msg = "\tThe model has algrebraic loops:$(loops)"
msg *= "\n\t\tTrying to break these loops..."
@info msg
while !isempty(loops)
loop = popfirst!(loops)
if hasmemory(model, loop)
@info "\tLoop $loop has a Memory component. The loops is broken"
continue
end
breakpoint = isempty(breakpoints) ? length(loop) : popfirst!(breakpoints)
breakloop!(model, loop, breakpoint)
@info "\tLoop $loop is broken"
loops = getloops(model)
end
end
# Return model
model
end
hasmemory(model, loop) = any([getnode(model, idx).component isa Memory for idx in loop])
"""
getloops(model)
Returns idx of nodes that constructs algrebraic loops.
"""
getloops(model::Model) = simplecycles(model.graph)
# LoopBreaker to break the loop
@def_static_system struct LoopBreaker{OP, RO} <: AbstractStaticSystem
input::Nothing = nothing
output::OP
readout::RO
end
"""
breakloop!(model, loop, breakpoint=length(loop))
Breaks the algebraic `loop` of `model`. The `loop` of the `model` is broken by inserting a `Memory` at the `breakpoint`
of loop.
"""
function breakloop!(model::Model, loop, breakpoint=length(loop))
nftidx = findfirst(idx -> !isfeedthrough(getnode(model, idx).component), loop)
nftidx === nothing || (breakpoint = nftidx)
# Delete the branch at the breakpoint.
srcnode = getnode(model, loop[breakpoint])
if breakpoint == length(loop)
dstnode = getnode(model, loop[1])
else
dstnode = getnode(model, loop[(breakpoint + 1)])
end
branch = getbranch(model, srcnode.idx => dstnode.idx)
# Construct the loopbreaker.
if nftidx === nothing
nodefuncs = wrap(model, loop)
ff = feedforward(nodefuncs, breakpoint)
n = length(srcnode.component.output)
breaker = LoopBreaker(readout = (u,t) -> findroot(ff, n, t), output=Outport(n))
else
component = srcnode.component
n = length(component.output)
breaker = LoopBreaker(readout = (u,t)->component.readout(component.state, nothing, t), output=Outport(n))
end
# newidx = length(model.nodes) + 1
newnode = addnode!(model, breaker)
# Delete the branch at the breakpoint
deletebranch!(model, branch.nodepair)
# Connect the loopbreker to the loop at the breakpoint.
addbranch!(model, newnode.idx => dstnode.idx, branch.indexpair)
return newnode
end
function wrap(model, loop)
graph = model.graph
map(loop) do idx
node = getnode(model, idx)
innbrs = filter(i -> i ∉ loop, inneighbors(graph, idx))
outnbrs = filter(i -> i ∉ loop, outneighbors(graph, idx))
if isempty(innbrs) && isempty(outnbrs)
zero_in_zero_out(node)
elseif isempty(innbrs) && !isempty(outnbrs)
zero_in_nonzero_out(node, getoutmask(model, node, loop))
elseif !isempty(innbrs) && isempty(outnbrs)
nonzero_in_zero_out(node, getinmask(model, node, loop))
else
nonzero_in_nonzero_out(node, getinmask(model, node, loop), getoutmask(model, node, loop))
end
end
end
function zero_in_zero_out(node)
component = node.component
function func(ut)
u, t = ut
out = [_computeoutput(component, u, t)...]
out, t
end
end
function zero_in_nonzero_out(node, outmask)
component = node.component
function func(ut)
u, t = ut
out = [_computeoutput(component, u, t)...]
out[outmask], t
end
end
function nonzero_in_zero_out(node, inmask)
component = node.component
nin = length(inmask)
function func(ut)
u, t = ut
uu = zeros(nin)
uu[inmask] .= readbuffer(component.input, inmask)
uu[.!inmask] .= u
out = [_computeoutput(component, uu, t)...]
out, t
end
end
function nonzero_in_nonzero_out(node, inmask, outmask)
component = node.component
nin = length(inmask)
function func(ut)
u, t = ut
uu = zeros(nin)
uu[inmask] .= readbuffer(component.input, inmask)
uu[.!inmask] .= u
out = [_computeoutput(component, uu, t)...]
out[outmask]
out, t
end
end
function getinmask(model, node, loop)
idx = node.idx
inmask = falses(length(node.component.input))
for nidx in filter(n -> n ∉ loop, inneighbors(model.graph, idx)) # Not-in-loop inneighbors
k = getbranch(model, nidx => idx).indexpair.second
if length(k) == 1
inmask[k] = true
else
inmask[k] .= trues(length(k))
end
end
inmask
end
function getoutmask(model, node, loop)
idx = node.idx
outmask = falses(length(node.component.output))
for nidx in filter(n -> n ∈ loop, outneighbors(model.graph, idx)) # In-loop outneighbors
k = getbranch(model, idx => nidx).indexpair.first
if length(k) == 1
outmask[k] = true
else
outmask[k] .= trues(length(k))
end
end
outmask
end
readbuffer(input, inmask) = map(pin -> read(pin.link.buffer), input[inmask])
_computeoutput(comp::AbstractStaticSystem, u, t) = comp.readout(u, t)
_computeoutput(comp::AbstractDynamicSystem, u, t) = comp.readout(comp.state, map(uu -> t -> uu, u), t)
function feedforward(nodefuncs, breakpoint=length(nodefuncs))
(u, t) -> ∘(reverse(circshift(nodefuncs, -breakpoint))...)((u, t))[1] - u
end
function findroot(ff, n, t)
sol = nlsolve((dx, x) -> (dx .= ff(x, t)), rand(n))
sol.zero
end
function isfeedthrough(component)
try
out = typeof(component) <: AbstractStaticSystem ?
component.readout(nothing, 0.) : component.readout(component.state, nothing, 0.)
return false
catch ex
return true
end
end
# Check if components of nodes of the models has unbound pins. In case there are any unbound pins,
# the simulation is got stuck since the data flow through an unbound pin is not possible.
checknodeports(model) = foreach(node -> checkports(node.component), model.nodes)
function checkports(comp::T) where T
if hasfield(T, :input)
idx = unboundpins(comp.input)
isempty(idx) || error("Input port of $comp has unbound pins at index $idx")
end
if hasfield(T, :output)
idx = unboundpins(comp.output)
isempty(idx) || error("Output port of $comp has unbound pins at index $idx")
end
end
unboundpins(port::AbstractPort) = findall(.!isbound.(port))
unboundpins(port::Nothing) = Int[]
# Checks if all the channels the links in the model is open. If a link is not open, than
# it is not possible to bind a task that reads and writes data from the channel.
function checkchannels(model)
# Check branch links
for branch in model.branches
for link in branch.links
isopen(link) || refresh!(link)
end
end
# Check taskmanager links
for pin in model.taskmanager.triggerport
link = only(pin.links)
isopen(link) || refresh!(link)
end
for pin in model.taskmanager.handshakeport
link = pin.link
isopen(link) || refresh!(link)
end
end
##### Model initialization
"""
initialize!(model::Model)
Initializes `model` by launching component task for each of the component of `model`. The pairs component and component tasks are recordedin the task manager of the `model`. The `model` clock is [`set!`](@ref) and the files of [`Writer`](@ref) are openned.
"""
function initialize!(model::Model)
taskmanager = model.taskmanager
pairs = taskmanager.pairs
nodes = model.nodes
# NOTE: Tasks to make the components be triggerable are launched here.
# The important point here is that the simulation should be cancelled if an error is thrown in any of the tasks
# launched here. This is done by binding the task to the chnnel of the trigger link of the component. Hrence the
# lifetime of the channel of the link connecting the component to the taskmanger is determined by the lifetime of
# the task launched for the component. To cancel the simulation and report the stacktrace the task is `fetch`ed.
for node in nodes
component = node.component
link = whichlink(taskmanager, component) # Link connecting the component to taskmanager.
task = launch(component) # Task launched to make `componnent` be triggerable.
bind(link.channel, task) # Bind the task to the channel of the link.
pairs[component] = task
end
# Turn on clock model clock if it is running.
if isoutoftime(model.clock)
msg = "Model clock is out of time. Its current time $(model.clock.t) should be less than its final time "
msg *= "$(model.clock.tf). Resettting the model clock to its defaults."
@warn msg
set!(model.clock)
end
isrunning(model.clock) || set!(model.clock)
# Open the files, GUI's for sink components.
foreach(node -> open(node.component), filter(node->isa(node.component, AbstractSink), model.nodes))
# Return the model back.
model
end
# Find the link connecting `component` to `taskmanager`.
function whichlink(taskmanager, component)
tpin = component.trigger
tport = taskmanager.triggerport
# NOTE: `component` must be connected to `taskmanager` by a single link which is checked by `only`
# `outpin.links` must have just a single link which checked by `only`
outpin = filter(pin -> isconnected(pin, tpin), tport) |> only
outpin.links |> only
end
##### Model running
# Copy-paste loop body. See `run!(model, withbar)`.
# NOTE: We first trigger the component, Then the tasks fo the `taskmanager` is checked. If an error is thrown in one
# of the tasks, the simulation is cancelled and stacktrace is printed reporting the error. In order to ensure the
# time synchronization between the components of the model, `handshakeport` of the taskmanger is read. When all the
# components take step succesfully, then the simulation goes with the next step after calling the callbacks of the
# components.
# Note we first check the tasks of the taskmanager and then read the `handshakeport` of the taskmanager. Otherwise,
# the simulation gets stuck without printing the stacktrace if an error occurs in one of the tasks of the taskmanager.
@def loopbody begin
put!(triggerport, fill(t, ncomponents))
checktaskmanager(taskmanager)
all(take!(handshakeport)) || @warn "Taking step could not be approved."
applycallbacks(model)
end
"""
run!(model::Model, withbar::Bool=true)
Runs the `model` by triggering the components of the `model`. This triggering is done by generating clock tick using the model clock `model.clock`. Triggering starts with initial time of model clock, goes on with a step size of the sampling period of the model clock, and finishes at the finishing time of the model clock. If `withbar` is `true`, a progress bar indicating the simulation status is displayed on the console.
!!! warning
The `model` must first be initialized to be run. See also: [`initialize!`](@ref).
"""
function run!(model::Model, withbar::Bool=true)
taskmanager = model.taskmanager
triggerport, handshakeport = taskmanager.triggerport, taskmanager.handshakeport
ncomponents = length(model.nodes)
clock = model.clock
withbar ? (@showprogress clock.dt for t in clock @loopbody end) : (for t in clock @loopbody end)
model
end
# ##### Model termination
# """
# release(model::Model)
# Releaes the each component of `model`, i.e., the input and output bus of each component is released.
# """
# release(model::Model) = foreach(release, model.nodes)
"""
terminate!(model::Model)
Terminates `model` by terminating all the components of the `model`, i.e., the components tasks in the task manager of the `model` is terminated.
"""
function terminate!(model::Model)
taskmanager = model.taskmanager
tasks = unwrap(collect(values(taskmanager.pairs)), Task, depth=length(taskmanager.pairs))
any(istaskstarted.(tasks)) && put!(taskmanager.triggerport, fill(NaN, length(model.nodes)))
isrunning(model.clock) && stop!(model.clock)
model
end
function _simulate(sim::Simulation, reportsim::Bool, withbar::Bool, breakpoints::Vector{Int})
model = sim.model
@siminfo "Started simulation..."
sim.state = :running
@siminfo "Inspecting model..."
inspect!(model, breakpoints)
@siminfo "Done."
@siminfo "Initializing the model..."
initialize!(model)
@siminfo "Done..."
@siminfo "Running the simulation..."
run!(model, withbar)
sim.state = :done
sim.retcode = :success
@siminfo "Done..."
@siminfo "Terminating the simulation..."
terminate!(model)
@siminfo "Done."
reportsim && report(sim)
return sim
end
"""
simulate!(model::Model; simdir::String=tempdir(), simprefix::String="Simulation-", simname=string(uuid4()),
logtofile::Bool=false, loglevel::LogLevel=Logging.Info, reportsim::Bool=false, withbar::Bool=true)
Simulates `model`. `simdir` is the path of the directory into which simulation files are saved. `simprefix` is the prefix of the simulation name `simname`. If `logtofile` is `true`, a log file for the simulation is constructed. `loglevel` determines the logging level. If `reportsim` is `true`, model components are saved into files. If `withbar` is `true`, a progress bar indicating the simualation status is displayed on the console.
"""
function simulate!(model::Model; simdir::String=tempdir(), simprefix::String="Simulation-", simname=string(uuid4()),
logtofile::Bool=false, loglevel::LogLevel=Logging.Info, reportsim::Bool=false, withbar::Bool=true,
breakpoints::Vector{Int}=Int[])
# Construct a Simulation
sim = Simulation(model, simdir=simdir, simprefix=simprefix, simname=simname)
sim.logger = logtofile ? SimpleLogger(open(joinpath(sim.path, "simlog.log"), "w+"), loglevel) : ConsoleLogger(stderr, loglevel)
# Simualate the modoel
with_logger(sim.logger) do
_simulate(sim, reportsim, withbar, breakpoints)
end
logtofile && flush(sim.logger.stream) # Close logger file stream.
return sim
end
"""
simulate!(model::Model, t0::Real, dt::Real, tf::Real; kwargs...)
Simulates the `model` starting from the initial time `t0` until the final time `tf` with the sampling interval of `tf`. For `kwargs` are
* `logtofile::Bool`: If `true`, a log file is contructed logging each step of the simulation.
* `reportsim::Bool`: If `true`, `model` components are written files after the simulation. When this file is read back, the model components can be consructed back with their status at the end of the simulation.
* `simdir::String`: The path of the directory in which simulation file are recorded.
"""
function simulate!(model::Model, t0::Real, dt::Real, tf::Real; kwargs...)
set!(model.clock, t0, dt, tf)
simulate!(model; kwargs...)
end
#### Troubleshooting
"""
troubleshoot(model)
Prints the exceptions of the tasks that are failed during the simulation of `model`.
"""
function troubleshoot(model::Model)
fails = filter(pair -> istaskfailed(pair.second), model.taskmanager.pairs)
if isempty(fails)
@info "No failed tasks in $model."
else
for (comp, task) in fails
println("", comp)
@error task.exception
end
end
end
##### Plotting signal flow of the model
"""
signalflow(model, args...; kwargs...)
Plots the signal flow of `model`. `args` and `kwargs` are passed into [`gplot`](https://github.com/JuliaGraphs/GraphPlot.jl) function.
"""
signalflow(model::Model, args...; kwargs...) =
gplot(model.graph, args...; nodelabel=[node.label for node in model.nodes], kwargs...)
##### @model macro
function check_macro_syntax(name, ex)
name isa Symbol || error("Invalid usage of @model")
ex isa Expr && ex.head == :block || error("Invalid usage of @model")
end
function check_block_syntax(node_expr, branch_expr)
#------------------- Node expression check ---------------
# Check syntax the following syntax
# @nodes begin
# label1 = Component1()
# label2 = Component2()
# ⋮
# end
(
node_expr isa Expr &&
node_expr.head === :(macrocall) &&
node_expr.args[1] === Symbol("@nodes")
) || error("Invalid usage of @nodes")
node_block = node_expr.args[3]
(
node_block.head === :block &&
all([ex.head === :(=) for ex in filter(arg -> isa(arg, Expr), node_block.args)])
) || error("Invalid usage of @nodes")
#--------------------- Branch expression check --------------
# Check syntax the following syntax
# @branches begin
# src1[srcidx1] => dst1[dstidx1]
# src2[srcidx2] => dst2[dstidx2]
# ⋮
# end
(
branch_expr isa Expr &&
branch_expr.head === :(macrocall) &&
branch_expr.args[1] === Symbol("@branches")
) || error("Invalid usage of @branches")
branch_block = branch_expr.args[3]
(
branch_block.head === :block &&
all([ex.head === :call && ex.args[1] == :(=>) for ex in filter(arg -> isa(arg, Expr), branch_block.args)])
) || error("Invalid usage of @branches")
end
"""
@defmodel name ex
Construts a model. The expected syntax is.
```
@defmodel mymodel begin
@nodes begin
label1 = Component1()
label2 = Component1()
⋮
end
@branches begin
src1 => dst1
src2 => dst2
⋮
end
end
```
Here `@nodes` and `@branches` blocks adefine the nodes and branches of the model, respectively.
"""
macro defmodel(name, ex)
# Check syntax
check_macro_syntax(name, ex)
node_expr = ex.args[2]
branch_expr = ex.args[4]
check_block_syntax(node_expr, branch_expr)
# Extract nodes info
node_block = node_expr.args[3]
node_labels = [expr.args[1] for expr in node_block.args if expr isa Expr]
node_components = [expr.args[2] for expr in node_block.args if expr isa Expr]
# Extract branches info
branch_block = branch_expr.args[3]
lhs = [expr.args[2] for expr in filter(ex -> isa(ex, Expr), branch_block.args)]
rhs = [expr.args[3] for expr in filter(ex -> isa(ex, Expr), branch_block.args)]
quote
# Construct model
$name = Model()
# Add nodes to model
for (node_label, node_component) in zip($node_labels, $node_components)
addnode!($name, eval(node_component), label=node_label)
end
# Add braches to model
for (src, dst) in zip($lhs, $rhs)
if src isa Symbol && dst isa Symbol
addbranch!($name, src => dst)
elseif src isa Expr && dst isa Expr # src and dst has index.
if src.args[2] isa Expr && dst.args[2] isa Expr
# array or range index.
addbranch!($name, src.args[1] => dst.args[1], eval(src.args[2]) => eval(dst.args[2]))
else
# integer index
addbranch!($name, src.args[1] => dst.args[1], src.args[2] => dst.args[2])
end
else
error("Ambbiuos connection. Specify the indexes explicitely.")
end
end
end |> esc
end
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 4270 | # This file is for Simulation object.
"""
Simulation(model; simdir=tempdir(), simname=string(uuid4()), simprefix="Simulation-", logger=SimpleLogger())
Constructs a `Simulation` object for the simulation of `model`. The `Simulation` object is used to monitor the state of the simulation of the `model`. `simdir` is the path of the directory into which the simulation files(log, data files etc.) are recorded. `simname` is the name of the `Simulation` and `simprefix` is the prefix of the name of the `Simulation`. `logger` is used to log the simulation steps of the `model`. See also: [`Model`](@ref), [`Logging`](https://docs.julialang.org/en/v1/stdlib/Logging/)
"""
mutable struct Simulation{MD}
model::MD
path::String
logger::Union{SimpleLogger, ConsoleLogger}
state::Symbol
retcode::Symbol
name::String
function Simulation(model; simdir=tempdir(), simname=string(uuid4()), simprefix="Simulation-",
logger=SimpleLogger())
name = simprefix * simname # `get_instant()` may be used for time-based paths names.
path = joinpath(simdir, name)
ispath(path) || mkpath(path)
check_writer_files(model, path, force=true)
new{typeof(model)}(model, path, logger, :idle, :unknown, name)
end
end
show(io::IO, sim::Simulation) = print(io, "Simulation(state:$(sim.state), retcode:$(sim.retcode), path:$(sim.path))")
##### Simulation checks
function check_writer_files(model, path; force=true)
for node in filter(node-> isa(node.component, Writer), model.nodes)
dirname(node.component.file.path) == path || mv(node.component, path, force=true)
end
end
##### Simulation logging
"""
setlogger(path, name; setglobal::Bool=true)
Returns a logger. `path` is the path and `name` is the name of the file of the logger. If `setglobal` is `true`, the returned logger is a global logger.
# Example
```julia
julia> logger = setlogger(tempdir(), "mylogger", setglobal=true)
Base.CoreLogging.SimpleLogger(IOStream(<file /tmp/mylogger>), Info, Dict{Any,Int64}())
```
"""
function setlogger(path::AbstractString, name::AbstractString; setglobal::Bool=true, loglevel::LogLevel=Logging.Info)
io = open(joinpath(path, name), "w+")
logger = SimpleLogger(io, loglevel)
if setglobal
global_logger(logger)
end
logger
end
"""
closelogger(logger=global_logger())
Closes the `logger` the file of the `loggger`. See also: [`setlogger`](@ref)
"""
function closelogger(logger=global_logger())
if isa(logger, AbstractLogger)
close(logger.stream)
end
end
##### Simulation reporting
"""
report(simulation::Simulation)
Records the state of the `simulation` by writing all its fields into a data file. All the fields of the `simulation` is written into file. When the file is read back, the `simulation` object is constructed back. The data file is written under the path of the `simulation`.
"""
function report(simulation::Simulation)
# Write simulation info.
jldopen(joinpath(simulation.path, "report.jld2"), "w") do simreport
simreport["name"] = simulation.name
simreport["path"] = simulation.path
simreport["state"] = simulation.state
simreport["retcode"] = simulation.retcode
# Save simulation model components.
model = simulation.model
components = [node.component for node in model.nodes]
# foreach(unfasten!, filter(component->isa(component, AbstractSink), components))
model_group = JLD2.Group(simreport, "model")
model_group["id"] = string(simulation.model.id)
model_group["name"] = string(simulation.model.name)
model_group["clock"] = simulation.model.clock
model_group["callbacks"] = simulation.model.callbacks
model_blocks_group = JLD2.Group(simreport, "components")
for component in filter(component->!isa(component, Writer), components)
model_blocks_group[string(component.name)] = component
end
end
# close(simreport)
end
##### SimulationError type
"""
SimulationError(msg::String)
Thrown when an error occurs during a simulation.
"""
struct SimulationError <: Exception
msg::String
end
Base.showerror(io::IO, err::SimulationError) = println(io, err.msg)
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 3018 | # This file is for TaskManager object.
"""
TaskManager(pairs)
Constructs a `TaskManager` with `pairs`. `pairs` is a dictionary whose keys are components and values are component tasks. Component tasks are constructed correponding to the components. A `TaskManager` is used to keep track of the component task launched corresponding to components.
TaskManager()
Constructs a `TaskManager` with empty `pairs`.
```
"""
mutable struct TaskManager{T, S, IP, OP, CB}
pairs::Dict{T, S}
handshakeport::IP
triggerport::OP
callbacks::CB
name::Symbol
id::UUID
function TaskManager(pairs::Dict{T, S}; callbacks=nothing, name=Symbol()) where {T, S}
triggerport, handshakeport = Outport(0), Inport{Bool}(0)
new{T, S, typeof(handshakeport), typeof(triggerport), typeof(callbacks)}(pairs, handshakeport, triggerport,
callbacks, name, uuid4())
end
end
TaskManager() = TaskManager(Dict{Any, Any}())
show(io::IO, tm::TaskManager) = print(io, "TaskManager(pairs:$(tm.pairs))")
"""
checktaskmanager(tm::TaskManager)
Throws an error if any of the component task of `tm` is failed. See also: [`TaskManager`](@ref)
"""
function checktaskmanager(tm::TaskManager)
for (component, comptask) in tm.pairs
# NOTE: If any of the tasks of the taskmanager failes during its computation, the tasks are fetched
# to cancel the simulation and stacktrace is printed to report the error.
checkcomptask(comptask) || (@error "Failed for $component"; fetch(comptask))
end
end
function checkcomptask(comptask)
if typeof(comptask) <: AbstractArray
return checkcomptask(comptask...)
else
istaskfailed(comptask) ? false : true
end
end
checkcomptask(comptask...) = all(checkcomptask.(comptask))
"""
istaskfailed(task::Nothing)
Returns `false`.
istaskfailed(comptask::ComponentTask)
Returns `true` is `triggertask` or `outputtask` of `comptask` is failed.
"""
# function istaskfailed end
# istaskfailed(task::Nothing) = false
# istaskfailed(comptask::ComponentTask) = istaskfailed(comptask.triggertask) || istaskfailed(comptask.outputtask)
"""
istaskrunning(task::Task)
Returns `true` is the state of `task` is `runnable`.
istaskrunning(task::Nothing)
Returns `true`
istaskrunning(comptask::ComponentTask)
Returns `true` if `triggertask` and `outputtask` of `comptask` is running.
"""
function istaskrunning end
istaskrunning(task::Task) = task.state == :runnable
# istaskrunning(task::Nothing) = true
# istaskrunning(comptask::ComponentTask) = istaskrunning(comptask.triggertask) && istaskrunning(comptask.outputtask)
# """
# istaskrunning(task::Nothing)
# Returns `true`
# istaskdone(comptask::ComponentTask)
# Returns `true` if the state of `triggertask` and `outputtask` of `comptask` is `done`.
# """
# function istaskdone end
# istaskdone(task::Nothing) = true
# istaskdone(comptask::ComponentTask) = istaskdone(comptask.triggertask) && istaskdone(comptask.outputtask)
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 1927 | # This file includes the Plugins module
abstract type AbstractPlugin end
# Define generic plugin functions.
function process end
function enable end
function disable end
function check end
function add end
function remove end
function search(rootpath::AbstractString, filename::AbstractString)
paths = String[]
for (root, dirs, files) in walkdir(rootpath)
for file in files
if occursin(filename, file)
push!(paths, joinpath(root, file))
end
end
end
paths
end
const remote_repo_url = "https://imel.eee.deu.edu.tr/git/JusdlPlugins.jl.git"
function add(name::AbstractString, url::AbstractString=remote_repo_url)
startswith(name, ".") && error("Name of plugin should not start with `.`")
startswith(name, "Plugins") && error("Name of plugin cannot be `Plugins`")
startswith(".jl", name) || (name *= ".jl")
repopath = joinpath("/tmp", "JusdlPlugins", randstring())
ispath(repopath) || mkpath(repopath)
@info "Cloning avaliable plugins from $url"
LibGit2.clone(url, repopath)
@info "Done..."
@info "Searching for $name in plugins repo."
srcpath = search(joinpath(repopath, "src"), name)[1]
if isempty(srcpath)
error("$name could not be found in avaliable plugins")
else
dstdir = joinpath(@__DIR__, "additionals")
dstpath = joinpath(dstdir, name)
cp(srcpath, dstpath, force=true)
include(dstpath)
@info "$name is added to Jusdl.Plugins"
end
end
# # Includes essential plugins from Jusdl
# foreach(include, search(joinpath(@__DIR__, "essentials"), ".jl"))
# Includes additional plugins from Jusdl
foreach(include, search(joinpath(@__DIR__, "additionals"), ".jl"))
# Include plugins from user working directory.
user_plugins_path = joinpath(pwd(), "plugins")
ispath(user_plugins_path) && foreach(include, search(joinpath(user_plugins_path), ".jl"))
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 174 | # This file includes the template plugin
struct TemplatePlugin <: AbstractPlugin
process(plg::TemplatePlugin, x) = println("In the template plugin. Doing nothing")
end
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 1044 | # This file includes the plugin for calculation of fast fourier transform of data
using FFTW
"""
Fft(dims::Int)
Constructs an `Fft` plugin. The [`process(plg::Fft, x)`](@ref) function performes an `fft` operatinon along `dims` of `x`. See also: [`fft`](https://juliamath.github.io/AbstractFFTs.jl/stable/api/#AbstractFFTs.fft)
"""
struct Fft <: AbstractPlugin
dims::Int
end
Fft(;dims::Int=1) = Fft(dims)
show(io::IO, plg::Fft) = print(io, "Fft(dims:$(plg.dims))")
"""
process(plg::Fft, x)
Performes an `fft` transformation for the input data `x`.
# Example
```julia
julia> x = collect(reshape(1:16, 4,4))
4×4 Array{Int64,2}:
1 5 9 13
2 6 10 14
3 7 11 15
4 8 12 16
julia> plg = Plugins.Fft(dims=1)
Fft(dims:1)
julia> process(plg, x)
4×4 Array{Complex{Float64},2}:
10.0+0.0im 26.0+0.0im 42.0+0.0im 58.0+0.0im
-2.0+2.0im -2.0+2.0im -2.0+2.0im -2.0+2.0im
-2.0+0.0im -2.0+0.0im -2.0+0.0im -2.0+0.0im
-2.0-2.0im -2.0-2.0im -2.0-2.0im -2.0-2.0im
```
"""
process(plg::Fft, x) = fft(x, plg.dims)
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 2788 | # This file includes the plugin for calculation of Lyapunov exponents.
using ChaosTools
"""
Lyapunov(;m::Int=15, J::Int=5, ni::Int=300, ts::Float64=0.01)
Constructs a `Lyapunov` plugin. The [`process(plg::Lyapunov, x)`](@ref) function computes the maximum numerical Lyapunov exponents. `m` is the reconstruction dimension, `J` is the amount of delay in reconstruction, `ni` is the number of steps during transient steps and `ts` is the sampling time between samples of the input data `x`. See also: (https://juliadynamics.github.io/DynamicalSystems.jl/latest/chaos/nlts/)
"""
struct Lyapunov <: AbstractPlugin
m::Int
J::Int
ni::Int
ts::Float64
end
Lyapunov(;m::Int=15, J::Int=5, ni::Int=300, ts::Float64=0.01) = Lyapunov(m, J, ni, ts)
show(io::IO, plg::Lyapunov) = print(io,
"Lyapunov(embeddingdim:$(plg.m), numlags:$(plg.J), numiteration:$(plg.ni), samplingtime:$(plg.ts)")
"""
process(plg::Lyapunov, x)
Computes the maximum Lyapunov exponent of the input data `x`.
# Example
```julia
julia> using Random
julia> rng = MersenneTwister(1234);
julia> x = rand(rng, 1000);
julia> plg = Plugins.Lyapunov()
Lyapunov(embeddingdim:15, numlags:5, numiteration:300, samplingtime:0.01
julia> process(plg, x)
-0.42032928176193973
```
"""
function process(plg::Lyapunov, x)
ndims(x) == 1 || (x = x[:])
ntype = FixedMassNeighborhood(5)
ks = 1 : 4 : plg.ni
R = reconstruct(x, plg.m, plg.J)
E = numericallyapunov(R, ks, ntype=ntype)
val = linear_region(plg.ts .* ks, E)[2]
return val
end
# using NearestNeighbors
# using LinearAlgebra
# using Statistics
# using LsqFit
# import Base.log
# process(plg::Lyapunov, x) = lyapunov(x, plg.m, plg.J, plg.ni, plg.ts)[2]
# function reconstruct(x, m, J)
# N = length(x)
# M = N - (m - 1) * J
# X = zeros(m, M)
# for i = 1 : M
# data = x[i : J : i + (m - 1)* J]
# X[:, i] = data
# end
# X
# end
# function knneighbours(X)
# tree = KDTree(X)
# [knn(tree, X[:, j], 2)[1][1] for j = 1 : size(X, 2)]
# end
# distance(Xj, Xjhat) = norm(Xj - Xjhat)
# Base.log(a::Vector) = log.(a)
# function lyapunov(x, m, J, ni, ts)
# X = reconstruct(x, m, J)
# M = size(X, 2)
# js = collect(1:M)
# jbars = knneighbours(X)
# m1 = js .+ ni .<= M
# m2 = jbars .+ ni .<= M
# m = m1 .& m2
# mjs = js[m]
# mjbars = jbars[m]
# y = mean(log.([distance.(eachcol(X[:, j : j + ni]), eachcol(X[:, jbar : jbar + ni]))
# for (j, jbar) in zip(mjs, mjbars)])) / ts
# @. model(x, p) = p[1]*x
# ydata = y[round(Int, length(y) * 0.25) : end] # Discard first transient region and go to the linear region.
# lambda = coef(curve_fit(model, collect(1:length(ydata)), ydata, rand(1)))[1]
# return y, lambda
# end
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 788 | # This file illustrates the plugin for calculation of mean of data
using Statistics
"""
Mean(dims::Int)
Constructs a `Mean` plugin. The [`process(plg::Mean, x)`](@ref) function takes the mean of the input data `x` along dimension `dims`.
"""
struct Mean <: AbstractPlugin
dims::Int
end
Mean(;dims::Int=1) = Mean(dims)
show(io::IO, plg::Mean) = print(io, "Mean(dims:$(plg.dims))")
"""
process(plg::Mean, x)
Returns the means of `x` along the dimension `plg.dims`.
# Example
```julia
julia> x = collect(reshape(1:16, 4,4))
4×4 Array{Int64,2}:
1 5 9 13
2 6 10 14
3 7 11 15
4 8 12 16
julia> plg = Plugins.Mean(dims=1)
Mean(dims:1)
julia> process(plg, x)
1×4 Array{Float64,2}:
2.5 6.5 10.5 14.5
```
"""
process(plg::Mean, x) = mean(x, dims=plg.dims)
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 816 | # This file includes the plugin for standard deviation of data
using Statistics
"""
Std(dims::Int)
Constructs a `Std` plugin. The [`process(plg::Std, x)`](@ref) function takes the standard deviation of the input data `x` along dimension `dims`.
"""
struct Std <: AbstractPlugin
dims::Int
end
Std(;dims::Int=1) = Std(dims)
show(io::IO, plg::Std) = print(io, "Mean(dims:$(plg.dims))")
"""
process(plg::Std, x)
Returns the standard deviation of `x` along the dimension `plg.dims`.
# Example
```julia
julia> x = collect(reshape(1:16, 4,4))
4×4 Array{Int64,2}:
1 5 9 13
2 6 10 14
3 7 11 15
4 8 12 16
julia> plg = Plugins.Std(dims=1)
Mean(dims:1)
julia> process(plg, x)
1×4 Array{Float64,2}:
1.29099 1.29099 1.29099 1.29099
```
"""
process(plg::Std, x) = std(x, dims=plg.dims)
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 857 | # This file includes the plugin for the calculation variance of data
using Statistics
"""
Variance(dims::Int)
Constructs a `Variance` plugin. The [`process(plg::Variance, x)`](@ref) function takes the variance of the input data `x` along dimension `dims`.
"""
struct Variance <: AbstractPlugin
dims::Int
end
Variance(;dims::Int=1) = Variance(dims)
show(io::IO, plg::Variance) = print(io, "Mean(dims:$(plg.dims))")
"""
process(plg::Std, x)
Returns the standard deviation of `x` along the dimension `plg.dims`.
# Example
```julia
julia> x = collect(reshape(1:16, 4,4))
4×4 Array{Int64,2}:
1 5 9 13
2 6 10 14
3 7 11 15
4 8 12 16
julia> plg = Plugins.Variance(dims=1)
Mean(dims:1)
julia> process(plg, x)
1×4 Array{Float64,2}:
1.66667 1.66667 1.66667 1.66667
```
"""
process(plg::Variance, x) = var(x, dims=plg.dims)
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 13007 | # This file constains the Buffer for data buffering.
##### Buffer modes
"""
BufferMode
Abstract type for buffer mode. Subtypes of `BufferMode` is `CyclicMode` and `LinearMode`.
"""
abstract type BufferMode end
"""
CyclicMode <: BufferMode
Abstract type of cyclic buffer modes. See [`Cyclic`](@ref)
"""
abstract type CyclicMode <: BufferMode end
"""
LinearMode <: BufferMode
Abstract type of linear buffer modes. See [`Normal`](@ref), [`Lifo`](@ref), [`Fifo`](@ref)
"""
abstract type LinearMode <: BufferMode end
"""
Cyclic <: CyclicMode
Cyclic buffer mode. The data is written to buffer until the buffer is full. When the buffer is full, new data is written by overwriting the data available in the buffer starting from the beginning of the buffer. When the buffer is read, the element written last is returned and the returned element is not deleted from the buffer.
"""
struct Cyclic <: CyclicMode end
"""
Normal <: LinearMode
LinearMode buffer mode. The data is written to buffer until the buffer is full. When it is full, no more data is written to the buffer. When read, the data written last is returned and the returned data is not deleted from the internal container of the buffer.
"""
struct Normal <: LinearMode end
"""
Lifo <: LinearMode
Lifo (Last-in-first-out) buffer mode. This type of buffer is a *last-in-first-out* buffer. Data is written to the buffer until the buffer is full. When the buffer is full, no more element can be written into the buffer. When read, the last element written into buffer is returned. The returned element is deleted from the buffer.
"""
struct Lifo <: LinearMode end
"""
Fifo <: LinearMode
Fifo (First-in-last-out) buffer mode. This type of buffer is a *first-in-first-out* buffer. The data is written to the buffer until the buffer is full. When the buffer is full, no more element can be written into the buffer. When read, the first element written into the buffer is returned. The returned element is deleted from the buffer.
"""
struct Fifo <: LinearMode end
##### Buffer
"""
Buffer{M}(dtype::Type{T}, sz::Int...) where {M, T}
Constructs a `Buffer` of size `sz` with element type of `T`. `M` is the mode of the `Buffer` that determines how data is to read from and written into the `Buffer`. There exists for different buffer modes:
* `Normal`: See [`Normal`](@ref)
* `Cyclic`: See [`Cyclic`](@ref)
* `Lifo`: See [`Lifo`](@ref)
* `Fifo`: See [`Fifo`](@ref)
The default mode for `Buffer` is `Cyclic` and default element type is `Float64`.
Buffer{M}(sz::Int...) where {M, T}
Constructs a `Buffer` of size `sz` and with element type of `T` and mode `M`.
Buffer(dtype::Type{T}, sz::Int...) where T
Constructs a `Buffer` of size `sz` and element type `T`. The mode of buffer is `Cyclic`.
Buffer(sz::Int...)
Constructs a `Buffer` of size `sz` with mode `Cyclic` and element type of `Float64`.
Buffer{M}(data::AbstractVecOrMat{T}) where {M, T<:Real}
Constructs a `Buffer` with `data`.
# Example
```jldoctest
julia> buf = Buffer(5)
5-element Buffer{Cyclic,Float64,1}
julia> buf = Buffer{Fifo}(2, 5)
2×5 Buffer{Fifo,Float64,2}
julia> buf = Buffer{Lifo}(collect(reshape(1:8, 2, 4)))
2×4 Buffer{Lifo,Int64,2}
```
"""
mutable struct Buffer{M<:BufferMode, T, N} <: AbstractArray{T, N}
internals::Vector{Array{T, N}}
src::Int
dst::Int
index::Int
state::Symbol
id::UUID
Buffer{M}(data::AbstractVecOrMat{T}) where {M, T<:Real} = new{M, T, ndims(data)}([copy(data), data], 1, 2, 1, :empty, uuid4())
end
Buffer{M}(dtype::Type{T}, sz::Int...) where {M, T} = Buffer{M}(zeros(T, sz...))
Buffer{M}(sz::Int...) where {M, T} = Buffer{M}(zeros(Float64, sz...))
Buffer(dtype::Type{T}, sz::Int...) where T = Buffer{Cyclic}(dtype, sz...)
Buffer(sz::Int...) = Buffer(Float64, sz...)
show(io::IO, buf::Buffer)= print(io,
"Buffer(mode:$(mode(buf)), eltype:$(eltype(buf)), size:$(size(buf)), index:$(buf.index), state:$(buf.state))")
# display(buf::Buffer) = println(
# "Buffer(mode:$(mode(buf)), eltype:$(eltype(buf)), size:$(size(buf)), index:$(buf.index), state:$(buf.state))")
function swapinternals(buf::Buffer)
temp = buf.src
buf.src = buf.dst
buf.dst = temp
end
"""
inbuf(buf::Buffer)
Returns the element of `internals` of `buf` that is used to input data to `buf`. See also [`outbuf`][@ref)
"""
inbuf(buf::Buffer) = buf.internals[buf.src]
"""
outbuf(buf::Buffer)
Returns the element of `intervals` of `buf` that is used to take data out of `buf`. See also: [`inbuf`](@ref)
"""
outbuf(buf::Buffer) = buf.internals[buf.dst]
##### Buffer info.
"""
mode(buf::Buffer)
Returns buffer mode of `buf`. See also: [`Normal`](@ref), [`Cyclic`](@ref), [`Lifo`](@ref), [`Fifo`](@ref) for buffer modes.
"""
mode(buf::Buffer{M, T, N}) where {M, T, N} = M
##### AbstractArray interface.
"""
datalength(buf::Buffer)
Returns the maximum number of data that can be hold in `buf`.
# Example
```jldoctest
julia> buf = Buffer(5);
julia> datalength(buf)
5
julia> buf2 = Buffer(2, 10);
julia> datalength(buf2)
10
```
"""
datalength(buf::Buffer{M, T, N}) where {M, T, N} = N == 1 ? size(buf, 1) : size(buf, 2)
"""
size(buf::Buffer)
Returns the size of `buf`.
"""
size(buf::Buffer) = size(outbuf(buf))
"""
getindex(buf::Buffer, idx::Vararg{Int, N})
Returns an element from `buf` at index `idx`. Same as `buf[idx]`
# Example
```jldoctest
julia> buf = Buffer(2, 5); # Construct a buffer.
julia> write!(buf, reshape(2 : 2 : 20, 2, 5)) # Write data into buffer.
julia> buf[1]
18.0
julia> buf[1, 2]
14.0
julia> buf[1, end]
2.0
julia> buf[:, 2]
2-element Array{Float64,1}:
14.0
16.0
```
"""
getindex(buf::Buffer, idx::Vararg{Int, N}) where N = getindex(outbuf(buf), idx...)
"""
setindex!(buf::Buffer, val, idx)
Sets `val` to `buf` at index `idx`. Same as `buf[idx] = val`.
# Example
```jldoctest
julia> buf = Buffer(2, 5);
julia> buf[1] = 1
1
julia> buf[:, 2] = [1, 1]
2-element Array{Int64,1}:
1
1
julia> buf[end] = 10
10
julia> buf.internals
2-element Array{Array{Float64,2},1}:
[1.0 1.0 … 0.0 0.0; 0.0 1.0 … 0.0 10.0]
[0.0 0.0 … 0.0 0.0; 0.0 0.0 … 0.0 0.0]
```
"""
setindex!(buf::Buffer, item, idx::Vararg{Int, N}) where N = setindex!(inbuf(buf), item, idx...)
##### Buffer state control and check.
"""
isempty(buf::Buffer)
Returns `true` if the index of `buf` is 1.
"""
isempty(buf::Buffer) = buf.state == :empty
"""
isfull(buf::Buffer)
Returns `true` if the index of `buf` is equal to the length of `buf`.
"""
isfull(buf::Buffer) = buf.state == :full
"""
ishit(buf::Buffer)
Returns true when `buf` index is an integer multiple of datalength of `buf`.
# Example
```jldoctest
julia> buf = Buffer(3);
julia> for val in 1 : 7
write!(buf, val)
@show ishit(buf)
end
ishit(buf) = false
ishit(buf) = false
ishit(buf) = true
ishit(buf) = false
ishit(buf) = false
ishit(buf) = true
ishit(buf) = false
```
"""
ishit(buf::Buffer) = buf.index % datalength(buf) == 1
#
# `setproperty!` function is used to keep track of buffer status.
# The tracking is done through the updates of `index` of buffer.
#
function setproperty!(buf::Buffer, name::Symbol, val::Int)
if name == :index
val < 1 && error("Buffer index cannot be less than 1.")
setfield!(buf, name, val)
if val == 1
buf.state = :empty
elseif val > datalength(buf)
buf.state = :full
# mode(buf) == Cyclic && setfield!(buf, :index, %(buf.index, datalength(buf)))
else
buf.state = :nonempty
end
else
setfield!(buf, name, val)
end
end
##### Writing into buffers
"""
write!(buf::Buffer{M, <:Real, 1}, val::Real) where {M}
Writes `val` into `buf`.
write!(buf::Buffer{M, <:Real, 2}, val::AbstractVector{<:Real}) where {M}
Writes `val` into `buf`.
write!(buf::Buffer{M, <:Real, 1}, vals::AbstractVector{<:Real}) where {M}
Writes each element of `vals` into `buf`.
write!(buf::Buffer{M, <:Real, 2}, vals::AbstractMatrix{<:Real}) where {M}
Writes each column of `vals` into `buf`.
!!! warning
Buffer mode determines how data is written into buffers. See also: [`Normal`](@ref), [`Cyclic`](@ref), [`Lifo`](@ref), [`Fifo`](@ref) for buffer modes.
# Example
```jldoctest
julia> buf = Buffer(5)
5-element Buffer{Cyclic,Float64,1}
julia> write!(buf, 1.)
1.0
julia> write!(buf, [2, 3])
julia> buf.internals
2-element Array{Array{Float64,1},1}:
[3.0, 2.0, 1.0, 0.0, 0.0]
[2.0, 1.0, 0.0, 0.0, 0.0]
julia> buf = Buffer(2,5)
2×5 Buffer{Cyclic,Float64,2}
julia> write!(buf, [1, 1])
2-element Array{Int64,1}:
1
1
julia> write!(buf, [2 3; 2 3])
julia> buf.internals
2-element Array{Array{Float64,2},1}:
[3.0 2.0 … 0.0 0.0; 3.0 2.0 … 0.0 0.0]
[2.0 1.0 … 0.0 0.0; 2.0 1.0 … 0.0 0.0]
```
"""
function write!(buf::Buffer, val) end
write!(buf::Buffer{M, <:Real, 1}, val::Real) where {M} = _write!(buf, val)
write!(buf::Buffer{M, <:Real, 2}, val::AbstractVector{<:Real}) where {M} = _write!(buf, val)
write!(buf::Buffer{M, <:Real, 1}, vals::AbstractVector{<:Real}) where {M} = foreach(val -> _write!(buf, val), vals)
write!(buf::Buffer{M, <:Real, 2}, vals::AbstractMatrix{<:Real}) where {M} = foreach(val -> _write!(buf, val), eachcol(vals))
function _write!(buf::Buffer, val)
checkstate(buf)
ibuf = inbuf(buf)
obuf = outbuf(buf)
rotate(ibuf, obuf, 1)
writeitem(ibuf, val)
buf.index += 1
swapinternals(buf)
val
end
# writeitem(buf::Buffer{M, T, 1}, val) where {M, T} = (buf[buf.index] = val; buf.index += 1)
writeitem(buf::AbstractArray{T, 1}, val) where {T} = buf[1] = val
writeitem(buf::AbstractArray{T, 2}, val) where {T} = buf[:, 1] = val
checkstate(buf::Buffer) = mode(buf) != Cyclic && isfull(buf) && error("Buffer is full")
##### Reading from buffers
"""
read(buf::Buffer)
Reads an element from `buf`. Reading is performed according to the mode of `buf`. See also: [`Normal`](@ref), [`Cyclic`](@ref), [`Lifo`](@ref), [`Fifo`](@ref) for buffer modes.
# Example
```jldoctest
julia> buf = Buffer(3)
3-element Buffer{Cyclic,Float64,1}
julia> write!(buf, [2, 4, 6])
julia> for i = 1 : 3
@show (read(buf), buf.internals)
end
(read(buf), buf.internals) = (6.0, [[6.0, 4.0, 2.0], [4.0, 2.0, 0.0]])
(read(buf), buf.internals) = (6.0, [[6.0, 4.0, 2.0], [4.0, 2.0, 0.0]])
(read(buf), buf.internals) = (6.0, [[6.0, 4.0, 2.0], [4.0, 2.0, 0.0]])
julia> buf = Buffer{Fifo}(5)
5-element Buffer{Fifo,Float64,1}
julia> write!(buf, [2, 4, 6])
julia> for i = 1 : 3
@show (read(buf), buf.internals)
end
(read(buf), buf.internals) = (2.0, [[6.0, 4.0, 0.0, 0.0, 0.0], [4.0, 2.0, 0.0, 0.0, 0.0]])
(read(buf), buf.internals) = (4.0, [[6.0, 0.0, 0.0, 0.0, 0.0], [4.0, 2.0, 0.0, 0.0, 0.0]])
(read(buf), buf.internals) = (6.0, [[0.0, 0.0, 0.0, 0.0, 0.0], [4.0, 2.0, 0.0, 0.0, 0.0]])
```
"""
function read(buf::Buffer)
isempty(buf) && error("Buffer is empty.")
val = _read(buf)
val
end
function _read(buf::Buffer{Fifo, T, N}) where {T, N}
obuf = outbuf(buf)
val = readitem(obuf, buf.index - 1)
buf.index -= 1
insertzero(obuf, buf.index)
val
end
function _read(buf::Buffer{Lifo, T, N}) where {T, N}
obuf = outbuf(buf)
ibuf = inbuf(buf)
val = readitem(obuf, 1)
rotate(ibuf, obuf, -1)
buf.index -= 1
swapinternals(buf)
val
end
function _read(buf::Buffer{M, T, N}) where {M<:Union{Normal, Cyclic}, T, N}
readitem(outbuf(buf), 1)
end
readitem(buf::AbstractArray{T, 1}, idx::Int) where {T} = buf[idx]
readitem(buf::AbstractArray{T, 2}, idx::Int) where {T} = buf[:, idx]
insertzero(buf::AbstractArray{T, 1}, idx::Int) where {T} = buf[idx] = zero(T)
insertzero(buf::AbstractArray{T, 2}, idx::Int) where {T} = buf[:, idx] = zeros(T, size(buf, 1))
rotate(ibuf::AbstractArray{T, 1}, obuf::AbstractArray{T, 1}, idx::Int) where {T} = circshift!(ibuf, obuf, idx)
rotate(ibuf::AbstractArray{T, 2}, obuf::AbstractArray{T, 2}, idx::Int) where {T} = circshift!(ibuf, obuf, (0, idx))
##### Accessing buffer internals
"""
content(buf, [flip=true])
Returns the current data of `buf`. If `flip` is `true`, the data to be returned is flipped. See also [`snapshot`](@ref)
# Example
```jldoctest
julia> buf = Buffer(5);
julia> write!(buf, 1:3)
julia> content(buf, flip=false)
3-element Array{Float64,1}:
3.0
2.0
1.0
julia> buf = Buffer(2, 5);
julia> write!(buf, reshape(1:10, 2, 5))
julia> content(buf)
2×5 Array{Float64,2}:
1.0 3.0 5.0 7.0 9.0
2.0 4.0 6.0 8.0 10.0
```
"""
function content(buf::Buffer; flip::Bool=true)
bufdim = ndims(buf)
if isfull(buf)
val = outbuf(buf)
else
val = bufdim == 1 ? buf[1 : buf.index - 1] : buf[:, 1 : buf.index - 1]
end
if flip
return bufdim == 1 ? reverse(val, dims=1) : reverse(val, dims=2)
else
return val
end
end
"""
snapshot(buf::Buffer)
Returns all elements in `buf`. See also: [`content`](@ref)
"""
snapshot(buf::Buffer) = outbuf(buf)
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 2362 | # This file constains the callbacks for event monitoring.
"""
Callback(condition, action)
Constructs a `Callback` from `condition` and `action`. The `condition` and `action` must be a single-argument function. The `condition` returns `true` if the condition it checks occurs, otherwise, it returns `false`. `action` performs the specific action for which the `Callback` is constructed. A `Callback` can be called by passing its single argument which is mostly bound to the `Callback`.
# Example
```julia
julia> struct Object # Define a dummy type.
x::Int
clb::Callback
end
julia> cond(obj) = obj.x > 0; # Define callback condition.
julia> action(obj) = println("obj.x = ", obj.x); # Define callback action.
julia> obj = Object(1, Callback(condition=cond, action=action))
Object(1, Callback(condition:cond, action:action))
julia> obj.clb(obj) # Call the callback bound `obj`.
obj.x = 1
```
"""
Base.@kwdef mutable struct Callback{CN, AC}
condition::CN = obj -> false
action::AC = obj -> nothing
enabled::Bool = true
id::UUID = uuid4()
end
show(io::IO, clb::Callback) = print(io, "Callback(condition:$(clb.condition), action:$(clb.action))")
##### Callback controls
"""
enable!(clb::Callback)
Enables `clb`.
"""
enable!(clb::Callback) = clb.enabled = true
"""
disable!(clb::Callback)
Disables `clb`.
"""
disable!(clb::Callback) = clb.enabled = false
"""
isenabled(clb::Callback)
Returns `true` if `clb` is enabled. Otherwise, returns `false`.
"""
isenabled(clb::Callback) = clb.enabled
##### Callback calls
# Apply callback asynchronously.
# (clb::Callback)(obj) = clb.enabled && clb.condition(obj) ? clb.action(obj) : nothing
(clb::Callback)(obj) = clb.enabled && clb.condition(obj) ? (@async(clb.action(obj)); nothing) : nothing
(clbs::AbstractVector{CB})(obj) where CB<:Callback = foreach(clb -> clb(obj), clbs)
"""
applycallbacks(obj)
Calls the callbacks of `obj` if the callbacks are not nothing.
# Example
```julia
julia> mutable struct MyType{CB}
x::Int
callbacks::CB
end
julia> obj = MyType(5, Callback(condition=obj -> obj.x > 0, action=obj -> println("x is positive")));
julia> applycallbacks(obj)
x is positive
julia> obj.x = -1
-1
julia> applycallbacks(obj)
```
"""
applycallbacks(obj) = typeof(obj.callbacks) <: Nothing || obj.callbacks(obj)
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 1575 | # This file includes utiliti functions for Systems module
macro siminfo(msg...)
quote
@info "$(now()) $($msg...)"
end
end
#=
@def begin name
code
end
Copy paste macro
=#
macro def(name, code)
quote
macro $(esc(name))()
esc($(Meta.quot(code)))
end
end
end
hasargs(func, n) = n + 1 in [method.nargs for method in methods(func)]
function unwrap(container, etype; depth=10)
for i in 1 : depth
container = vcat(container...)
eltype(container) == etype && break
end
container
end
launchport(iport) = @async while true
all(take!(iport) .=== NaN) && break
end
# Equips `comp` to make it launchable. Equipment is done by constructing and connecting signalling pins (i.e. `trigger`
# and `handshake`), input and output ports (if necessary)
function equip(comp, kickoff::Bool=true)
oport = typeof(comp) <: AbstractSource ?
nothing : (typeof(comp.input) === nothing ? nothing : Outport(length(comp.input)))
iport = typeof(comp) <: AbstractSink ?
nothing : (typeof(comp.output) === nothing ? nothing : Inport(length(comp.output)))
trg = Outpin()
hnd = Inpin{Bool}()
oport === nothing || connect!(oport, comp.input)
iport === nothing || connect!(comp.output, iport)
connect!(trg, comp.trigger)
connect!(comp.handshake, hnd)
if kickoff
comptask, outputtask = launch(comp), launchport(iport)
else
comptask, outputtask = nothing, nothing
end
oport, iport, trg, hnd, comptask, outputtask
end | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 866 | # This file is used for code coverage of Jusdl test suites.
# NOTE: Before executing this script, run test suite of Jusdl as
# ] test --coverage Jusdl
#
using Coverage
# process '*.cov' files
coverage = process_folder() # defaults to src/; alternatively, supply the folder name as argument
coverage = append!(coverage, process_folder("deps"))
# process '*.info' files
coverage = merge_coverage_counts(coverage, filter!(
let prefixes = (joinpath(pwd(), "src", ""),
joinpath(pwd(), "deps", ""))
c -> any(p -> startswith(c.filename, p), prefixes)
end,
LCOV.readfolder("test")))
# Get total coverage for all Julia files
covered_lines, total_lines = get_summary(coverage)
percentage = covered_lines / total_lines * 100
@info "Code coverage percentage : $percentage%"
# Clean folders
foreach(clean_folder, ["src", "test"])
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 933 | # This file includes the main test set of Jusdl.
# To include new tests, write your tests in files and save them in directories under `test` directory.
using Test
using Jusdl
using Logging
using Random
using JLD2, FileIO
using UUIDs
using Statistics
using LightGraphs
import Jusdl.process
# --------------------------- Deprecated --------------------------
function prepare(comp, kickoff::Bool=true)
@warn "`prepare` function has been deprecated in favor of `equip`"
equip(comp, kickoff)
end
# ---------------------------------- Include all test files ---------------------
# Construct the file tree in `test` directory.
filetree = walkdir(@__DIR__)
take!(filetree) # Pop the root directory `test` in which `runtests.jl` is.
# Include all test files under `test`
@time @testset "JusdlTestSet" begin
for (root, dirs, files) in filetree
foreach(file -> include(joinpath(root, file)), files)
end
end
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 973 | # This file constains testset for Printer
@testset "PrinterTestSet" begin
@info "Running PrinterTestSet ..."
# Printer construction
printer = Printer(input=Inport(2), buflen=100)
@test typeof(printer.trigger) == Inpin{Float64}
@test typeof(printer.handshake) == Outpin{Bool}
@test size(printer.timebuf) == (100,)
@test size(printer.databuf) == (2, 100)
@test isa(printer.input, Inport)
@test printer.plugin === nothing
@test typeof(printer.callbacks) <: Nothing
@test typeof(printer.sinkcallback) <: Callback
# Driving Printer
oport, iport, trg, hnd, tsk, tsk2 = prepare(printer)
for t in 1 : 200
put!(trg, t)
put!(oport, ones(2) * t)
take!(hnd)
@test read(printer.timebuf) == t
@test [read(pin.links[1].buffer) for pin in oport] == ones(2) * t
end
put!(trg, NaN)
sleep(0.1)
@test istaskdone(tsk)
@info "Done PrinterTestSet ..."
end # testset | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 963 | # This file constains testset for Scope
@testset "ScopeTestSet" begin
@info "Running ScopeTestSet ..."
# Scope construction
scope = Scope(input=Inport(1), buflen=100)
@test typeof(scope.trigger) == Inpin{Float64}
@test typeof(scope.handshake) == Outpin{Bool}
@test size(scope.timebuf) == (100,)
@test size(scope.databuf) == (100,)
@test isa(scope.input, Inport)
@test scope.plugin === nothing
@test typeof(scope.callbacks) <: Nothing
@test typeof(scope.sinkcallback) <: Callback
# Driving Scope
open(scope)
oport, iport, trg, hnd, tsk, tsk2 = prepare(scope)
for t in 1 : 200
put!(trg, t)
put!(oport, ones(1) * t)
take!(hnd)
@test read(scope.timebuf) == t
@test [read(pin.links[1].buffer) for pin in oport] == ones(1) * t
@show t
end
put!(trg, NaN)
sleep(0.1)
@test istaskdone(tsk)
@info "Done ScopeTestSet ..."
end # testset | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 2335 | # This file constains testset for Writer
@testset "WriterTestSet" begin
@info "Running WriterTestSet ..."
# Preliminaries
randdirname() = string(uuid4())
randfilename() = join([string(uuid4()), ".jld2"], "")
testdir = tempdir()
# Writer construction
writer = Writer(input=Inport(3), buflen=10)
writer = Writer(input=Inport(3), buflen=10, path=joinpath(testdir, randfilename()))
path = joinpath(testdir, randfilename())
writer = Writer(input=Inport(3), path=path)
@test typeof(writer.trigger) == Inpin{Float64}
@test typeof(writer.handshake) == Outpin{Bool}
@test isa(writer.input, Inport)
@test length(writer.input) == 3
@test size(writer.timebuf) == (64,)
@test size(writer.databuf) == (3, 64)
@test writer.plugin === nothing
@test writer.callbacks === nothing
@test typeof(writer.sinkcallback) <: Callback
# Reading and writing into Writer
writer = Writer(input=Inport())
open(writer)
for t in 1 : 10
write!(writer, t, sin(t))
end
close(writer)
data = read(writer, flatten=false)
for (t, u) in data
@test sin(t) == u
end
data = fread(writer.file.path, flatten=false)
for (t, u) in data
@test sin(t) == u
end
# Moving/Copying Writer file.
filename = randfilename()
dirnames = map(1:3) do i
path = joinpath(testdir, randdirname())
ispath(path) || mkdir(path)
path
end
paths = map(dname -> joinpath(dname, filename), dirnames)
w = Writer(input=Inport(), path=paths[1])
mv(w, dirnames[2], force=true)
@test w.file.path == paths[2]
cp(w, dirnames[3], force=true)
@test isfile(paths[3])
# Driving Writer
writer = Writer(input=Inport(3), buflen=10)
open(writer)
oport, iport, trg, hnd, comptask, outtask = prepare(writer)
for t in 1 : 100
put!(trg, t)
put!(oport, ones(3)*t)
take!(hnd)
@test read(writer.timebuf) == t
@test [read(pin.links[1].buffer) for pin in oport] == ones(3) * t
end
close(writer)
t, x = read(writer, flatten=true)
@test t == collect(1 : 100)
@test x == [collect(1:100) collect(1:100) collect(1:100)]
put!(trg, NaN)
sleep(0.1)
@test istaskdone(comptask)
@info "Done WriterTestSet."
end # testset | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 427 | # This file includes testset to define new sink types
@testset "NewSinkDefinitionTestset" begin
# New sink types must be of subtypes of `AbstractSink`.
@test_throws Exception @eval @def_sink struct Mysink{T,S}
field1::T
field2::S
end
@test_throws Exception @eval @def_source struct Mysink{T,S} <: SomeDummyType
readout::RO = t -> sin(t)
output::OP = Outport()
end
end | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 3063 | # This file includes testset for sources.
@testset "ClockTestSet" begin
@info "Running ClockTestSet ..."
# Clock construction
clk1 = Clock(0., 1., 10.)
clk2 = Clock(0., 1, 10)
clk3 = Clock(0, 1, 10)
@test eltype(clk1.t) == Float64
@test eltype(clk2.t) == Float64
@test eltype(clk3.t) == Int
# Check Clock defaults.
clk = clk1
@test clk.t == 0.
@test clk.dt == 1.
@test clk.tf == 10.
@test typeof(clk.generator) == Channel{Float64}
@test clk.generator.sz_max == 0
@test !ispaused(clk)
@test !isrunning(clk)
# Set Clock
set!(clk)
@test isrunning(clk)
# Taking values from clk
clk = Clock(0., 1., 10.)
set!(clk)
@test [take!(clk) for i in 0 : 10] == collect(Float64, 0:10)
@test isoutoftime(clk)
# Pausing Clock
clk = set!(Clock(0., 1, 10))
@test take!(clk) == 0
@test take!(clk) == 1.
pause!(clk)
for i = 1 : 10
@test take!(clk) == 1.
end
@info "Done ClockTestSet."
end # testset
@testset "GeneratorsTestSet" begin
@info "Running GeneratorsTestSet ..."
# FunctionGenerator construction
gen = SinewaveGenerator()
@test typeof(gen.trigger) == Inpin{Float64}
@test typeof(gen.handshake) == Outpin{Bool}
@test !hasfield(typeof(gen), :input)
@test typeof(gen.output) == Outport{Outpin{Float64}}
@def_source struct Mygen{OP, RO} <: AbstractSource
output::OP = Outport(2)
readout::RO = t -> [sin(t), cos(t)]
end
gen = Mygen()
@test length(gen.output) == 2
# Driving FunctionGenerator
gen = Mygen(readout = t -> t, output=Outport(1))
trg = Outpin()
hnd = Inpin{Bool}()
ip = Inport()
connect!(gen.output, ip)
connect!(trg, gen.trigger)
connect!(gen.handshake, hnd)
task = launch(gen)
task2 = @async while true
all(take!(ip) .=== NaN) && break
end
for t in 1. : 10.
put!(trg, t)
take!(hnd)
end
@test content(ip[1].link.buffer) == collect(1:10)
@test !istaskdone(task)
put!(trg, NaN)
@test istaskdone(task)
put!(gen.output, [NaN])
@test istaskdone(task2)
# Construction of other generators
sinegen = SinewaveGenerator()
dampedsinegen = DampedSinewaveGenerator()
sqauregen = SquarewaveGenerator()
trigen = TriangularwaveGenerator()
congen = ConstantGenerator()
rampgen = RampGenerator()
stepgen = StepGenerator()
expgen = ExponentialGenerator()
dampedexpgen = DampedExponentialGenerator()
# Mutaton of generators
@test_throws Exception sinegen.amplitude = 5.
@test_throws Exception sqauregen.high = 10.
# Test redefining new source types.
@test_throws Exception @eval @def_source struct Mygen{RO,OP}
readout::RO = t -> sin(t)
output::OP = Outport()
end
@test_throws Exception @eval @def_source struct Mygen{RO,OP} <: SomeDummyType
readout::RO = t -> sin(t)
output::OP = Outport()
end
@info "Done GeneratorsTestSet ..."
end # testset | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 4355 | # This file includes testset for DAESystem
@testset "DAESystemTestSet" begin
@info "Running DAESystemTestSet ..."
# DAESystem construction
function sfunc(out, dx, x, u, t)
out[1] = -0.04 * x[1] + 1e4 * x[2] * x[3] - dx[1]
out[2] = 0.04 * x[1] - 3e7 * x[2]^2 - 1e4 * x[2] * x[3] - dx[2]
out[3] = x[1] + x[2] + x[3] - 1.0
end
ofunc(x, u, t) = x
state = [1., 0., 0.]
stateder = [-0.04, 0.04, 0.]
differential_vars = [true, true, false]
ds = DAESystem(righthandside=sfunc, readout=ofunc, state=state, input=nothing, output=Outport(3),
stateder=stateder, diffvars=differential_vars)
@test typeof(ds.trigger) == Inpin{Float64}
@test typeof(ds.handshake) == Outpin{Bool}
@test ds.input === nothing
@test typeof(ds.output) == Outport{Outpin{Float64}}
@test length(ds.output) == 3
@test ds.state == state
@test ds.t == 0.
@test ds.integrator.sol.prob.p === nothing
# Driving DAESystem
iport = Inport(3)
trg = Outpin()
hnd = Inpin{Bool}()
connect!(ds.output, iport)
connect!(trg, ds.trigger)
connect!(ds.handshake, hnd)
tsk = launch(ds)
tsk2 = @async while true
all(take!(iport) .=== NaN) && break
end
for t in 1 : 10
put!(trg, t)
take!(hnd)
@test ds.t == t
@test [read(pin.link.buffer) for pin in iport] == ds.state
end
put!(trg, NaN)
sleep(0.1)
@test istaskdone(tsk)
put!(ds.output, NaN * ones(length(ds.output)))
sleep(0.1)
@test istaskdone(tsk2)
# DAESystem with inputs
function sfunc2(out, dx, x, u, t)
out[1] = -0.04 * x[1] + 1e4 * x[2] * x[3] - dx[1] + u[1](t)
out[2] = 0.04 * x[1] - 3e7 * x[2]^2 - 1e4 * x[2] * x[3] - dx[2] + u[2](t)
out[3] = x[1] + x[2] + x[3] - 1.0
end
ofunc2(x, u, t) = x
state = [1., 0., 0.]
stateder = [-0.04, 0.04, 0.]
differential_vars = [true, true, false]
ds = DAESystem(righthandside=sfunc2, readout=ofunc2, state=state, input=Inport(2), output=Outport(3),
stateder=stateder, diffvars=differential_vars)
@test typeof(ds.trigger) == Inpin{Float64}
@test typeof(ds.handshake) == Outpin{Bool}
@test typeof(ds.input) <: Inport
@test typeof(ds.output) == Outport{Outpin{Float64}}
@test length(ds.input) == 2
@test length(ds.output) == 3
@test ds.state == state
@test ds.t == 0.
@test typeof(ds.integrator.sol.prob.p) <: Interpolant
@test size(ds.integrator.sol.prob.p.timebuf) == (3,)
@test size(ds.integrator.sol.prob.p.databuf) == (2,3)
# Driving DAESystem with input
oport = Outport(2)
iport = Inport(3)
trg = Outpin()
hnd = Inpin{Bool}()
connect!(oport, ds.input)
connect!(ds.output, iport)
connect!(trg, ds.trigger)
connect!(ds.handshake, hnd)
tsk = launch(ds)
tsk2 = @async while true
all(take!(iport) .=== NaN) && break
end
for t in 1 : 10
put!(trg, t)
put!(oport, ones(2) * t)
take!(hnd)
@test ds.t == t
@test [read(pin.link.buffer) for pin in iport] == ds.state
end
put!(trg, NaN)
sleep(0.1)
@test istaskdone(tsk)
put!(ds.output, NaN * ones(length(ds.output)))
sleep(0.1)
@test istaskdone(tsk2)
# Test defining new DAESystems
# Type mest be mutable
@test_throws Exception @eval @def_dae_system struct DAESystem{RH, RO, ST, IP, OP}
righthandside::RH
readout::RO
state::ST
stateder::ST
diffvars::Vector{Bool}
input::IP
output::OP
end
# The type must be a subtype of AbstractDAESystem
@test_throws Exception @eval @def_dae_system mutable struct DAESystem{RH, RO, ST, IP, OP}
righthandside::RH
readout::RO
state::ST
stateder::ST
diffvars::Vector{Bool}
input::IP
output::OP
end
# The type must be a subtype of AbstractDAESystem
@test_throws Exception @eval @def_dae_system mutable struct DAESystem{RH, RO, ST, IP, OP} <: MyDummyAbstractDAESystem
righthandside::RH
readout::RO
state::ST
stateder::ST
diffvars::Vector{Bool}
input::IP
output::OP
end
@info "Done DAESystemTestSet."
end # testset
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 4339 | # This file includes testset for DDESystem
import DifferentialEquations: MethodOfSteps, Vern9
@testset "DDESystemTestSet" begin
@info "Running DDESystemTestSet ..."
# DDESystem construction
out = zeros(1)
tau = 1
constlags = [tau]
histfunc(out, u, t) = (out .= 1.)
function statefunc(dx, x, h, u, t)
h(out, u, t - tau) # Update `out`.
dx[1] = out[1] + x[1]
end
outputfunc(x, u, t) = x
ds = DDESystem(righthandside=statefunc, history=histfunc, readout=outputfunc, state=[1.], input=nothing, output=Outport(1), alg=MethodOfSteps(Vern9()), constlags=constlags, depslags=nothing)
# ds = DDESystem((statefunc, histfunc), outputfunc, [1.], 0., nothing, Outport(1), alg=MethodOfSteps(Tsit5()), modelkwargs=(constant_lags=constlags,))
@test typeof(ds.trigger) == Inpin{Float64}
@test typeof(ds.handshake) == Outpin{Bool}
@test ds.input === nothing
@test isa(ds.output, Outport)
@test length(ds.output) == 1
@test ds.integrator.sol.prob.constant_lags == constlags
@test ds.integrator.sol.prob.dependent_lags === nothing
@test ds.integrator.sol.prob.neutral == false
@test ds.integrator.alg == Vern9()
# Driving DDESystem
iport = Inport(1)
trg = Outpin()
hnd = Inpin{Bool}()
connect!(ds.output, iport)
connect!(trg, ds.trigger)
connect!(ds.handshake, hnd)
tsk = launch(ds)
tsk2 = @async while true
all(take!(iport) .=== NaN) && break
end
for t in 1 : 10
put!(trg, t)
take!(hnd)
@test ds.t == t
@test [read(pin.link.buffer) for pin in iport] == ds.state
end
put!(trg, NaN)
sleep(0.1)
@test istaskdone(tsk)
put!(ds.output, NaN * ones(length(ds.output)))
sleep(0.1)
@test istaskdone(tsk2)
# DDESystem with input
# hist2 = History(histfunc, constlags, ())
function statefunc2(dx, x, h, u, t)
h(out, u, t - tau) # Update `out`.
dx[1] = out[1] + x[1] + sin(u[1](t)) + cos(u[2](t))
end
outputfunc2(x, u, t) = x
ds = DDESystem(righthandside=statefunc2, history=histfunc, readout=outputfunc2, state=[1.], input=Inport(2),
output=Outport(1), constlags=constlags, depslags=nothing)
@test isa(ds.input, Inport)
@test isa(ds.output, Outport)
@test length(ds.input) == 2
@test length(ds.output) == 1
@test typeof(ds.integrator.sol.prob.p) <: Interpolant
@test size(ds.integrator.sol.prob.p.timebuf) == (3,)
@test size(ds.integrator.sol.prob.p.databuf) == (2, 3)
oport = Outport(2)
iport = Inport(1)
trg = Outpin()
hnd = Inpin{Bool}()
connect!(oport, ds.input)
connect!(ds.output, iport)
connect!(trg, ds.trigger)
connect!(ds.handshake, hnd)
tsk = launch(ds)
tsk2 = @async while true
all(take!(iport) .=== NaN) && break
end
for t in 1 : 10
put!(trg, t)
put!(oport, [t, 2t])
take!(hnd)
@test ds.t == t
@test [read(pin.link.buffer) for pin in iport] == ds.state
end
put!(trg, NaN)
sleep(0.1)
@test istaskdone(tsk)
put!(ds.output, NaN * ones(length(ds.output)))
sleep(0.1)
@test istaskdone(tsk2)
# Test defining new DDESystem
# The type must be mutable
@test_throws Exception @eval @def_dde_system struct DDESystem{CL, DL, RH, HST, RO, ST, IP, OP}
constlags::CL
depslags::DL
righthandside::RH
history::HST
readout::RO
state::ST
input::IP
output::OP
end
# The type must be a subtype of AbstractDAESystem
@test_throws Exception @eval @def_dde_system mutable struct DDESystem{CL, DL, RH, HST, RO, ST, IP, OP}
constlags::CL
depslags::DL
righthandside::RH
history::HST
readout::RO
state::ST
input::IP
output::OP
end
# The type must be a subtype of AbstractDAESystem
@test_throws Exception @eval @def_dde_system mutable struct DDESystem{CL, DL, RH, HST, RO, ST, IP, OP} <: MyDummyAbstractDDESystem
constlags::CL
depslags::DL
righthandside::RH
history::HST
readout::RO
state::ST
input::IP
output::OP
end
@info "Done DDESystemTestSet ..."
end # testset
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 2956 | # This file includes testset for DiscreteSystem
@testset "DiscreteSystemTestSet" begin
@info "Running DiscreteSystemTestSet ..."
# ODESystem construction
sfunc1(dx, x, u, t) = (dx .= -x)
ofunc1(x, u, t) = x
ds = DiscreteSystem(righthandside=sfunc1, readout=ofunc1, state=[1.], input=nothing, output=Outport())
@test typeof(ds.trigger) == Inpin{Float64}
@test typeof(ds.handshake) == Outpin{Bool}
@test ds.input === nothing
@test typeof(ds.output) == Outport{Outpin{Float64}}
@test length(ds.output) == 1
@test ds.state == [1.]
@test ds.t == 0.
@test ds.integrator.sol.prob.p === nothing
function sfunc2(dx, x, u, t)
dx[1] = x[1] + u[1](t)
dx[2] = x[2] - u[2](t)
dx[3] = x[3] + sin(u[1](t))
end
ofunc2(x, u, t) = x
ds = DiscreteSystem(righthandside=sfunc2, readout=ofunc2, state=ones(3), input=Inport(2), output=Outport(3))
@test isa(ds.input, Inport)
@test isa(ds.output, Outport)
@test length(ds.input) == 2
@test length(ds.output) == 3
ds = DiscreteSystem(righthandside=sfunc2, readout=nothing, state=ones(3), input = Inport(2), output = nothing)
@test isa(ds.input, Inport)
@test length(ds.input) == 2
@test ds.readout === nothing
@test ds.output === nothing
# Driving ODESystem
sfunc3(dx, x, u, t) = (dx .= -x)
ofunc3(x, u, t) = x
ds = DiscreteSystem(righthandside=sfunc3, readout=ofunc3, state=[1.], input=nothing, output=Outport())
iport = Inport()
trg = Outpin()
hnd = Inpin{Bool}()
connect!(ds.output, iport)
connect!(trg, ds.trigger)
connect!(ds.handshake, hnd)
tsk = launch(ds)
tsk2 = @async while true
all(take!(iport) .=== NaN) && break
end
for t in 1. : 10.
put!(trg, t)
take!(hnd)
@test ds.t == t
@test [read(pin.link.buffer) for pin in iport] == ds.state
end
put!(trg, NaN)
sleep(0.1)
@test istaskdone(tsk)
put!(ds.output, NaN * ones(length(ds.output)))
sleep(0.1)
@test istaskdone(tsk2)
# Test definining new DiscreteSystem
# Type must be mutable
# The type must be mutable
@test_throws Exception @eval @def_discrete_system struct MyDiscreteSystem{RH, RO, ST, IP, OP}
righthandside::RH
readout::RO
state::ST
input::IP
output::OP
end
# Type must be a subtype of AbstractDiscreteSystem
@test_throws Exception @eval @def_discrete_system mutable struct MyDiscreteSystem{RH, RO, ST, IP, OP}
righthandside::RH
readout::RO
state::ST
input::IP
output::OP
end
@test_throws Exception @eval @def_discrete_system mutable struct MyDiscreteSystem{RH, RO, ST, IP, OP} <: MyDummyAbstractDiscreteSystem
righthandside::RH
readout::RO
state::ST
input::IP
output::OP
end
@info "Done DiscreteSystemTestSet ..."
end | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 9836 | # This file includes testset for ODESystem
@testset "ODESystemTestSet" begin
@info "Running ODESystemTestSet ..."
# ODESystem construction
sfunc1(dx, x, u, t) = (dx .= -x)
ofunc1(x, u, t) = x
ds = ODESystem(righthandside = sfunc1, readout=ofunc1, state=[1.], solverkwargs=(dt=0.1,), input=nothing, output=Outport())
ds = ODESystem(righthandside = sfunc1, readout=ofunc1, state=[1.], solverkwargs=(dt=0.1, dense=true), input=nothing, output=Outport())
ds = ODESystem(righthandside = sfunc1, readout=ofunc1, state=[1.], input=nothing, output=Outport())
@test typeof(ds.trigger) == Inpin{Float64}
@test typeof(ds.handshake) == Outpin{Bool}
@test ds.input === nothing
@test typeof(ds.output) == Outport{Outpin{Float64}}
@test length(ds.output) == 1
@test ds.state == [1.]
@test ds.t == 0.
@test ds.integrator.sol.prob.p === nothing
function sfunc2(dx, x, u, t)
dx[1] = x[1] + u[1](t)
dx[2] = x[2] - u[2](t)
dx[3] = x[3] + sin(u[1](t))
end
ofunc2(x, u, t) = x
ds = ODESystem(righthandside=sfunc2, readout=ofunc2, state=ones(3), input=Inport(2), output=Outport(3))
@test isa(ds.input, Inport)
@test isa(ds.output, Outport)
@test length(ds.input) == 2
@test length(ds.output) == 3
ds = ODESystem(righthandside=sfunc2, readout=nothing, state=ones(3), input=Inport(2), output=nothing)
@test isa(ds.input, Inport)
@test length(ds.input) == 2
@test ds.readout === nothing
@test ds.output === nothing
# Driving ODESystem
sfunc3(dx, x, u, t) = (dx .= -x)
ofunc3(x, u, t) = x
ds = ODESystem(righthandside=sfunc3, readout=ofunc3, state=[1.], input=nothing, output=Outport())
iport = Inport()
trg = Outpin()
hnd = Inpin{Bool}()
connect!(ds.output, iport)
connect!(trg, ds.trigger)
connect!(ds.handshake, hnd)
tsk = launch(ds)
tsk2 = @async while true
all(take!(iport) .=== NaN) && break
end
for t in 1. : 10.
put!(trg, t)
take!(hnd)
@test ds.t == t
@test [read(pin.link.buffer) for pin in iport] == ds.state
end
put!(trg, NaN)
sleep(0.1)
@test istaskdone(tsk)
put!(ds.output, NaN * ones(length(ds.output)))
sleep(0.1)
@test istaskdone(tsk2)
# LinaerSystem tests
ds = ContinuousLinearSystem(input=nothing, output=Outport(1))
@test ds.A == fill(-1, 1, 1)
@test ds.B == fill(1., 1, 1)
@test ds.C == fill(1, 1, 1)
@test ds.D == fill(0, 1, 1)
@test_throws Exception ds.γ == 1.
ds = ContinuousLinearSystem(input=nothing, output=Outport(2), A=ones(2,2), C=ones(2,2))
@test ds.input === nothing
@test isa(ds.output, Outport)
@test length(ds.output) == 2
ds = ContinuousLinearSystem(input=Inport(2), output=Outport(3), A=ones(4,4), B=ones(4,2), C=ones(3,4), D=ones(3, 2), state=zeros(4))
@test ds.t == 0.
@test ds.state == zeros(4)
ds = ContinuousLinearSystem(input=Inport(2), output=Outport(3), A=ones(4,4), B=ones(4,2), C=ones(3,4), D=ones(3, 2))
@test typeof(ds.integrator.sol.prob.p) <: Interpolant
@test size(ds.integrator.sol.prob.p.timebuf) == (3,)
@test size(ds.integrator.sol.prob.p.databuf) == (2, 3)
@test isa(ds.output, Outport)
@test length(ds.input) == 2
@test length(ds.output) == 3
@test length(ds.state) == 4
oport = Outport(2)
iport = Inport(3)
trg = Outpin()
hnd = Inpin{Bool}()
connect!(ds.output, iport)
connect!(ds.handshake, hnd)
connect!(trg, ds.trigger)
connect!(oport, ds.input)
tsk = launch(ds)
tsk2 = @async while true
all(take!(iport) .=== NaN) && break
end
for t in 1. : 10.
put!(trg, t)
u = [sin(t), cos(t)]
put!(oport, u)
take!(hnd)
@test ds.t == t
@test [read(pin.link.buffer) for pin in iport] == ds.C * ds.state + ds.D * u
end
put!(trg, NaN)
sleep(0.1)
@test istaskdone(tsk)
put!(ds.output, NaN * ones(length(ds.output)))
sleep(0.1)
@test istaskdone(tsk2)
# Other 3-Dimensional AbstractODESystem tests
for (DSystem, defaults) in zip(
[
LorenzSystem,
ChenSystem,
ChuaSystem,
RosslerSystem
], [
(σ = 10., β = 8/3, ρ = 28., γ = 1.),
(a = 35., b = 3., c = 28., γ = 1.),
(diode = Jusdl.PiecewiseLinearDiode(), α = 15.6, β = 28., γ = 1.),
(a = 0.38, b = 0.3, c = 4.82, γ = 1.)
]
)
ds = DSystem(input=nothing, output=Outport(3); defaults...) # System with key-value pairs with no input and bus output.
ds = DSystem(input=nothing, output=Outport(3)) # System with no input
@test ds.input === nothing
@test isa(ds.output, Outport)
@test length(ds.output) == 3
@test length(ds.state) == 3
iport = Inport(3)
trg = Outpin()
hnd = Inpin{Bool}()
connect!(ds.output, iport)
connect!(trg, ds.trigger)
connect!(ds.handshake, hnd)
tsk = launch(ds)
tsk2 = @async while true
all(take!(iport) .=== NaN) && break
end
for t in 1. : 10.
put!(trg, t)
take!(hnd)
@test ds.t == t
@test [read(pin.link.buffer) for pin in iport] == ds.state
end
put!(trg, NaN)
sleep(0.1)
@test istaskdone(tsk)
put!(ds.output, NaN * ones(length(ds.output)))
sleep(0.1)
@test istaskdone(tsk2)
end
for (DSystem, defaults) in zip(
[
ForcedLorenzSystem,
ForcedChenSystem,
ForcedChuaSystem,
ForcedRosslerSystem
], [
(σ = 10., β = 8/3, ρ = 28., γ = 1.),
(a = 35., b = 3., c = 28., γ = 1.),
(diode = Jusdl.PiecewiseLinearDiode(), α = 15.6, β = 28., γ = 1.),
(a = 0.38, b = 0.3, c = 4.82, γ = 1.)
]
)
ds = DSystem(input=Inport(3), output=Outport(3), state=rand(3), cplmat=[1. 0 0; 0 1 0; 0 0 0])
@test typeof(ds.integrator.sol.prob.p) <: Interpolant
@test size(ds.integrator.sol.prob.p.timebuf) == (3,)
@test size(ds.integrator.sol.prob.p.databuf) == (3,3)
@test isa(ds.input, Inport)
@test isa(ds.output, Outport)
@test length(ds.input) == 3
@test length(ds.output) == 3
iport = Inport(3)
oport = Outport(3)
trg = Outpin()
hnd = Inpin{Bool}()
connect!(ds.output, iport)
connect!(oport, ds.input)
connect!(trg, ds.trigger)
connect!(ds.handshake, hnd)
tsk = launch(ds)
tsk2 = @async while true
all(take!(iport) .=== NaN) && break
end
for t in 1. : 10.
put!(trg, t)
u = [sin(t), cos(t), log(t)]
put!(oport, u)
take!(hnd)
@test ds.t == t
end
put!(trg, NaN)
sleep(0.1)
@test istaskdone(tsk)
put!(ds.output, NaN * ones(length(ds.output)))
sleep(0.1)
@test istaskdone(tsk2)
end
# VanderpolSystem tests.
ds = VanderpolSystem(input=nothing, output=Outport(2)) # System with no input
@test ds.input === nothing
@test isa(ds.output, Outport)
@test length(ds.output) == 2
@test length(ds.state) == 2
@test ds.μ == 5.
@test ds.γ == 1.
iport = Inport(2)
trg = Outpin()
hnd = Inpin{Bool}()
connect!(ds.output, iport)
connect!(trg, ds.trigger)
connect!(ds.handshake, hnd)
tsk = launch(ds)
tsk2 = @async while true
all(take!(iport) .=== NaN) && break
end
for t in 1. : 10.
put!(trg, t)
take!(hnd)
@test ds.t == t
@test [read(pin.link.buffer) for pin in iport] == ds.state
end
put!(trg, NaN)
sleep(0.1)
@test istaskdone(tsk)
put!(ds.output, NaN * ones(length(ds.output)))
sleep(0.1)
@test istaskdone(tsk2)
ds = ForcedVanderpolSystem(input=Inport(2), output=Outport(2), cplmat=[1 0; 0 0]) # Add input values to 1. state
@test isa(ds.input, Inport)
@test isa(ds.output, Outport)
@test length(ds.input) == 2
@test length(ds.output) == 2
iport = Inport(2)
oport = Outport(2)
trg = Outpin()
hnd = Inpin{Bool}()
connect!(oport, ds.input)
connect!(ds.output, iport)
connect!(trg, ds.trigger)
connect!(ds.handshake, hnd)
tsk = launch(ds)
tsk2 = @async while true
all(take!(iport) .=== NaN) && break
end
for t in 1. : 10.
put!(trg, t)
u = [sin(t), cos(t)]
put!(oport, u)
take!(hnd)
@test ds.t == t
@test [read(pin.link.buffer) for pin in iport] == ds.state
end
put!(trg, NaN)
sleep(0.1)
@test istaskdone(tsk)
put!(ds.output, NaN * ones(length(ds.output)))
sleep(0.1)
@test istaskdone(tsk2)
# Test defining new ODE systems
# The type must be mutabe
@test_throws Exception @eval @def_ode_system struct ODESystem{RH, RO, ST, IP, OP}
righthandside::RH
readout::RO
state::ST
input::IP
output::OP
end
# The type must be a subtype of AbstractODESystem
@test_throws Exception @eval @def_ode_system mutable struct ODESystem{RH, RO, ST, IP, OP}
righthandside::RH
readout::RO
state::ST
input::IP
output::OP
end
# The type must be subtype of AbstractODESystem
@test_throws Exception @eval @def_ode_system mutable struct ODESystem{RH, RO, ST, IP, OP} <: MyDummyyAbstractODESystem
righthandside::RH
readout::RO
state::ST
input::IP
output::OP
end
@info "Done ODESystemTestSet."
end # testset
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 3628 | # This file includes testset for RODESystem
import DifferentialEquations.RandomEM
@testset "RODESystemTestSet" begin
@info "Running RODESystemTestSet ..."
# RODESystem construction
function statefunc(dx, x, u, t, W)
dx[1] = 2x[1]*sin(W[1] - W[2])
dx[2] = -2x[2]*cos(W[1] + W[2])
end
outputfunc(x, u, t) = x
ds = RODESystem(righthandside=statefunc, readout=outputfunc, state=ones(2), input=nothing, output=Outport(2),
alg=RandomEM())
ds = RODESystem(righthandside=statefunc, readout=outputfunc, state=ones(2), input=nothing, output=Outport(2),
alg=RandomEM(), modelkwargs=(rand_prototype=zeros(2),))
@test typeof(ds.trigger) == Inpin{Float64}
@test typeof(ds.handshake) == Outpin{Bool}
@test ds.input === nothing
@test isa(ds.output, Outport)
@test length(ds.output) == 2
@test ds.state == ones(2)
@test ds.integrator.sol.prob.p === nothing
# Driving RODESystem
iport = Inport(2)
trg = Outpin()
hnd = Inpin{Bool}()
connect!(ds.output, iport)
connect!(trg, ds.trigger)
connect!(ds.handshake, hnd)
tsk = launch(ds)
tsk2 = @async while true
all(take!(iport) .=== NaN) && break
end
for t in 1 : 10
put!(trg, t)
take!(hnd)
@test ds.t == t
@test [read(pin.link.buffer) for pin in iport] == ds.state
end
put!(trg, NaN)
sleep(0.1)
@test istaskdone(tsk)
put!(ds.output, NaN * ones(length(ds.output)))
sleep(0.1)
@test istaskdone(tsk2)
# Driving RODESystem with input
function sfunc(dx, x, u, t, W)
dx[1] = 2x[1]*sin(W[1] - W[2]) + cos(u[1](t))
dx[2] = -2x[2]*cos(W[1] + W[2]) - sin(u[1](t))
end
ofunc(x, u, t) = x
ds = RODESystem(righthandside=sfunc, readout=ofunc, state=ones(2), input=Inport(2), output=Outport(2),
modelkwargs=(rand_prototype=zeros(2),))
@test typeof(ds.integrator.sol.prob.p) <: Interpolant
@test size(ds.integrator.sol.prob.p.timebuf) == (3,)
@test size(ds.integrator.sol.prob.p.databuf) == (2,3)
oport = Outport(2)
iport = Inport(2)
trg = Outpin()
hnd = Inpin{Bool}()
connect!(oport, ds.input)
connect!(ds.output, iport)
connect!(trg, ds.trigger)
connect!(ds.handshake, hnd)
tsk = launch(ds)
tsk2 = @async while true
all(take!(iport) .=== NaN) && break
end
for t in 1 : 10
put!(trg, t)
put!(oport, [t, 2t])
take!(hnd)
@test ds.t == t
@test [read(pin.link.buffer) for pin in iport] == ds.state
end
put!(trg, NaN)
sleep(0.1)
@test istaskdone(tsk)
put!(ds.output, NaN * ones(length(ds.output)))
sleep(0.1)
@test istaskdone(tsk2)
# Test defining new RODESystem types
# The type must be mutable
@test_throws Exception @eval @def_rode_system struct RODESystem{RH, RO, ST, IP, OP}
righthandside::RH
readout::RO
state::ST
input::IP
output::OP
end
# The type must be of type AbstractRODESystem
@test_throws Exception @eval @def_rode_system mutable struct RODESystem{RH, RO, ST, IP, OP}
righthandside::RH
readout::RO
state::ST
input::IP
output::OP
end
# The type must be of type AbstractRODESystem
@test_throws Exception @eval @def_rode_system mutable struct RODESystem{RH, RO, ST, IP, OP} <: MyDummyAbstractRODESystem
righthandside::RH
readout::RO
state::ST
input::IP
output::OP
end
@info "Done RODESystemTestSet ..."
end # testset | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 3386 | # This file includes testset for SDESystem
import DifferentialEquations: LambaEM
@testset "SDESystemTestSet" begin
@info "Running SDESystemTestSet ..."
# SDESystem construction
f(dx, x, u, t) = (dx[1] = -x[1])
h(dx, x, u, t) = (dx[1] = -x[1])
g(x, u, t) = x
ds = SDESystem(drift=f, diffusion=h, readout=g, state=[1.], input=nothing, output=Outport(1), alg=LambaEM{true}())
ds = SDESystem(drift=f, diffusion=h, readout=g, state=[1.], input=nothing, output=Outport(1))
@test typeof(ds.trigger) == Inpin{Float64}
@test typeof(ds.handshake) == Outpin{Bool}
@test ds.input === nothing
@test isa(ds.output, Outport)
@test length(ds.output) == 1
@test ds.integrator.sol.prob.p === nothing
# Driving SDESystem
iport = Inport(1)
trg = Outpin()
hnd = Inpin{Bool}()
connect!(ds.output, iport)
connect!(trg, ds.trigger)
connect!(ds.handshake, hnd)
tsk = launch(ds)
tsk2 = @async while true
all(take!(iport) .=== NaN) && break
end
for t in 1. : 10.
put!(trg, t)
take!(hnd)
@test ds.t == t
@test [read(pin.link.buffer) for pin in iport] == ds.state
end
put!(trg, NaN)
sleep(0.1)
@test istaskdone(tsk)
put!(ds.output, NaN * ones(length(ds.output)))
sleep(0.1)
@test istaskdone(tsk2)
# SDESystem with input
function f2(dx, x, u, t)
dx[1] = -x[1] + sin(u[2](t))
dx[2] = -x[2] + cos(u[1](t))
dx[3] = -x[3] + cos(u[1](t))
end
function h2(dx, x, u, t)
dx[1] = -x[1]
dx[2] = -x[2] + cos(u[1](t))
dx[3] = -x[3] + cos(u[2](t))
end
g2(x, u, t) = x
ds = SDESystem(drift=f2, diffusion=h2, readout=g2, state=ones(3), input=Inport(2), output=Outport(3))
oport = Outport(2)
iport = Inport(3)
trg = Outpin()
hnd = Inpin{Bool}()
connect!(oport, ds.input)
connect!(ds.output, iport)
connect!(trg, ds.trigger)
connect!(ds.handshake, hnd)
tsk = launch(ds)
tsk2 = @async while true
all(take!(iport) .=== NaN) && break
end
for t in 1 : 10
put!(trg, t)
put!(oport, [t, 2t])
take!(hnd)
@test ds.t == t
@test [read(pin.link.buffer) for pin in iport] == ds.state
end
put!(trg, NaN)
sleep(0.1)
@test istaskdone(tsk)
put!(ds.output, NaN * ones(length(ds.output)))
sleep(0.1)
@test istaskdone(tsk2)
# Test defining new SDESystem types
# The type must be mutable
@test_throws Exception @eval @def_sde_system struct SDESystem{DR, DF, RO, ST, IP, OP}
drift::DR
diffusion::DF
readout::RO
state::ST
input::IP
output::OP
end
# The type must be subtype of AbstractSDESystem
@test_throws Exception @eval @def_sde_system mutable struct SDESystem{DR, DF, RO, ST, IP, OP}
drift::DR
diffusion::DF
readout::RO
state::ST
input::IP
output::OP
end
# The type must be subtype of AbstractSDESystem
@test_throws Exception @eval @def_sde_system mutable struct SDESystem{DR, DF, RO, ST, IP, OP} <: MyDummyAbstractSDESystem
drift::DR
diffusion::DF
readout::RO
state::ST
input::IP
output::OP
end
@info "Running SDESystemTestSet ..."
end # testset
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 7287 | # This file includes testset for StaticSystems
@testset "StaticSystems" begin
@info "Running StaticSystemTestSet ..."
# StaticSystem construction
@def_static_system struct Mysystem{IP, OP, RO} <: AbstractStaticSystem
input::IP = Inport(2)
output::OP = Outport(3)
readout::RO = (u, t) -> [u[1] + u[2], u[1] - u[2], u[1] * u[2]]
end
# ofunc(u, t) = [u[1] + u[2], u[1] - u[2], u[1] * u[2]]
ss = Mysystem()
@test isimmutable(ss)
@test length(ss.input) == 2
@test length(ss.output) == 3
@test typeof(ss.input) == Inport{Inpin{Float64}}
@test typeof(ss.output) == Outport{Outpin{Float64}}
@test typeof(ss.trigger) == Inpin{Float64}
@test typeof(ss.handshake) == Outpin{Bool}
# ofunc2(u, t) = nothing
ss = Mysystem(readout=nothing, input=nothing, output=nothing) # Input or output may be nothing
@test ss.input === nothing
@test ss.output === nothing
# Driving of StaticSystem
ofunc3(u, t) = u[1] + u[2]
ss = Mysystem(readout = ofunc3, input=Inport(2), output=Outport(1))
iport, oport, ipin, opin = Inport(1), Outport(2), Inpin{Bool}(), Outpin()
connect!(oport, ss.input)
connect!(ss.output, iport)
connect!(opin, ss.trigger)
connect!(ss.handshake, ipin)
tsk = launch(ss)
tsk2 = @async while true
all(take!(iport) .=== NaN) && break
end
for t in 1. : 10.
put!(opin, t)
put!(oport, [t, t])
take!(ipin)
end
@test content(iport[1].link.buffer) == collect(1 : 10) * 2
@test !istaskdone(tsk)
put!(opin, NaN)
sleep(0.1)
@test istaskdone(tsk)
put!(ss.output, [NaN])
sleep(0.1)
@test istaskdone(tsk2)
# Adder tests
ss = Adder()
@test isimmutable(ss)
@test ss.signs == (+, +)
@test length(ss.output) == 1
ss = Adder(signs=(+, +, -))
@test ss.signs == (+, +, -)
oport, iport, opin, ipin = Outport(3), Inport(1), Outpin(), Inpin{Bool}()
connect!(opin, ss.trigger)
connect!(oport, ss.input)
connect!(ss.handshake, ipin)
connect!(ss.output, iport)
tsk = launch(ss)
tsk2 = @async while true
all(take!(iport) .=== NaN) && break
end
put!(opin, 1.)
put!(oport, [1, 3, 5])
take!(ipin)
@test read(iport[1].link.buffer) == 1 + 3 - 5
put!(opin, NaN)
sleep(0.1)
@test istaskdone(tsk)
put!(ss.output, [NaN])
sleep(0.1)
@test istaskdone(tsk2)
# Multiplier tests
ss = Multiplier(ops=(*, *))
@test isimmutable(ss)
@test ss.ops == (*, *)
@test length(ss.output) == 1
ss = Multiplier(ops=(*, *, /,*))
@test ss.ops == (*, *, /, *)
oport, iport, opin, ipin = Outport(4), Inport(1), Outpin(), Inpin{Bool}()
connect!(opin, ss.trigger)
connect!(oport, ss.input)
connect!(ss.handshake, ipin)
connect!(ss.output, iport)
tsk = launch(ss)
tsk2 = @async while true
all(take!(iport) .=== NaN) && break
end
put!(opin, 1.)
put!(oport, [1, 3, 5, 6])
take!(ipin)
@test read(iport[1].link.buffer) == 1 * 3 / 5 * 6
put!(opin, NaN)
sleep(0.1)
@test istaskdone(tsk)
put!(ss.output, [NaN])
sleep(0.1)
@test istaskdone(tsk2)
# Gain tests
ss = Gain(input=Inport(3))
@test isimmutable(ss)
@test ss.gain == 1.
@test length(ss.output) == 3
K = rand(3, 3)
ss = Gain(input=Inport(3), gain=K)
oport, iport, opin, ipin = Outport(3), Inport(3), Outpin(), Inpin{Bool}()
connect!(oport, ss.input)
connect!(opin, ss.trigger)
connect!(ss.handshake, ipin)
connect!(ss.output, iport)
tsk = launch(ss)
tsk2 = @async while true
all(take!(iport) .=== NaN) && break
end
u = rand(3)
put!(opin, 1.)
put!(oport, u)
take!(ipin)
@test [read(pin.link.buffer) for pin in iport] == K * u
put!(opin, NaN)
sleep(0.1)
@test istaskdone(tsk)
put!(ss.output, NaN * ones(3))
sleep(0.1)
@test istaskdone(tsk2)
# Terminator tests
ss = Terminator(input=Inport(3))
@test isimmutable(ss)
@test ss.readout === nothing
@test ss.output === nothing
@test typeof(ss.trigger) == Inpin{Float64}
@test typeof(ss.handshake) == Outpin{Bool}
oport, opin, ipin = Outport(3), Outpin(), Inpin{Bool}()
connect!(oport, ss.input)
connect!(opin, ss.trigger)
connect!(ss.handshake, ipin)
tsk = launch(ss)
put!(opin, 1.)
put!(oport, [1., 2., 3.])
take!(ipin)
@test [read(pin.link.buffer) for pin in ss.input] == [1., 2., 3.]
put!(opin, NaN)
sleep(0.1)
@test istaskdone(tsk)
# Memory tests
ss = Memory(delay=1., numtaps=10, initial=zeros(3))
@test isimmutable(ss)
@test size(ss.databuf) == (3, 10)
@test size(ss.timebuf) == (10,)
@test mode(ss.databuf) == Cyclic
@test mode(ss.timebuf) == Cyclic
@test typeof(ss.trigger) == Inpin{Float64}
@test typeof(ss.handshake) == Outpin{Bool}
@test typeof(ss.input) == Inport{Inpin{Float64}}
@test typeof(ss.output) == Outport{Outpin{Float64}}
@test outbuf(ss.databuf) == zeros(3, 10)
oport, iport, opin, ipin = Outport(3), Inport(3), Outpin(), Inpin{Bool}()
connect!(oport, ss.input)
connect!(opin, ss.trigger)
connect!(ss.handshake, ipin)
connect!(ss.output, iport)
tsk = launch(ss)
tsk2 = @async while true
all(take!(iport) .=== NaN) && break
end
put!(opin, 1.)
put!(oport, [10, 20, 30])
take!(ipin)
@test [read(pin.link.buffer) for pin in iport] == zeros(3)
@test ss.databuf[:, 1] == [10, 20, 30]
put!(opin, NaN)
sleep(0.1)
@test istaskdone(tsk)
put!(ss.output, NaN * ones(3))
sleep(0.1)
@test istaskdone(tsk2)
# Coupler test
conmat = [-1 1; 1 -1]
cplmat = [1 0 0; 0 0 0; 0 0 0]
ss = Coupler(conmat=conmat, cplmat=cplmat)
@test isimmutable(ss)
@test typeof(ss.trigger) == Inpin{Float64}
@test typeof(ss.handshake) == Outpin{Bool}
@test typeof(ss.input) == Inport{Inpin{Float64}}
@test typeof(ss.output) == Outport{Outpin{Float64}}
@test length(ss.input) == 6
@test length(ss.output) == 6
oport, iport, opin, ipin = Outport(6), Inport(6), Outpin(), Inpin{Bool}()
connect!(oport, ss.input)
connect!(opin, ss.trigger)
connect!(ss.handshake, ipin)
connect!(ss.output, iport)
tsk = launch(ss)
tsk2 = @async while true
all(take!(iport) .=== NaN) && break
end
put!(opin, 1.)
u = rand(6)
put!(oport, u)
take!(ipin)
@test [read(pin.link.buffer) for pin in iport] == kron(conmat, cplmat) * u
put!(opin, NaN)
sleep(0.1)
@test istaskdone(tsk)
put!(ss.output, NaN * ones(6))
sleep(0.1)
@test istaskdone(tsk2)
# Test defining new statik systems
# The type must be a subtype of AbstractStaticSystem
@test_throws Exception @eval @def_static_system struct MyStaticSystem{RO, OP}
reaout::RO = (u, t) -> u
output::OP = Outport()
end
# The type must be a subtype of AbstractStaticSystem
@test_throws Exception @eval @def_static_system struct MyStaticSystem{RO, OP} <: MyDummyAbstractStaticSystem
reaout::RO = (u, t) -> u
output::OP = Outport()
end
@info "Done StaticSystemTestSet ..."
end # testset | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 1219 | # This file includes the testset for links
@testset "LinkTestSet" begin
@info "Running LinkTestSet ..."
# Link construction.
l = Link(5)
@test eltype(l) == Float64
@test eltype(l.channel) == Float64
@test l.channel.sz_max == 0
@test length(l.buffer) == 5
@test mode(l.buffer) == Cyclic
@test !iswritable(l)
@test !isreadable(l)
# More on Buffer construction
l = Link{Int}(5)
@test size(l.buffer) == (5,)
@test eltype(l) == Int
l = Link{Bool}()
@test size(l.buffer) == (64,)
l = Link()
@test eltype(l) == Float64
@test size(l.buffer) == (64,)
# Putting values to link
l = Link()
t = @async while true
take!(l) === NaN && break
end
vals = collect(1:5)
for i = 1 : length(vals)
put!(l, vals[i])
@test l.buffer[1] == vals[i]
end
close(l)
@test istaskdone(t)
@test !isopen(l.channel)
# Taking values from the link
l = Link()
vals = collect(1 : 10)
t = launch(l, vals)
val = take!(l)
@test val == 1.
for i = 2 : 10
@test take!(l) == vals[i]
end
close(l)
wait(t)
@test istaskdone(t)
@info "Done LinkTestSet."
end # testset
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 2540 | # This file includes the testset for pins
@testset "PinTestSet" begin
@info "Running PinTestSet ..."
# Construction of Outpin
op = Outpin()
@test isa(op.links, Missing)
@test !isbound(op)
# Construction of Inpin
ip = Inpin()
@test !isbound(ip)
# Connection of pins
op, ip = Outpin(), Inpin()
l = connect!(op, ip)
@test isa(l, Link)
@test isbound(op)
@test isbound(ip)
@test l.masterid == op.id
@test l.slaveid == ip.id
@test isconnected(op, ip)
op2, ip2 = Outpin(), Inpin()
@test_throws Exception connect!(op, op2) # Outpin cannot be connected to Inpin
@test_throws Exception connect!(ip, ip2) # Inpin cannot be connected to Inpin
@test_throws Exception connect!(ip, op) # Inpin cannot be connected to Outpin
op1 = Outpin()
op2 = Outpin()
ip = Inpin()
@test_throws MethodError connect!(ip, op1) # Inpin cannot drive and Outpin
@test_throws MethodError connect!(op1, op2) # Outpoin cannot drive and Outpin
@test !isbound(op1)
@test !isbound(op2)
@test !isbound(ip)
l = connect!(op1, ip) # Outpin can drive Inpin
@test isbound(op1)
@test isbound(ip)
@test_throws ErrorException connect!(op1, ip) # Reconnection is not possible
@test_throws ErrorException connect!(op2, ip) # `ip` is bound. No new connections are allowed.
@test isconnected(op1, ip)
disconnect!(op1, ip)
@test !isconnected(op1, ip)
l = connect!(op2, ip)
@test isconnected(op2, ip)
@test isbound(ip)
# Connection of multiple Inpins to an Outpin
op = Outpin()
ips = [Inpin() for i in 1 : 5]
ls = map(ip -> connect!(op, ip), ips)
for (l, ip) in zip(ls, ips)
@test l.masterid == op.id
@test l.slaveid == ip.id
end
# Data transfer through pins
op, ip = Outpin(), Inpin()
@test_throws MethodError take!(op) # Data cannot be read from Outpin
@test_throws MethodError put!(ip, 1.) # Data cannot be written into Inpin
l = connect!(op, ip)
t = @async while true
take!(ip) === NaN && break # Take from ip
end
for val in 1 : 5
put!(op, val) # Write into op.
@test !istaskdone(t)
@test read(l.buffer) == val
end
put!(op, NaN)
@test istaskdone(t)
# Disconnection of Outpin and Inpin
op, ip = Outpin(), Inpin()
l = connect!(op, ip)
@test isconnected(op, ip)
disconnect!(op, ip)
@test !isconnected(op, ip)
@info "Done PinTestSet."
end # testset
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 1952 | # # This file includes the test set for ports
@testset "PortTestSet" begin
@info "Running PortTestSet ..."
# Constructiokn of Outport and Inport
op = Outport(5)
@test length(op.pins) == 5
@test all(.!isbound.(op))
@test eltype(op) == Outpin{Float64}
op = Outport{Int}(5)
@test eltype(op) == Outpin{Int}
op = Outport()
@test length(op.pins) == 1
# Construction of Inport
ip = Inport(3)
@test length(ip.pins) == 3
@test all(.!isbound.(ip))
@test eltype(ip) == Inpin{Float64}
ip = Inport{Bool}(4)
@test eltype(ip) == Inpin{Bool}
ip = Inport()
@test length(ip.pins) == 1
# Connection of Outport and Inport
op, ip = Outport(3), Inport(3)
ls = connect!(op, ip)
@test typeof(ls) <: Vector{<:Link}
@test length(ls) == 3
for (l, _op, _ip) in zip(ls, op, ip)
@test l.masterid == _op.id
@test l.slaveid == _ip.id
end
@test isconnected(op, ip)
# Partial connection of Outport and Inport
op = Outport(5)
ip1, ip2 = Inport(3), Inport(2)
@test_throws DimensionMismatch connect!(op, ip1) # Length of op and ip1 are not same
ls1 = connect!(op[1:3], ip1)
ls2 = connect!(op[4:5], ip2)
@test isconnected(op[1], ip1[1])
@test isconnected(op[4], ip2[1])
@test !isconnected(op[3], ip2[1])
# Data transfer through ports.
op, ip = Outport(2), Inport(2)
@test_throws MethodError take!(op)
@test_throws MethodError put!(ip, zeros(2))
ls = connect!(op, ip)
t = @async while true
all(take!(ip) .=== NaN) && break
end
for val in 1 : 5
put!(op, ones(2) * val)
@test !istaskfailed(t)
end
put!(op, [NaN, NaN])
@test istaskdone(t)
# Disconnection of ports
op, ip = Outport(), Inport()
ls = connect!(op, ip)
@test isconnected(op, ip)
disconnect!(op, ip)
@test !isconnected(op, ip)
@info "Donke PortTestSet."
end # testset
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 6551 | # This file includes testset for Model
@testset "ModelTestSet" begin
@info "Running ModelTestSet ..."
# Model construction
model = Model()
@test isempty(model.nodes)
@test isempty(model.branches)
@test isempty(model.taskmanager.pairs)
@test model.clock.t == 0.
@test model.clock.dt == 0.01
@test model.clock.tf == 1.
@test typeof(model.graph) <: SimpleDiGraph
@test nv(model.graph) == 0
@test ne(model.graph) == 0
# Adding nodes to model
model = Model()
comps = [SinewaveGenerator(), Gain(), Gain(), Writer()]
for (k,comp) in enumerate(comps)
node = addnode!(model, comp)
@test node.component === comp
@test node.idx == k
@test node.label === nothing
@test length(model.nodes) == k
@test nv(model.graph) == k
@test ne(model.graph) == 0
end
n = length(model.nodes)
singen = FunctionGenerator(readout=sin)
newnode = addnode!(model, singen, label=:gen)
@test newnode.idx == n + 1
@test newnode.label == :gen
rampgen = RampGenerator()
@test_throws Exception addnode!(model, rampgen, label=:gen)
# Accessing nodes in model
node = getnode(model, 1)
@test node.idx == 1
@test node.label == nothing
@test node.component == comps[1]
node = getnode(model, :gen)
@test node.idx == 5
@test node.label == :gen
@test node.component == singen
# Adding branches to model
model = Model()
@test_throws BoundsError addbranch!(model, 1 => 2)
@test_throws MethodError addbranch!(model, 1, 2)
for (comp, label) in zip(
[FunctionGenerator(readout=t -> [sin(t), cos(t)], output=Outport(2)), Gain(input=Inport(2)), Gain(input=Inport(3)), Writer(input=Inport(3))],
[:gen, :gain1, :gain2, :writer]
)
addnode!(model, comp, label=label)
end
branch = addbranch!(model, :gen => :gain1)
@test branch.nodepair == (1 => 2)
@test branch.indexpair == ((:) => (:))
@test typeof(branch.links) <: Vector{<:Link}
@test length(branch.links) == 2
@test length(model.branches) == 1
@test ne(model.graph) == 1
@test collect(edges(model.graph)) == [Edge(1, 2)]
branch2 = addbranch!(model, 2 => 3, 1 => 1)
@test branch2.nodepair == (2 => 3)
@test branch2.indexpair == (1 => 1)
@test typeof(branch2.links) <: Vector{<:Link}
@test length(model.branches) == 2
@test ne(model.graph) == 2
branch3 = addbranch!(model, 3 => :writer, 1:2 => 2:3)
@test length(model.branches) == 3
@test ne(model.graph) == 3
# Accessing branches
br = getbranch(model, 1 => 2)
@test br === branch
br2 = getbranch(model, :gain1 => :gain2)
@test br2 === branch2
@test_throws MethodError getbranch(model, 3 => :writer)
# Deleting branches
n = length(model.nodes)
br = deletebranch!(model, 1 => 2)
@test br === branch
@test branch ∉ model.branches
@test Edge(1, 2) ∉ edges(model.graph)
@test length(model.nodes) == n
@test !isconnected(
getnode(model, br.nodepair.first).component.output[br.indexpair.first],
getnode(model, br.nodepair.second).component.input[br.indexpair.second]
)
# Investigation of algebrraic loops
function contruct_model_with_loops()
model = Model()
for (comp, label) in zip(
[SinewaveGenerator(), Adder(signs=(+, +, +)), Gain(), Writer()],
[:gen, :adder, :gain, :writer]
)
addnode!(model, comp, label=label)
end
addbranch!(model, :gen => :adder, 1 => 1)
addbranch!(model, :adder => :gain, 1 => 1)
addbranch!(model, :gain => :adder, 1 => 2)
addbranch!(model, :adder => :adder, 1 => 3)
addbranch!(model, :gain => :writer, 1 => 1)
model
end
model = contruct_model_with_loops()
loops = getloops(model)
@test length(loops) == 2
@test [2] ∈ loops
@test [2, 3] ∈ loops
# Breaking algebrraic loops
loop = filter(loop -> loop == [2], loops)[1]
loopcomp = getnode(model, :adder).component
@test isconnected(loopcomp.output[1], loopcomp.input[3])
nn = length(model.nodes)
nb = length(model.branches)
breakernode = breakloop!(model, loop)
@test typeof(breakernode.component) <: Jusdl.LoopBreaker
@test breakernode.idx == nn + 1
@test breakernode.label === nothing
@test !isconnected(loopcomp.output[1], loopcomp.input[3])
@test length(model.nodes) == nn + 1
@test length(model.branches) == nb
loops = getloops(model)
@test length(loops) == 1
@test loops[1] == [2, 3]
nn = length(model.nodes)
nb = length(model.branches)
comp1 = getnode(model, 2).component
comp2 = getnode(model, 3).component
@test isconnected(comp2.output[1], comp1.input[2])
newbreakernode = breakloop!(model, loops[1])
@test typeof(newbreakernode.component) <: Jusdl.LoopBreaker
@test !isconnected(comp2.output[1], comp1.input[2])
# Initializing Model
model = Model()
addnode!(model, SinewaveGenerator())
addnode!(model, Writer())
addbranch!(model, 1 => 2)
Jusdl.initialize!(model)
@test !isempty(model.taskmanager.pairs)
@test checktaskmanager(model.taskmanager) === nothing
@test length(model.taskmanager.pairs) == 2
@test getnode(model, 1).component in keys(model.taskmanager.pairs)
@test getnode(model, 2).component in keys(model.taskmanager.pairs)
# Running Model
ti, dt, tf = 0., 0.01, 10.
set!(model.clock, ti, dt, tf)
run!(model)
@test isoutoftime(model.clock)
@test isapprox(read(getbranch(model, 1 => 2).links[1].buffer), sin(2 * pi * tf))
@test read(getnode(model, 2).component.timebuf) == tf
# Terminating Model
@test !any(istaskdone.(values(model.taskmanager.pairs)))
Jusdl.terminate!(model)
@test all(istaskdone.(values(model.taskmanager.pairs)))
# Simulating Model
model = Model()
addnode!(model, FunctionGenerator(readout=t -> [sin(t), cos(t)], output=Outport(2)), label=:gen)
addnode!(model, Adder(), label=:adder)
addnode!(model, Writer(), label=:writer)
addbranch!(model, :gen => :adder)
addbranch!(model, :adder => :writer)
sim = simulate!(model)
@test typeof(sim) <: Simulation
@test sim.model === model
@test sim.retcode == :success
@test sim.state == :done
@test isoutoftime(model.clock)
@test all(istaskdone.(values(model.taskmanager.pairs)))
@info "Done ModelTestSet."
end # testset | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 1427 | # This file includes testset for Simulation
@testset "SimulationTestSet" begin
@info "Running SimulationTestSet ..."
# Simulation construction
model = Model()
simname = string(uuid4())
simdir = tempdir()
sim = Simulation(model, simdir=simdir, simname=simname, logger=SimpleLogger())
@test sim.model === model
@test startswith(basename(sim.path), "Simulation-")
@test sim.path == joinpath(simdir, "Simulation-" * simname)
@test sim.state == :idle
@test sim.retcode == :unknown
@test sim.name == "Simulation-" * simname
# Check Writer files
model = Model()
addnode!(model, SinewaveGenerator(), label=:gen)
addnode!(model, Writer(), label=:writer)
addbranch!(model, :gen => :writer)
dname1 = dirname(getnode(model, :writer).component.file.path)
simname = string(uuid4())
simdir = tempdir()
sim = Simulation(model, simdir=simdir, simname=simname)
@test dirname(getnode(model, :writer).component.file.path) == sim.path
@test dname1 != sim.path
# Report Simulation
sim = simulate!(model, 0., 0.01, 10.)
report(sim)
filename = joinpath(sim.path, "report.jld2")
@test isfile(filename)
data = load(filename)
@test data["name"] == sim.name
@test data["path"] == sim.path
@test data["state"] == sim.state
@test data["retcode"] == sim.retcode
@info "Done SimulationTestSet."
end # testset | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 925 | # This file includes testset for TaskManager
@testset "TaskManager" begin
@info "Running TaskManagerTestSet ..."
# Preliminaries.
gettask(ch) = @async while true
val = take!(ch)
val === NaN && break
val == 0 && error("The task failed.")
println("Took val" * string(val))
end
# TaskManager construction
struct Mytype1
x::Int
end
comps = [Mytype1(i) for i = 1 : 5]
chpairs = [Channel(0) for i = 1 : 5]
comptasks = [gettask(chpair) for chpair in chpairs]
ps = Dict(zip(comps, comptasks))
tm = TaskManager(ps)
@test checktaskmanager(tm) === nothing # All tasks are running, nothing is thrown.
put!(chpairs[1], 0.) # Fail the trigger task first Mytype1
put!(chpairs[2], 0.) # Fail the output task first Mytype1
@test_throws Exception checktaskmanager(tm)
@info "Done TaskManagerTestSet."
end # testset
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 780 | # This file includes testset for Plugin
@testset "PluginTestSet" begin
@info "Running PluginTestSet ..."
# Construction of a new plugin
Base.@kwdef struct MeanPlugin{PR} <: AbstractPlugin
process::PR = x -> mean(x)
end
# Try equip a writer in a model.
model = Model(clock=Clock(0., 0.01, 10.))
addnode!(model, SinewaveGenerator(), label=:gen)
addnode!(model, Writer(buflen=50, plugin=MeanPlugin()), label=:writer)
addbranch!(model, :gen => :writer)
simulate!(model)
# Test the simulation data
data = read(getnode(model, :writer).component, flatten=false)
@test length(data) == 20
for (t,x) in data
@test isapprox(x, mean(sin.(2 * pi * t)))
end
@info "Done PluginTestSet ..."
end # testset
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 2839 | # This file includes the buffer test set
@testset "BufferTestSet" begin
@info "Running BufferTestSet ..."
# Simple Buffer construction
buf = Buffer(5)
@test eltype(buf) == Float64
@test length(buf) == 5
@test size(buf) == (5,)
@test mode(buf) == Cyclic
@test buf.index == 1
@test isempty(buf)
@test buf.state == :empty
@test size(buf) == (5,)
@test isa(buf, AbstractArray)
# Buffer data length
buf = Buffer(5)
@test datalength(buf) == 5
buf = Buffer(3, 10)
@test datalength(buf) == 10
# Writing values into Buffers
buf = Buffer(5)
write!(buf, 1.)
@test !isempty(buf)
@test !isfull(buf)
@test buf.index == 2
@test buf.state == :nonempty
# Reading from buffers
val = read(buf)
@test val == 1.
@test buf.index == 2
@test !isempty(buf)
# More on buffer construction
buf = Buffer{Fifo}(Float64, 2, 5)
buf = Buffer{Fifo}(Float64, 5)
buf = Buffer{Fifo}(5)
buf = Buffer{Normal}(5)
buf = Buffer(5)
# # Filling buffers
# buf = Buffer{Cyclic}(5)
# fill!(buf, 1.)
# @test outbuf(buf) == ones(5)
# buf = Buffer{Normal}(2,5)
# fill!(buf, [1, 1])
# @test buf.data == ones(2, 5)
# Writing into Buffers with different modes
for bufmode in [Normal, Lifo, Fifo]
buf = Buffer{bufmode}(2, 5)
for item in 1 : 5
write!(buf, [item, item])
end
@test outbuf(buf) == [5. 4. 3. 2. 1.; 5. 4. 3. 2. 1.]
@test isfull(buf)
@test buf.index == 6
@test_throws Exception write!(buf, [1., 2.]) # When full, data cannot be written into buffers.
end
buf = Buffer{Cyclic}(2, 5)
for item in 1 : 5
write!(buf, [item, item])
end
@test outbuf(buf) == [5. 4. 3. 2. 1.; 5. 4. 3. 2. 1.]
@test isfull(buf)
@test buf.index == 6
temp = outbuf(buf)
write!(buf, [6., 6.]) # When full, data can be written into Cyclic buffers.
@test outbuf(buf) == hcat([6., 6.], temp[:, 1:end-1])
# Reading from Buffers with different modes
for bufmode in [Normal, Cyclic]
buf = Buffer{bufmode}(5)
foreach(item -> write!(buf, item), 1 : 5)
for i = 1 : 5
@test read(buf) == 5
end
@test !isempty(buf)
end
buf = Buffer{Fifo}(5)
foreach(item -> write!(buf, item), 1 : 5)
for i = 1 : 5
@test read(buf) == i
end
@test isempty(buf)
@test_throws Exception read(buf) # When buffer is empty, no more reads.
buf = Buffer{Lifo}(5)
foreach(item -> write!(buf, item), 1 : 5)
vals = collect(5:-1:1)
for i = 1 : 5
@test read(buf) == vals[i]
end
@test isempty(buf)
@test_throws Exception read(buf) # When buffer is empty, no more reads.
@info "Done BufferTestSet."
end # testset
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | code | 782 | # This file includees the callbacks tests
@testset "CallbackTestSet" begin
@info "Running CallbackTestSet ..."
condition(obj) = obj.x >= 5
action(obj) = println("Callaback activated . obj.x = ", obj.x)
clb = Callback(condition=condition, action=action)
@test isenabled(clb)
disable!(clb)
@test !isenabled(clb)
mutable struct Object{CB}
x::Int
clb::CB
end
obj = Object(1, clb)
for val in 1 : 10
obj.x = val
obj.clb(obj)
end
mutable struct Object2{CB}
x::Int
callbacks::CB
end
obj2 = Object2(4, Callback(condition=condition, action=action))
for val in 1 : 10
obj2.x = val
applycallbacks(obj2)
end
@info "Done CallbackTestSet."
end # testset
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 5670 | # Jusdl
[](https://zekeriyasari.github.io/Jusdl.jl/stable)
[](https://zekeriyasari.github.io/Jusdl.jl/dev)
[](https://travis-ci.com/zekeriyasari/Jusdl.jl)
[](https://ci.appveyor.com/project/zekeriyasari/Jusdl-jl)
[](https://codecov.io/gh/zekeriyasari/Jusdl.jl)
[](https://coveralls.io/github/zekeriyasari/Jusdl.jl)
Jusdl (Julia-Based System Description Language) focusses on effective systems simulations together with online and offline data analysis. In Jusdl, it is possible to simulate discrete time and continuous time, static or dynamical systems. In particular, it is possible to simulate dynamical systems modeled by different types of differential equations such as ODE (Ordinary Differential Equation), Random Ordinary Differential Equation (RODE), SDE (Stochastic Differential Equation), DDE (Delay Differential Equation) and DAE (Differential Algebraic Equation), and discrete difference equations. During the simulation, the data flowing through the links of the model can processed online and specialized analyzes can be performed. These analyzes can also be enriched with plugins that can easily be defined using the standard Julia library or various Julia packages. The simulation is performed by evolving the components of the model individually and in parallel in sampling time intervals. The individual evolution of the components allows the simulation of the models including the components that are represented by different kinds of mathematical equations.
## Features
* Simulation of a large class of systems:
* Static systems (whose input, output relation is represented by a functional relation)
* Dynamical systems (whose input, state and output relation is represented by difference or differential equations[1]).
* Dynamical systems modelled by continuous time differential equations: ODE, DAE, RODE, SDE, DDE.
* Dynamics systems modelled by discrete time difference equations.
* Simulation of models consisting of components that are represented by different type mathematical equations.
* Individual construction of components, no need to construct a unique equation representing the whole model.
* Online data analysis through plugins
* Flexibility to enrich the data analysis scope through user-defined plugins.
[1] : [DifferentialEquations.jl](https://docs.juliadiffeq.org/) package is used for differential equation solving.
## Installation
Installation of Jusdl is like any other registered Julia package. Enter the Pkg REPL by pressing ] from the Julia REPL and then add Jusdl:
```julia
] add Jusdl
```
## A First Look
Consider following simple model.
<center>
<img src="docs/src/assets/ReadMeModel/brokenloop.svg"
alt="Closed Loop System"
style="float: center; margin-right: 10px;"
width="75%"/>
</center>
Note that the model consists of connected components. In this example, the components are the sinusoidal wave generator, an adder, a dynamical system. The writer is included in the model to save simulation data. By using Jusdl, the model is simulated as follows:
```julia
using Jusdl
# Describe model
@defmodel model begin
@nodes begin
gen = SinewaveGenerator(amplitude=1., frequency=1/2π)
adder = Adder(signs=(+, -))
ds = ContinuousLinearSystem(state=[1.])
writer = Writer(input=Inport(2))
end
@branches begin
gen[1] => adder[1]
adder[1] => ds[1]
ds[1] => adder[2]
ds[1] => writer[1]
gen[1] => writer[2]
end
end
# Simulate the model
tinit, tsample, tfinal = 0., 0.01, 10.
sim = simulate!(model, tinit, tsample, tfinal)
# Read and plot data
t, x = read(getnode(model, :writer).component)
t, x = read(getnode(model, :writer).component)
using Plots
plot(t, x[:, 1], label="r(t)", xlabel="t")
plot!(t, x[:, 2], label="y(t)", xlabel="t")
plot!(t, 6 / 5 * exp.(-2t) + 1 / 5 * (2 * sin.(t) - cos.(t)), label="Analytical Solution")
```
```
[ Info: 2020-05-04T23:32:00.338 Started simulation...
[ Info: 2020-05-04T23:32:00.338 Inspecting model...
┌ Info: The model has algrebraic loops:[[2, 3]]
└ Trying to break these loops...
[ Info: Loop [2, 3] is broken
[ Info: 2020-05-04T23:32:00.479 Done.
[ Info: 2020-05-04T23:32:00.479 Initializing the model...
[ Info: 2020-05-04T23:32:01.283 Done...
[ Info: 2020-05-04T23:32:01.283 Running the simulation...
Progress: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████| Time: 0:00:00
[ Info: 2020-05-04T23:32:01.469 Done...
[ Info: 2020-05-04T23:32:01.469 Terminating the simulation...
[ Info: 2020-05-04T23:32:01.476 Done.
```
<center>
<img src="docs/src/assets/ReadMePlot/readme_example.svg"
alt="Readme Plot"
style="float: center; margin-right: 10px;"
width="75%"/>
</center>
For more information about how to use Jusdl, see its [documentation](https://zekeriyasari.github.io/Jusdl.jl/) .
## Contribution
Any form of contribution is welcome. Please feel free to open an [issue](https://github.com/zekeriyasari/Jusdl.jl/issues) for bug reports, feature requests, new ideas and suggestions etc., or to send a pull request for any bug fixes.
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 2733 | # Construction and Simulation of Subsystems
In this tutorial, we will construct and simulate subsystems. A subsystem consists of connected components. A subsystem can serve as a component of a model. That is, components of a model can be a subsystem consisting of sub-components. The input/output port of a subsystem can be specified from the input/output port of components of the subsystem. It is also possible that a subsystem may have no input/output. That is, the input or output of a subsystem is nothing.
Like the construction of a model, a subsystem is constructed by constructing the sub-components of the subsystem and connecting the sub-components.
!!! warning
Since a subsystem serves a standalone component in a model, the components of the subsystem must be connected to each other. Otherwise, the subsystem cannot take step which in turn causes the simulation to get stuck.
Consider the simple subsystem whose block diagram is given below.
```@raw html
<center>
<img src="../../assets/Subsystem/subsystem.svg" alt="model" width="60%"/>
</center>
```
We first construct the subsystem.
```@example subsystem_tutorial
using Jusdl
# Construct a subsystem
adder = Adder((+,-))
gain = Gain()
gen = ConstantGenerator()
connect!(gen.output, adder.input[2])
connect!(adder.output, gain.input)
sub = SubSystem([gen, adder, gain], adder.input[1], gain.output)
```
Since these components will serve as a subsystem, we must connect them. The input port of `adder` and output port of `gain` is specified as the input and output port of the subsystem `sub`. That is, we have a single-input-single-output subsystem.
Then, we construct the model. We drive the subsystem with a generator and save its output in a writer as shown in the block diagram below.
```@raw html
<center>
<img src="../../assets/SubsystemConnected/subsystemconnected.svg" alt="model" width="45%"/>
</center>
```
Thus, we construct other remaining components.
```@example subsystem_tutorial
model = Model()
addnode!(model, sub, label=:sub)
addnode!(model, SinewaveGenerator(frequency=5), label=:gen)
addnode!(model, Writer(), label=:writer)
nothing # hide
```
Then, to construct the model, we connect the components of the model
```@example subsystem_tutorial
addbranch!(model, :gen => :sub, 1 => 1)
addbranch!(model, :sub => :writer, 1 => 1)
nothing # hide
```
At this step, we are ready to simulate the model.
```@example subsystem_tutorial
sim = simulate!(model)
sim
```
We, then, read the simulation data from the writer and plot it.
```@example subsystem_tutorial
using Plots
t, x = read(getnode(model, :writer).component)
plot(t, x)
savefig("subsystem_tutorial_plot.svg"); nothing # hide
```
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 1285 | # Jusdl
Jusdl enables fast and effective systems simulations together with online and offline data analysis. In Jusdl, it is possible to simulate discrete-time and continuous-time, static or dynamical systems. In particular, it is possible to simulate dynamical systems modeled by different types of differential equations such as ODE (Ordinary Differential Equation), Random Ordinary Differential Equation (RODE), SDE (Stochastic Differential Equation), DDE (Delay Differential Equation) and DAE (Differential Algebraic Equation), and discrete difference equations. During the simulation, the data flowing through the links of the model can be processed online and offline and specialized analyzes can be performed. These analyses can also be enriched with plugins that can easily be defined using the standard Julia library or various Julia packages. The simulation is performed by evolving the components individually and in parallel during sampling time intervals. The individual evolution of the components allows the simulation of the models that include components represented by different kinds of mathematical equations.
## Installation
Installation of `Jusdl` is the similar to any other registered Julia package. Start a Julia session and type
```julia
] add Jusdl
```
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 1770 | # Evolution of Components
In Jusdl, the simulation of a model is performed by individual evolution of components (see [Modeling](@ref) and [Simulation](@ref section) for more information of modeling and simulation adopted in Jusdl). Basically, when triggered through its `trigger` pin, based on its type, a component takes a forward step as follows,
1. The next clock time `t` is read from its `trigger` pin.
2. The next input value `u(t)` is read from from its `input` port,
3. The component evolves from its current time `t - dt` to the current clock time `t`
4. Using the state variable `x(t)` at time `t`, current clock time `t` and `u(t)`, the next output value `y(t)` is computed.
5. The component writes `true` to its `handshake` pin to signal that taking step is performed with success.
or a backward step as follows.
1. The next clock time `t` is read from its `trigger` pin.
2. Using the state variable `x(t - dt)` at time `t - dt`, current component time `t - dt` and `u(t - dt)`, the next output value `y(t)` is computed.
3. The next input value `u(t)` is read from from its `input` port,
4. The component evolves from its current time `t - dt` to the current clock time `t`
5. The component writes `true` to its `handshake` pin to signal that taking step is performed with success.
Here `dt` is the simulation step size.
## Reading Time
```@docs
readtime!
```
## Reading State
```@docs
readstate
```
## Reading Input
```@docs
readinput!
```
## Writing Output
```@docs
writeoutput!
```
## Computing Output
```@docs
computeoutput
```
## Evolve
```@docs
evolve!
```
## Taking Steps
```@docs
takestep!
Jusdl.forwardstep
Jusdl.backwardstep
launch(comp::AbstractComponent)
launch(comp::AbstractSubSystem)
drive!
approve!
terminate!
```
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 306 | # Component Type Hierarchy
```@docs
AbstractComponent
AbstractSource
AbstractSystem
AbstractSink
AbstractStaticSystem
AbstractDynamicSystem
AbstractSubSystem
AbstractMemory
AbstractDiscreteSystem
AbstractODESystem
AbstractRODESystem
AbstractDAESystem
AbstractSDESystem
AbstractDDESystem
``` | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 120 | # Interpolation
## Full API
```@autodocs
Modules = [Jusdl]
Pages = ["interpolant.jl"]
Order = [:type, :function]
``` | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 285 | # Printer
## Basic Operation of Printers
See [Basic Operation of Writers](@ref) since the operation of [`Writer`](@ref) and that of [`Printer`](@ref) is very similar.
## Full API
```@docs
Printer
print(printer::Printer, td, xd)
open(printer::Printer)
close(printer::Printer)
``` | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 258 | # Scope
## Basic Operation of Scopes
See [Basic Operation of Writers](@ref) since the operation of [`Writer`](@ref) and that of [`Scope`](@ref) is very similar.
## Full API
```@docs
Scope
update!(s::Scope, x, yi)
close(sink::Scope)
open(sink::Scope)
``` | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 1030 | # Sinks
`Sink`s are used to simulation data flowing through the connections of the model. The data processing is done online during the simulation. `Sink` type is a subtype of `AbstractSink`. An `AbstractSink` is also a subtype of `AbstractComponent` (see [Components](@ref)), so an `AbstractSink` instance has a `trigger` link to be triggered and a `handshake` link to signal that evolution is succeeded. In addition, an `AbstractSink` has an input buffer `inbuf` whose mode is [`Cyclic`](@ref). When an `AbstractSink` instance is triggered through its trigger link, it basically reads its incoming data and writes to its input buffer `inbuf`. When its input buffer `inbuf` is full, the data in `inbuf` is processed according to the type of `AbstractSink`. `Jusdl` provides three concrete subtypes of `AbstractSink` which are [Writer](@ref), [Printer](@ref) and [Scope](@ref). As the operation of an `AbstractSink` just depends on incoming data, an `AbstractSink` does not have an output.
## Full API
```@docs
@def_sink
``` | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 2587 | # Writer
## Basic Operation of Writers
Having `launch`ed, a `Writer` is triggered through its `trigger` pin. When triggered, a `Writer` reads its input and then writes it to its internal buffer `databuf`. When `databuf` is full, the data in `databuf` is processed. Thus, the length of the data that is to be processed by the `Writer` is determined by the length of their internal buffer `databuf`.
Let us construct a `Writer`.
```@repl writer_ex
using Jusdl # hide
w = Writer(input=Inport(), buflen=5)
```
The file of `w` is closed and the `trigger` pin of `w` is not writable. That is, it is not possible to trigger `w` from its `trigger` pin.
```@repl writer_ex
w.file
w.trigger
```
To trigger `w`, we need to open and launch it,
```@repl writer_ex
oport, trg, hnd = Outport(), Outpin(), Inpin{Bool}()
connect!(oport, w.input)
connect!(trg, w.trigger)
connect!(w.handshake, hnd)
open(w)
t = launch(w)
```
Now, the internal file of `w` is opened in read/write mode and its `trigger` pin is writable.
```@repl writer_ex
w.file
w.trigger.link
```
Let us now trigger `w`.
```@repl writer_ex
put!(trg, 1.)
```
The `input` of `w` is now readable and `handshake` pin is not readable since `w` have not signaled that its triggering is succeeded yet. To do that, we need to put a value to the `input` of `w`
```@repl writer_ex
put!(oport, [10.])
```
Now, `w` signalled that its step is succeeded. It read the data from its `input` and written it into is `databuf`.
```@repl writer_ex
hnd.link
take!(hnd)
w.databuf
```
Since the `databuf` is not full nothing is written to the `file` of `w`.
```@repl writer_ex
w.file
```
Let us continue triggering `w` until the `databuf` of `w` is full.
```@repl writer_ex
for t in 2. : 5.
put!(trg, t)
put!(oport, [t * 10])
take!(hnd)
end
```
Now check that the content of the `file` of `w`.
```@repl writer_ex
w.file
```
Note that the content of `databuf` is written to the `file` of `w`. The operation of `w` can be terminated.
```@repl writer_ex
put!(trg, NaN)
```
When terminated, the `file` of `w` is closed.
```@repl writer_ex
w.file
```
!!! note
In this example, `w` does not have a `plugin` so nothing has been derived or computed from the data in `databuf`. The data in `databuf` is just written to `file` of `w`. To further data processing, see [Plugins](@ref)
## Full API
```@docs
Writer
write!(writer::Writer, td, xd)
read(writer::Writer; flatten=true)
fread
mv(writer::Writer, dst; force::Bool=false)
cp(writer::Writer, dst; force=false, follow_symlinks=false)
open(writer::Writer)
close(writer::Writer)
``` | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 2657 | # Clock
`Jusdl` is a *clocked* simulation environment. That is, model components are evolved in different time intervals, called the *sampling interval*. During the simulation, model components are triggered by these generated time pulses. A `Clock` instance is used to to generate those time pulses. The simulation time settings--the simulation start time, stop time, sampling interval--are configured through the `Clock`.
## Construction of Clock
Construction of `Clock` is done by specifying its start time and final time and the simulation sampling period.
```@repl clock_example_1
using Jusdl # hide
Clock(0., 1, 10.)
Clock{Int}(1, 1, 10)
```
## Basic Usage of Clocks
A `Clock` has a [Callback](@ref) list so that a [`Callback`](@ref) can be constructed to trigger specific events configured with the time settings. See the following case study.
Let us consider a `Clock` with initial time of `0`, sampling interval of `1` and final time of `10`.
```@repl clk_ex
using Jusdl # hide
clk = Clock(0., 1., 10.)
```
Notice that `clk` is not *running*, since it is not set. Now, let us set it
```@repl clk_ex
set!(clk)
```
`clk` is ready to run, i.e., to be iterated. The following commands generated clock ticks and shows it on the console.
```@repl clk_ex
for t in clk
@show t
end
```
At this point, `clk` is out of time. The current time of `clk` does not advance any more.
```@repl clk_ex
take!(clk)
```
But, `clk` can be reset again.
```@repl clk_ex
set!(clk, 0., 1., 10.)
```
Consider that we want to configure an alarm. For this, let us consider that when the time of `clk` is greater than `5` an alarm message is printed on the console. To this end, we need to construct a [`Callback`](@ref) and add it to the callbacks of `clk`. (When constructed callback list of `clk` is empty.)
```@repl clk_ex
condition(clk) = clk.t > 5
action(clk) = println("Clock time = ", clk.t)
clk = Clock(0., 1., 10., callbacks=Callback(condition=condition, action=action))
set!(clk)
```
Now, let us run `clk` by iterating it.
```@repl clk_ex
for t in clk
@show t
end
```
Note that we, constructed a simple callback. It is of course possible to construct more complex callbacks.
## Usage of Clocks with ProgressMeter
It also possible to iterate the `Clock`s by using a progress meter. See [ProgressMeter](https://github.com/timholy/ProgressMeter.jl) for further information for progress meter.
```julia
using Jusdl
using ProgressMeter
clk = Clock(0., 0.01, 1.)
set!(clk)
@showprogress for t in clk
end
```
Note that `clk` is just iterated.
## Full API
```@autodocs
Modules = [Jusdl]
Pages = ["clock.jl"]
Order = [:type, :function]
```
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 2666 | # Generators
## Basic Operation AbstractSource
An `AbstractSource` is a subtype of `AbstractComponent`. (See [Components](@ref) for more information.) An `AbstractComponent` has `input` port and `output` port for data flow. The `AbstractComponent` reads data from the `input` port and writes data to `output` port. Since the input-output relation of `AbstractSource` depends on just the current time `t`, `Source`s do not have `input` ports since they do not read input values. They just need time `t` to compute its output. During their evolution, an `AbstractComponent` reads time `t` from its `trigger` pins, computes its output according to its output function and writes its computed output to its `output` ports. An `AbstractComponent` also writes `true` to their `handshake` pin to signal that the evolution is succeeded. To further clarify the operation of `AbstractSource`, let us do some examples.
```@repl source_ex
using Jusdl # hide
f(t) = t * exp(t) + sin(t)
gen = FunctionGenerator(readout=f)
```
We constructed a [`FunctionGenerator`](@ref) which is an `AbstractSource`.
```@repl source_ex
gen isa AbstractSource
```
To drive `gen`, that is to make `gen` evolve, we need to launch `gen`. To this end, we construct ports and pins for input-output and signaling.
```@repl source_ex
trg, hnd, iport = Outpin(), Inpin{Bool}(), Inport(length(gen.output))
connect!(gen.output, iport)
connect!(trg, gen.trigger)
connect!(gen.handshake, hnd)
t = launch(gen)
tout = @async while true
all(take!(iport) .=== NaN) && break
end
```
At this moment, `gen` is ready to be triggered from its `trigger` link. Note that the trigger link `gen.trigger` and the output `gen.output` of `gen` are writable.
```@repl source_ex
gen.trigger.link
gen.output[1].links[1]
```
`gen` is triggered by writing time `t` to `trg`
```@repl source_ex
put!(trg, 1.)
```
When triggered `gen` writes `true` to its handshake link `gen.handshake` which can be read from `hnd`.
```@repl source_ex
hnd.link
```
and to drive `gen` for another time `hnd` must be read.
```@repl source_ex
take!(hnd)
```
Now continue driving `gen`.
```@repl source_ex
for t in 2. : 10.
put!(trg, t)
take!(hnd)
end
```
When triggered, the output of `gen` is written to its output `gen.output`.
```@repl source_ex
gen.output[1].links[1].buffer
```
`Jusdl` provides some other function generators which are documented in the following section.
## Full API
```@docs
@def_source
FunctionGenerator
SinewaveGenerator
DampedSinewaveGenerator
SquarewaveGenerator
TriangularwaveGenerator
ConstantGenerator
RampGenerator
StepGenerator
ExponentialGenerator
DampedExponentialGenerator
``` | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 110 | # DAESystem
## Full API
```@docs
@def_dae_system
DAESystem
RobertsonSystem
PendulumSystem
RLCSystem
```
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
Subsets and Splits