Add interface, SymbolCache, tests

Author: AayushSabharwal

Project.toml

@@ -3,7 +3,11 @@ uuid = "2efcf032-c050-4f8e-a9bb-153293bab1f5"
 authors = ["Aayush Sabharwal <[email protected]> and contributors"]
 version = "0.1.0"
 
+[deps]
+DocStringExtensions = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"
+
 [compat]
+DocStringExtensions = "0.9"
 julia = "1"
 
 [extras]

README.md

@@ -1 +1 @@
-# SymbolicIndexingInterface
+# SymbolicIndexingInterface.jl

src/SymbolicIndexingInterface.jl

@@ -1,5 +1,11 @@
 module SymbolicIndexingInterface
 
-# Write your package code here.
+using DocStringExtensions
+
+include("interface.jl")
+include("symbolcache.jl")
+
+export independent_variables, is_indep_sym, states, state_sym_to_index, is_state_sym,
+       parameters, param_sym_to_index, is_param_sym, SymbolCache
 
 end

src/interface.jl

@@ -0,0 +1,55 @@
+"""
+$(TYPEDSIGNATURES)
+
+Get the set of independent variables for the given system.
+"""
+function independent_variables end
+
+"""
+$(TYPEDSIGNATURES)
+
+Check if the given sym is an independent variable in the given system.
+"""
+function is_indep_sym end
+
+"""
+$(TYPEDSIGNATURES)
+
+Get the set of states for the given system.
+"""
+function states end
+
+"""
+$(TYPEDSIGNATURES)
+
+Find the index of the given sym in the given system.
+"""
+function state_sym_to_index end
+
+"""
+$(TYPEDSIGNATURES)
+
+Check if the given sym is a state variable in the given system.
+"""
+function is_state_sym end
+
+"""
+$(TYPEDSIGNATURES)
+
+Get the set of parameters variables for the given system.
+"""
+function parameters end
+
+"""
+$(TYPEDSIGNATURES)
+
+Find the index of the given sym in the given system.
+"""
+function param_sym_to_index end
+
+"""
+$(TYPEDSIGNATURES)
+
+Check if the given sym is a parameter variable in the given system.
+"""
+function is_param_sym end

src/symbolcache.jl

@@ -0,0 +1,27 @@
+struct SymbolCache{S,T,U}
+    syms::S
+    indepsym::T
+    paramsyms::U
+end
+
+
+independent_variables(sc::SymbolCache) = sc.indepsym
+independent_variables(::SymbolCache{S,Nothing}) where {S} = []
+is_indep_sym(sc::SymbolCache, sym) = any(isequal(sym), sc.indepsym)
+is_indep_sym(::SymbolCache{S,Nothing}, _) where {S} = false
+states(sc::SymbolCache) = sc.syms
+states(::SymbolCache{Nothing}) = []
+state_sym_to_index(sc::SymbolCache, sym) = findfirst(isequal(sym), sc.syms)
+state_sym_to_index(::SymbolCache{Nothing}, _) = nothing
+is_state_sym(sc::SymbolCache, sym) = !isnothing(state_sym_to_index(sc, sym))
+parameters(sc::SymbolCache) = sc.paramsyms
+parameters(::SymbolCache{S,T,Nothing}) where {S,T} = []
+param_sym_to_index(sc::SymbolCache, sym) = findfirst(isequal(sym), sc.paramsyms)
+param_sym_to_index(::SymbolCache{S,T,Nothing}, _) where {S,T} = nothing
+is_param_sym(sc::SymbolCache, sym) = !isnothing(param_sym_to_index(sc, sym))
+  
+Base.copy(VA::SymbolCache) = typeof(VA)(
+    (VA.syms===nothing) ? nothing : copy(VA.syms),
+    (VA.indepsym===nothing) ? nothing : copy(VA.indepsym),
+    (VA.paramsyms===nothing) ? nothing : copy(VA.paramsyms),
+)

test/runtests.jl

@@ -1,6 +1,6 @@
 using SymbolicIndexingInterface
 using Test
 
-@testset "SymbolicIndexingInterface.jl" begin
-    # Write your tests here.
+@time begin
+    @time @testset begin include("symbolcache.jl") end
 end

test/symbolcache.jl

@@ -0,0 +1,28 @@
+using SymbolicIndexingInterface, Test
+
+sc = SymbolCache(nothing, nothing, nothing)
+@test isempty(independent_variables(sc))
+@test !is_indep_sym(sc, :a)
+@test isempty(states(sc))
+@test isnothing(state_sym_to_index(sc, :a))
+@test !is_state_sym(sc, :a)
+@test isempty(parameters(sc))
+@test isnothing(param_sym_to_index(sc, :a))
+@test !is_param_sym(sc, :a)
+
+sc = SymbolCache([:a, :b], [:t], [:c, :d])
+@test independent_variables(sc) == [:t]
+@test is_indep_sym(sc, :t)
+@test !is_indep_sym(sc, :a)
+@test states(sc) == [:a, :b]
+@test state_sym_to_index(sc, :a) == 1
+@test state_sym_to_index(sc, :b) == 2
+@test isnothing(state_sym_to_index(sc, :t))
+@test all(is_state_sym.((sc,), [:a, :b]))
+@test !is_state_sym(sc, :c)
+@test parameters(sc) == [:c, :d]
+@test param_sym_to_index(sc, :c) == 1
+@test param_sym_to_index(sc, :d) == 2
+@test isnothing(param_sym_to_index(sc, :a))
+@test all(is_param_sym.((sc,), [:c, :d]))
+@test !is_param_sym(sc, :b)