Recently I revisited some old Julia code of mine and wondered how to implement it properly.
The setting is: I have a model struct which holds some model definition. Let’s say, each model just describes some system of equations which we want to solve for all variables x[i]:
struct model
equations::String # just to simplify (no strings in reality)
end
a = model("x[1] = x[2] and x[2] = 0")
b = model("x[1] = x[2] + 1 and x[2] = 0")
Therefore, I want to have a function solve(foo::model) which returns [0, 0] for a and [1, 0] in the case of b. For that reason, I have some macro which autogenerates the functions
function f_a!(F, x)
F[1] = x[2] - x[1]
F[2] = -x[2]
end
and
function f_b!(F, x)
F[1] = x[2] + 1 - x[1]
F[2] = -x[2]
end
These allow us to formulate the model problem as F(x) = 0 and we can plug the respective function into NLsolve.jl.
My simple question is now: How do we properly identify the model foo with the function f_foo! inside the function solve? After all, all models have the same type. My first intention is to just add some field id or name which can then be used inside solve. However, assume we have 1000 models loaded, then this is associated with runtime costs.
We could also have a new field f!::Function in every model which holds the correct function. This seems kinda odd.
Furthermore, if I define a new type for every model instead, it is not a good user experience. Of course I could hide them with some kind of composition:
struct model
equations <: AbstractEquations
end
and then have the structs Equations1, Equations2 etc. for each new model.
But I guess I am overthinking this way too much. Any suggestions?
