refactor: remove wrap_array_vars, wrap_mtkparameters, wrap_parameter_dependencies

Author: AayushSabharwal

src/systems/abstractsystem.jl

@@ -206,217 +206,8 @@ function wrap_assignments(isscalar, assignments; let_block = false)
     end
 end
 
-function wrap_parameter_dependencies(sys::AbstractSystem, isscalar)
-    wrap_assignments(isscalar, [eq.lhs ← eq.rhs for eq in parameter_dependencies(sys)])
-end
-
-"""
-    $(TYPEDSIGNATURES)
-
-Add the necessary assignment statements to allow use of unscalarized array variables
-in the generated code. `expr` is the expression returned by the function. `dvs` and
-`ps` are the unknowns and parameters of the system `sys` to use in the generated code.
-`inputs` can be specified as an array of symbolics if the generated function has inputs.
-If `history == true`, the generated function accepts a history function. `cachesyms` are
-extra variables (arrays of variables) stored in the cache array(s) of the parameter
-object. `extra_args` are extra arguments appended to the end of the argument list.
-
-The function is assumed to have the signature `f(du, u, h, x, p, cache_syms..., t, extra_args...)`
-Where:
-- `du` is the optional buffer to write to for in-place functions.
-- `u` is the list of unknowns. This argument is not present if `dvs === nothing`.
-- `h` is the optional history function, present if `history == true`.
-- `x` is the array of inputs, present only if `inputs !== nothing`. Values are assumed
-  to be in the order of variables passed to `inputs`.
-- `p` is the parameter object.
-- `cache_syms` are the cache variables. These are part of the splatted parameter object.
-- `t` is time, present only if the system is time dependent.
-- `extra_args` are the extra arguments passed to the function, present only if
-  `extra_args` is non-empty.
-"""
-function wrap_array_vars(
-        sys::AbstractSystem, exprs; dvs = unknowns(sys), ps = parameters(sys),
-        inputs = nothing, history = false, cachesyms::Tuple = (), extra_args::Tuple = ())
-    isscalar = !(exprs isa AbstractArray)
-    var_to_arridxs = Dict()
-
-    if dvs === nothing
-        uind = 0
-    else
-        uind = 1
-        for (i, x) in enumerate(dvs)
-            iscall(x) && operation(x) == getindex || continue
-            arg = arguments(x)[1]
-            inds = get!(() -> [], var_to_arridxs, arg)
-            push!(inds, (uind, i))
-        end
-    end
-    p_start = uind + 1 + history
-    rps = (reorder_parameters(sys, ps)..., cachesyms...)
-    if inputs !== nothing
-        rps = (inputs, rps...)
-    end
-    if has_iv(sys)
-        rps = (rps..., get_iv(sys))
-    end
-    rps = (rps..., extra_args...)
-    for sym in reduce(vcat, rps; init = [])
-        iscall(sym) && operation(sym) == getindex || continue
-        arg = arguments(sym)[1]
-
-        bufferidx = findfirst(buf -> any(isequal(sym), buf), rps)
-        idxinbuffer = findfirst(isequal(sym), rps[bufferidx])
-        inds = get!(() -> [], var_to_arridxs, arg)
-        push!(inds, (p_start + bufferidx - 1, idxinbuffer))
-    end
-
-    viewsyms = Dict()
-    splitsyms = Dict()
-    for (arrsym, idxs) in var_to_arridxs
-        length(idxs) == length(arrsym) || continue
-        # allequal(first, idxs) is a 1.11 feature
-        if allequal(Iterators.map(first, idxs))
-            viewsyms[arrsym] = (first(first(idxs)), reshape(last.(idxs), size(arrsym)))
-        else
-            splitsyms[arrsym] = reshape(idxs, size(arrsym))
-        end
-    end
-    if isscalar
-        function (expr)
-            Func(
-                expr.args,
-                [],
-                Let(
-                    vcat(
-                        [sym ← :(view($(expr.args[i].name), $idxs))
-                         for (sym, (i, idxs)) in viewsyms],
-                        [sym ←
-                         MakeArray([expr.args[bufi].elems[vali] for (bufi, vali) in idxs],
-                             expr.args[idxs[1][1]]) for (sym, idxs) in splitsyms]
-                    ),
-                    expr.body,
-                    false
-                )
-            )
-        end
-    else
-        function (expr)
-            Func(
-                expr.args,
-                [],
-                Let(
-                    vcat(
-                        [sym ← :(view($(expr.args[i].name), $idxs))
-                         for (sym, (i, idxs)) in viewsyms],
-                        [sym ←
-                         MakeArray([expr.args[bufi].elems[vali] for (bufi, vali) in idxs],
-                             expr.args[idxs[1][1]]) for (sym, idxs) in splitsyms]
-                    ),
-                    expr.body,
-                    false
-                )
-            )
-        end,
-        function (expr)
-            Func(
-                expr.args,
-                [],
-                Let(
-                    vcat(
-                        [sym ← :(view($(expr.args[i + 1].name), $idxs))
-                         for (sym, (i, idxs)) in viewsyms],
-                        [sym ← MakeArray(
-                             [expr.args[bufi + 1].elems[vali] for (bufi, vali) in idxs],
-                             expr.args[idxs[1][1] + 1]) for (sym, idxs) in splitsyms]
-                    ),
-                    expr.body,
-                    false
-                )
-            )
-        end
-    end
-end
-
 const MTKPARAMETERS_ARG = Sym{Vector{Vector}}(:___mtkparameters___)
 
-"""
-    wrap_mtkparameters(sys::AbstractSystem, isscalar::Bool, p_start = 2, offset = Int(is_time_dependent(sys)))
-
-Return function(s) to be passed to the `wrap_code` keyword of `build_function` which
-allow the compiled function to be called as `f(u, p, t)` where `p isa MTKParameters`
-instead of `f(u, p..., t)`. `isscalar` denotes whether the function expression being
-wrapped is for a scalar value. `p_start` is the index of the argument containing
-the first parameter vector in the out-of-place version of the function. For example,
-if a history function (DDEs) was passed before `p`, then the function before wrapping
-would have the signature `f(u, h, p..., t)` and hence `p_start` would need to be `3`.
-
-`offset` is the number of arguments at the end of the argument list to ignore. Defaults
-to 1 if the system is time-dependent (to ignore `t`) and 0 otherwise.
-
-The returned function is `identity` if the system does not have an `IndexCache`.
-"""
-function wrap_mtkparameters(sys::AbstractSystem, isscalar::Bool, p_start = 2,
-        offset = Int(is_time_dependent(sys)))
-    if has_index_cache(sys) && get_index_cache(sys) !== nothing
-        if isscalar
-            function (expr)
-                param_args = expr.args[p_start:(end - offset)]
-                param_buffer_idxs = findall(x -> x isa DestructuredArgs, param_args)
-                param_buffer_args = param_args[param_buffer_idxs]
-                destructured_mtkparams = DestructuredArgs(
-                    [x.name for x in param_buffer_args],
-                    MTKPARAMETERS_ARG; inds = param_buffer_idxs)
-                Func(
-                    [
-                        expr.args[begin:(p_start - 1)]...,
-                        destructured_mtkparams,
-                        expr.args[(end - offset + 1):end]...
-                    ],
-                    [],
-                    Let(param_buffer_args, expr.body, false)
-                )
-            end
-        else
-            function (expr)
-                param_args = expr.args[p_start:(end - offset)]
-                param_buffer_idxs = findall(x -> x isa DestructuredArgs, param_args)
-                param_buffer_args = param_args[param_buffer_idxs]
-                destructured_mtkparams = DestructuredArgs(
-                    [x.name for x in param_buffer_args],
-                    MTKPARAMETERS_ARG; inds = param_buffer_idxs)
-                Func(
-                    [
-                        expr.args[begin:(p_start - 1)]...,
-                        destructured_mtkparams,
-                        expr.args[(end - offset + 1):end]...
-                    ],
-                    [],
-                    Let(param_buffer_args, expr.body, false)
-                )
-            end,
-            function (expr)
-                param_args = expr.args[(p_start + 1):(end - offset)]
-                param_buffer_idxs = findall(x -> x isa DestructuredArgs, param_args)
-                param_buffer_args = param_args[param_buffer_idxs]
-                destructured_mtkparams = DestructuredArgs(
-                    [x.name for x in param_buffer_args],
-                    MTKPARAMETERS_ARG; inds = param_buffer_idxs)
-                Func(
-                    [
-                        expr.args[begin:p_start]...,
-                        destructured_mtkparams,
-                        expr.args[(end - offset + 1):end]...
-                    ],
-                    [],
-                    Let(param_buffer_args, expr.body, false)
-                )
-            end
-        end
-    else
-        identity
-    end
-end
-
 mutable struct Substitutions
     subs::Vector{Equation}
     deps::Vector{Vector{Int}}