refactor: remove varmap_to_vars and related outdated infrastructure

Author: AayushSabharwal

src/variables.jl

@@ -149,133 +149,6 @@ function default_toterm(x)
     end
 end
 
-"""
-$(SIGNATURES)
-
-Takes a list of pairs of `variables=>values` and an ordered list of variables
-and creates the array of values in the correct order with default values when
-applicable.
-"""
-function varmap_to_vars(varmap, varlist; defaults = Dict(), check = true,
-        toterm = default_toterm, promotetoconcrete = nothing,
-        tofloat = true, use_union = true)
-    varlist = collect(map(unwrap, varlist))
-
-    # Edge cases where one of the arguments is effectively empty.
-    is_incomplete_initialization = varmap isa DiffEqBase.NullParameters ||
-                                   varmap === nothing
-    if is_incomplete_initialization || isempty(varmap)
-        if isempty(defaults)
-            if !is_incomplete_initialization && check
-                isempty(varlist) || throw(MissingVariablesError(varlist))
-            end
-            return nothing
-        else
-            varmap = Dict()
-        end
-    end
-
-    # We respect the input type if it's a static array
-    # otherwise canonicalize to a normal array
-    # container_type = T <: Union{Dict,Tuple} ? Array : T
-    if varmap isa StaticArray
-        container_type = typeof(varmap)
-    else
-        container_type = Array
-    end
-
-    vals = if eltype(varmap) <: Pair # `varmap` is a dict or an array of pairs
-        varmap = todict(varmap)
-        _varmap_to_vars(varmap, varlist; defaults, check, toterm)
-    else # plain array-like initialization
-        varmap
-    end
-
-    promotetoconcrete === nothing && (promotetoconcrete = container_type <: AbstractArray)
-    if promotetoconcrete
-        vals = promote_to_concrete(vals; tofloat, use_union)
-    end
-
-    if isempty(vals)
-        return nothing
-    elseif container_type <: Tuple
-        (vals...,)
-    else
-        SymbolicUtils.Code.create_array(container_type, eltype(vals), Val{1}(),
-            Val(length(vals)), vals...)
-    end
-end
-
-const MISSING_VARIABLES_MESSAGE = """
-                                Initial condition underdefined. Some are missing from the variable map.
-                                Please provide a default (`u0`), initialization equation, or guess
-                                for the following variables:
-                                """
-
-struct MissingVariablesError <: Exception
-    vars::Any
-end
-
-function Base.showerror(io::IO, e::MissingVariablesError)
-    println(io, MISSING_VARIABLES_MESSAGE)
-    println(io, join(e.vars, ", "))
-end
-
-function _varmap_to_vars(varmap::Dict, varlist; defaults = Dict(), check = false,
-        toterm = Symbolics.diff2term, initialization_phase = false)
-    varmap = canonicalize_varmap(varmap; toterm)
-    defaults = canonicalize_varmap(defaults; toterm)
-    varmap = merge(defaults, varmap)
-    values = Dict()
-
-    T = Union{}
-    for var in varlist
-        var = unwrap(var)
-        val = unwrap(fixpoint_sub(var, varmap; operator = Symbolics.Operator))
-        if !isequal(val, var)
-            values[var] = val
-        end
-    end
-    missingvars = setdiff(varlist, collect(keys(values)))
-    check && (isempty(missingvars) || throw(MissingVariablesError(missingvars)))
-    return [values[unwrap(var)] for var in varlist]
-end
-
-function varmap_with_toterm(varmap; toterm = Symbolics.diff2term)
-    return merge(todict(varmap), Dict(toterm(unwrap(k)) => v for (k, v) in varmap))
-end
-
-function canonicalize_varmap(varmap; toterm = Symbolics.diff2term)
-    new_varmap = Dict()
-    for (k, v) in varmap
-        k = unwrap(k)
-        v = unwrap(v)
-        new_varmap[k] = v
-        new_varmap[toterm(k)] = v
-        if Symbolics.isarraysymbolic(k) && Symbolics.shape(k) !== Symbolics.Unknown()
-            for i in eachindex(k)
-                new_varmap[k[i]] = v[i]
-                new_varmap[toterm(k[i])] = v[i]
-            end
-        end
-    end
-    return new_varmap
-end
-
-@noinline function throw_missingvars(vars)
-    throw(ArgumentError("$vars are missing from the variable map."))
-end
-
-struct IsHistory end
-ishistory(x::Num) = ishistory(unwrap(x))
-ishistory(x::Symbolic) = getmetadata(x, IsHistory, false)
-hist(x, t) = wrap(hist(unwrap(x), t))
-function hist(x::Symbolic, t)
-    setmetadata(
-        toparam(maketerm(typeof(x), operation(x), [unwrap(t)], metadata(x))),
-        IsHistory, true)
-end
-
 ## Bounds ======================================================================
 struct VariableBounds end
 Symbolics.option_to_metadata_type(::Val{:bounds}) = VariableBounds

test/initial_values.jl

@@ -66,13 +66,6 @@ ps = [k1 => 1.0, k2 => 5.0]
 # overdetermined because parameter initialization isn't in yet
 @test_warn "overdetermined" oprob=ODEProblem(osys_m, [u0; ps], tspan)
 
-# Make sure it doesn't error on array variables with unspecified size
-@parameters p::Vector{Real} q[1:3]
-varmap = Dict(p => ones(3), q => 2ones(3))
-cvarmap = ModelingToolkit.canonicalize_varmap(varmap)
-target_varmap = Dict(p => ones(3), q => 2ones(3), q[1] => 2.0, q[2] => 2.0, q[3] => 2.0)
-@test cvarmap == target_varmap
-
 # Initialization of ODEProblem with dummy derivatives of multidimensional arrays
 # Issue#1283
 @variables z(t)[1:2, 1:2]

test/odesystem.jl

@@ -434,14 +434,6 @@ end
 
 @named sys = System([0 ~ sys1.y + sys2.y], t; systems = [sys1, sys2])
 
-# DelayDiffEq
-using ModelingToolkit: hist
-@variables x(t) y(t)
-xₜ₋₁ = hist(x, t - 1)
-eqs = [D(x) ~ x * y
-       D(y) ~ y * x - xₜ₋₁]
-@named sys = System(eqs, t)
-
 # register
 using StaticArrays
 using SymbolicUtils: term