Add `new()` syntax to events

[TorkelE]

With the latest version of MTK we now have the prev() syntax to designate in events which values are from before the triggering of the event (and which are from after the event). I.e.

(X ~ 2.0) => [X ~ pre(X) + 1.0]

designates an event where, once X reaches the value 2.0, 1.0 unit for X is added.

I think it would be nice to support a syntax where one can rather designate which values are from the updated system, i.e. so that one can write:

(X ~ 2.0) => [new(X) ~ X + 1.0]

Advantages include:

• The same syntax is used for the condition and affect part. I.e. right now the pre() is implied across all conditions. While this is implicitly obvious, it is still nice to have a syntax be consistent across the entire event.
• In the vast majority of cases (at least that I can imagine), there is only a single symbolic variable for the post-event system (and this is typically isolated on the lhs). However, multiple pre-event symbolic variables are not that plausible. The syntax new(X) ~ ... simply feels a bit cleaner than X ~ pre(X + Xup + ...).

Considerations:

• Practically, an event declared using the new notation could directly (and internally) be converted to one using the pre notation (but just flipping all variables).
• Events using both new and pre should probably be disallowed.
• This doesn't actually add any new functionality, and only offers some syntax improvement, so it is relatively low priority.

[ChrisRackauckas]

No this doesn't make sense because it doesn't compose easily. new(new(X)) means that new(X) is not the solved for variable but is instead the previous variable. So it would get confusing because you have non-locality where a single new(new( changes the definition of what all new( means.

Also, it seems weird to introduce extra syntax here. This is not really special event syntax, it's just the discrete system syntax: https://docs.sciml.ai/ModelingToolkit/stable/tutorials/discrete_system/. Under MTK v10, callback affect!s are simply ImplicitDiscreteSystems. The reason for this is multi-fold and will be discussed more at JuliaCon, but it effectively solves the problem of DAE reinitialization automatically simultaneously to giving an unambiguous syntax to the affect! functions, and also upgrades the syntax to allow for potentially nonlinear implicit systems for the update rules. So it's 3 updates that all come together by making it an ImplicitDiscreteSystem, and the first statement here is then a consequence of the fact that as a resolvable ImplicitDiscreteSystem it would be solving for the new value (the least de-shifted value).

So in general, what's going on is that everything is an ImplicitDiscreteSystem and you need to make a choice there: x(n) ~ x(n-1) + x(n - 2) or x(n+2) ~ x(n+1) + x(n). But counting downwards has many advantages in most of the areas of the compiler and has more predictable behavior as syntax in most models (for the non-locality reason I described, where adding a big x(n + m) would effectively shift everything while x(n - m) would just put a new history term in the back), and so I think it's pretty clear that the ImplicitDiscreteSystem should be counting downwards, in which case the event system just adopts that and does x(n) ~ x(n-1) which is x ~ Pre(x) in short form.

[TorkelE]

I might misunderstand something about Pre in this case. New(New(X)) doesn't really make sense to me, but in the same way that Pre(Pre(X)) doesn't seem to make sense either. However, you suggest that this is actually something relevant, and if so, what does it mean?
(if we were solving difference equations I get it, but this is a ODE, would Pre(Pre(X)) fetch X from a couple of events ago, and if so, is this specific to the declared event only, or all events of the system?)

[ChrisRackauckas]

(if we were solving difference equations I get it, but this is a ODE, would Pre(Pre(X)) fetch X from a couple of events ago, and if so, is this specific to the declared event only, or all events of the system?)

It would fetch X from a couple of events ago, and this is required in many events used for example in control systems.

[TorkelE]

Ok, then it makes sense. Once the docs are up I will read things through to understand exactly how this works.