Replace Variable subtype with known

Author: HarrisonGrodin

README.md

@@ -136,8 +136,8 @@ context-aware single variable of the IR. Its fields are described as follows:
 - `name`: the name of the `Variable`. Note that this is not necessarily
   the same as the name of the Julia variable. But this symbol itself is considered
   the core identifier of the `Variable` in the sense of equality.
-- `subtype`: the main denotation of context. Variables within systems
-  are grouped according to their `subtype`.
+- `known`: the main denotation of context, storing whether or not the value of
+  the variable is known.
 - `dependents`: the vector of variables on which the current variable
   is dependent. For example, `u(t,x)` has dependents `[t,x]`. Derivatives thus
   require this information in order to simplify down.
@@ -252,9 +252,9 @@ is syntactic sugar for:
 
 ```julia
 t = Parameter(:t)
-x = Unknown(:x, dependents = [t])
-y = Unknown(:y, dependents = [t])
-z = Unknown(:z, dependents = [t])
+x = Unknown(:x, [t])
+y = Unknown(:y, [t])
+z = Unknown(:z, [t])
 D = Differential(t)
 σ = Parameter(:σ)
 ρ = Parameter(:ρ)

src/equations.jl

@@ -12,9 +12,10 @@ Base.:~(lhs::Expression, rhs::Number    ) = Equation(lhs, rhs)
 Base.:~(lhs::Number    , rhs::Expression) = Equation(lhs, rhs)
 
 
-_is_dependent(x::Variable) = x.subtype === :Unknown && !isempty(x.dependents)
-_is_parameter(iv) = x -> x.subtype === :Parameter && x ≠ iv
-_subtype(subtype::Symbol) = x -> x.subtype === subtype
+_is_dependent(x::Variable) = !x.known && !isempty(x.dependents)
+_is_parameter(iv) = x -> x.known && x ≠ iv
+_is_known(x::Variable) = x.known
+_is_unknown(x::Variable) = !x.known
 
 function extract_elements(eqs, predicates)
     result = [Variable[] for p ∈ predicates]

src/systems/diffeqs/first_order_transform.jl

@@ -5,7 +5,7 @@ end
 function lower_varname(var::Variable, idv, order::Int)
     sym = var.name
     name = order == 0 ? sym : Symbol(sym, :_, string(idv.name)^order)
-    return Variable(name, var.subtype, var.dependents)
+    return Variable(name, var.known, var.dependents)
 end
 
 function ode_order_lowering(sys::DiffEqSystem)

src/systems/nonlinear/nonlinear_system.jl

@@ -18,7 +18,7 @@ struct NonlinearSystem <: AbstractSystem
 end
 
 function NonlinearSystem(eqs)
-    vs, ps = extract_elements(eqs, [_subtype(:Unknown), _subtype(:Parameter)])
+    vs, ps = extract_elements(eqs, [_is_unknown, _is_known])
     NonlinearSystem(eqs, vs, ps)
 end
 

src/variables.jl

@@ -3,12 +3,12 @@ export Variable, Unknown, Parameter, @Unknown, @Param
 
 struct Variable <: Expression
     name::Symbol
-    subtype::Symbol
+    known::Bool
     dependents::Vector{Variable}
 end
 
-Parameter(name; dependents = Variable[]) = Variable(name, :Parameter, dependents)
-Unknown(name; dependents = Variable[]) = Variable(name, :Unknown, dependents)
+Parameter(name, dependents = Variable[]) = Variable(name, true, dependents)
+Unknown(name, dependents = Variable[]) = Variable(name, false, dependents)
 
 
 struct Constant <: Expression
@@ -22,7 +22,7 @@ Base.isone(ex::Expression)  = isa(ex, Constant) && isone(ex.value)
 
 
 # Variables use isequal for equality since == is an Operation
-Base.:(==)(x::Variable, y::Variable) = (x.name, x.subtype) == (y.name, y.subtype)
+Base.:(==)(x::Variable, y::Variable) = (x.name, x.known) == (y.name, y.known)
 Base.:(==)(::Variable, ::Number) = false
 Base.:(==)(::Number, ::Variable) = false
 Base.:(==)(::Variable, ::Constant) = false
@@ -32,13 +32,18 @@ Base.:(==)(n::Number, c::Constant) = c.value == n
 Base.:(==)(a::Constant, b::Constant) = a.value == b.value
 
 function Base.convert(::Type{Expr}, x::Variable)
-    x.subtype === :Parameter || return x.name
-    isempty(x.dependents)    && return x.name
+    x.known               || return x.name
+    isempty(x.dependents) && return x.name
     return :($(x.name)($(convert.(Expr, x.dependents)...)))
 end
 Base.convert(::Type{Expr}, c::Constant) = c.value
 
-Base.show(io::IO, x::Variable) = print(io, x.subtype, '(', x.name, ')')
+function Base.show(io::IO, x::Variable)
+    subtype = x.known ? :Parameter : :Unknown
+    print(io, subtype, '(', repr(x.name))
+    isempty(x.dependents) || print(io, ", ", x.dependents)
+    print(io, ')')
+end
 
 # Build variables more easily
 function _parse_vars(macroname, fun, x)
@@ -65,7 +70,7 @@ function _parse_vars(macroname, fun, x)
         end
 
         push!(var_names, var_name)
-        expr = :($var_name = $fun($(Meta.quot(var_name)), dependents = $dependents))
+        expr = :($var_name = $fun($(Meta.quot(var_name)), $dependents))
         push!(ex.args, expr)
     end
     push!(ex.args, build_expr(:tuple, var_names))

test/basic_variables_and_operations.jl

@@ -7,7 +7,7 @@ using Test
 
 # Default values
 p = Parameter(:p)
-u = Unknown(:u, dependents = [t])
+u = Unknown(:u, [t])
 
 σ*(y-x)
 D(x)

test/variable_parsing.jl

@@ -5,9 +5,9 @@ using Test
 @Unknown x(t)
 @Unknown y(t)
 @Unknown z(t)
-x1 = Unknown(:x ,dependents = [t])
-y1 = Unknown(:y ,dependents = [t])
-z1 = Unknown(:z ,dependents = [t])
+x1 = Unknown(:x, [t])
+y1 = Unknown(:y, [t])
+z1 = Unknown(:z, [t])
 @test x1 == x
 @test y1 == y
 @test z1 == z