update spelling, most importantly fix wrong spelling of continuous

Author: hexaeder

NEWS.md

@@ -1,5 +1,12 @@
 # NetworkDynamics Release Notes
 
+## v0.10.3 Changelog
+- [#301](https://github.com/JuliaDynamics/NetworkDynamics.jl/pull/301) improve callback system performance and flexibility:
+  - Add callback batching for better DiscreteComponentCallback performance 
+  - Allow `EIndex(1=>2)` as standalone edge index with relaxed type constraints
+  - Optimize CallbackSet construction to prevent performance bottlenecks
+  - Add important documentation warning about parameter array copying in callbacks
+
 ## v0.10.2 Changelog
 - [#299](https://github.com/JuliaDynamics/NetworkDynamics.jl/pull/299) enhance metadata system with pattern matching and utility functions:
   - Add String/Regex pattern matching for all metadata functions (`has_metadata`, `get_metadata`, `set_metadata!`, etc.)

docs/src/API.md

@@ -197,8 +197,8 @@ is_linear_stable
 ### Define Callbacks
 ```@docs
 NetworkDynamics.ComponentCallback
-ContinousComponentCallback
-VectorContinousComponentCallback
+ContinuousComponentCallback
+VectorContinuousComponentCallback
 DiscreteComponentCallback
 PresetTimeComponentCallback
 ComponentCondition

docs/src/callbacks.md

@@ -21,7 +21,7 @@ refer to the [Cascading Failure](@ref) example.
 ## Component-based Callback functions
 In practice, events often act locally, meaning they only depend and act on a
 specific component or type of component. `NetworkDynamics.jl` provides a way of
-defining those callbacks on a component level and automaticially combine them into performant
+defining those callbacks on a component level and automatically combine them into performant
 [`VectorContinuousCallback`](@extref SciMLBase.VectorContinuousCallback) and [`DiscreteCallback`](@extref SciMLBase.DiscreteCallback) for the whole network.
 
 The main entry points are the types [`ContinousComponentCallback`](@ref),
@@ -72,10 +72,10 @@ vectoraffect = ComponentAffect([:u], [:p]) do u, p, event_idx, ctx
     end
 end
 ```
-Notably, the `syms` (here `:u`) can *exclusivly* refer to "ordinary" states, since they are now writable.
+Notably, the `syms` (here `:u`) can *exclusively* refer to "ordinary" states, since they are now writable.
 However the affect gets passed a `ctx` "context" object, which is a named tuple which holds additional context like the integrator object, the component model, the index of the component model, the current time and so on. Please refer to the [`ComponentAffect`](@ref) docstring for a detailed list.
 
-Lastly we need to define the actuall callback object using [`ContinousComponentCallback`](@ref)/[`VectorContinousComponentCallback`](@ref):
+Lastly we need to define the actual callback object using [`ContinuousComponentCallback`](@ref)/[`VectorContinuousComponentCallback`](@ref):
 ```julia
 ccb  = ContinousComponentCallback(condition, affect; kwargs...)
 vccb = VectorContinousComponentCallback(condition, affect; kwargs...)
@@ -101,14 +101,14 @@ prob = ODEProblem(nw, uflat(u0), (0,10), pflat(u0); callback=cbs)
 sol = solve(prob, ...)
 ```
 
-When combining the component based callbacks to a single callback, NetworkDynamics will check whether states and or parameters changed during the affect and automaticially call [`SciMLBase.auto_dt_reset!`](@extref) and [`save_parameters!`](@ref) if necessary.
+When combining the component based callbacks to a single callback, NetworkDynamics will check whether states and or parameters changed during the affect and automatically call [`SciMLBase.auto_dt_reset!`](@extref) and [`save_parameters!`](@ref) if necessary.
 
 
 ## Normal DiffEq Callbacks
 Besides component based callbacks, it is also possible to use "normal" DiffEq
 callbacks together with `NetworkDynamics.jl`.
 It is far more powerful but also more cumbersome compared to the component based callback functions.
-To access states and parameters of specific components, we havily rely on the [Symbolic Indexing](@ref) features.
+To access states and parameters of specific components, we heavily rely on the [Symbolic Indexing](@ref) features.
 
 ```julia
 using SymbolicIndexingInterface as SII
@@ -134,7 +134,7 @@ Please note a few important things here:
 
 ```julia
 function affect!(integrator, vidx)
-    p = NWParameter(integrator) # get symbolicially indexable parameter object
+    p = NWParameter(integrator) # get symbolically indexable parameter object
     p.v[vidx, :some_vertex_parameter] = 0 # change some parameter
     auto_dt_reset!(integrator)
     save_parameters!(integrator)
@@ -159,4 +159,4 @@ Once the `condition` and `affect!` is defined, you can use the [`SciMLBase.Conti
     To extract or plot timeseries of observed states under *time variant
     parameters* (i.e. parameters that are changed in a callback), those changes
     need to be recorded using the [`save_parameters!`](@ref) function whenever `p` is changed.
-    When using [ComponentCallback](@ref NetworkDynamics.ComponentCallback), NetworkDynamics will automaticially check for changes in `p` and save them if necessary.
+    When using [ComponentCallback](@ref NetworkDynamics.ComponentCallback), NetworkDynamics will automatically check for changes in `p` and save them if necessary.

src/callbacks.jl

@@ -6,12 +6,12 @@ bundles a [`ComponentCondition`](@ref) as well as a [`ComponentAffect`](@ref)
 which can be then tied to a component model using [`add_callback!`](@ref) or
 [`set_callback!`](@ref).
 
-On a Network level, you can automaticially create network wide `CallbackSet`s using
+On a Network level, you can automatically create network wide `CallbackSet`s using
 [`get_callbacks`](@ref).
 
 See
 [`ContinousComponentCallback`](@ref) and [`VectorContinousComponentCallback`](@ref) for concrete
-implemenations of this abstract type.
+implementations of this abstract type.
 """
 abstract type ComponentCallback end
 
@@ -20,25 +20,25 @@ abstract type ComponentCallback end
 
 Creates a callback condition for a [`ComponentCallback`].
 - `f`: The condition function. Must be a function of the form `out=f(u, p, t)`
-  when used for [`ContinousComponentCallback`](@ref) or
+  when used for [`ContinuousComponentCallback`](@ref) or
   [`DiscreteComponentCallback`](@ref) and `f!(out, u, p, t)` when used for
-  [`VectorContinousComponentCallback`](@ref).
+  [`VectorContinuousComponentCallback`](@ref).
   - Arguments of `f`
-    - `u`: The current value of the selecte `sym` states, provided as a [`SymbolicView`](@ref) object.
+    - `u`: The current value of the selected `sym` states, provided as a [`SymbolicView`](@ref) object.
     - `p`: The current value of the selected `psym` parameters.
     - `t`: The current simulation time.
 - `sym`: A vector or tuple of symbols, which represent **states** (including
   inputs, outputs, observed) of the component model. Determines, which states will
-  be available thorugh parameter `u` in the callback condition function `f`.
-- `psym`: A vector or tuple of symbols, which represetn **parameters** of the component mode.
+  be available through parameter `u` in the callback condition function `f`.
+- `psym`: A vector or tuple of symbols, which represent **parameters** of the component mode.
   Determines, which parameters will be available in the condition function `f`
 
 # Example
 Consider a component model with states `[:u1, :u2]`, inputs `[:i]`, outputs
 `[:o]` and parameters `[:p1, :p2]`.
 
     ComponentCondition([:u1, :o], [:p1]) do u, p, t
-        # access states symbolicially or via int index
+        # access states symbolically or via int index
         u[:u1] == u[1]
         u[:o] == u[2]
         p[:p1] == p[1]
@@ -63,8 +63,8 @@ Creates a callback condition for a [`ComponentCallback`].
   is only available in [`VectorContinousComponentCallback`](@ref).
   - Arguments of `f`
     - `u`: The current (mutable) value of the selected `sym` states, provided as a [`SymbolicView`](@ref) object.
-    - `p`: The current (mutalbe) value of the selected `psym` parameters.
-    - `event_idx`: The current event index, i.e. which `out` element triggerd in case of [`VectorContinousComponentCallback`](@ref).
+    - `p`: The current (mutable) value of the selected `psym` parameters.
+    - `event_idx`: The current event index, i.e. which `out` element triggered in case of [`VectorContinuousComponentCallback`](@ref).
     - `ctx::NamedTuple` a named tuple with context variables.
        - `ctx.model`: a referenc to the ocmponent model
        - `ctx.vidx`/`ctx.eidx`: The index of the vertex/edge model.
@@ -73,8 +73,8 @@ Creates a callback condition for a [`ComponentCallback`].
        - `ctx.t=ctx.integrator.t`: The current simulation time.
 - `sym`: A vector or tuple of symbols, which represent **states** (**excluding**
   inputs, outputs, observed) of the component model. Determines, which states will
-  be available thorugh parameter `u` in the callback condition function `f`.
-- `psym`: A vector or tuple of symbols, which represetn **parameters** of the component mode.
+  be available through parameter `u` in the callback condition function `f`.
+- `psym`: A vector or tuple of symbols, which represent **parameters** of the component mode.
   Determines, which parameters will be available in the condition function `f`
 
 # Example
@@ -97,36 +97,36 @@ struct ComponentAffect{A,DIM,PDIM}
 end
 
 """
-    ContinousComponentCallback(condition, affect; kwargs...)
+    ContinuousComponentCallback(condition, affect; kwargs...)
 
-Connect a [`ComponentCondition`](@ref) and a [`ComponentAffect`)[@ref] to a
-continous callback which can be attached to a component model using
+Connect a [`ComponentCondition`](@ref) and a [`ComponentAffect`](@ref) to a
+continuous callback which can be attached to a component model using
 [`add_callback!`](@ref) or [`set_callback!`](@ref).
 
 The `kwargs` will be forwarded to the `VectorContinuousCallback` when the component based
 callbacks are collected for the whole network using `get_callbacks`.
 [`DiffEq.jl docs`](https://docs.sciml.ai/DiffEqDocs/stable/features/callback_functions/)
 for available options.
 """
-struct ContinousComponentCallback{C,A,CDIM,CPDIM,ADIM,APDIM} <: ComponentCallback
+struct ContinuousComponentCallback{C,A,CDIM,CPDIM,ADIM,APDIM} <: ComponentCallback
     condition::ComponentCondition{C,CDIM,CPDIM}
     affect::ComponentAffect{A,ADIM,APDIM}
     kwargs::NamedTuple
 end
-function ContinousComponentCallback(condition, affect; kwargs...)
+function ContinuousComponentCallback(condition, affect; kwargs...)
     if haskey(kwargs, :affect_neg!)
         throw(ArgumentError("affect_neg! not supported yet. Please raise issue."))
     end
-    ContinousComponentCallback(condition, affect, NamedTuple(kwargs))
+    ContinuousComponentCallback(condition, affect, NamedTuple(kwargs))
 end
 
 """
-    VectorContinousComponentCallback(condition, affect, len; kwargs...)
+    VectorContinuousComponentCallback(condition, affect, len; kwargs...)
 
-Connect a [`ComponentCondition`](@ref) and a [`ComponentAffect`)[@ref] to a
-continous callback which can be attached to a component model using
+Connect a [`ComponentCondition`](@ref) and a [`ComponentAffect`](@ref) to a
+continuous callback which can be attached to a component model using
 [`add_callback!`](@ref) or [`set_callback!`](@ref). This vector version allows
-for `condions` which have `len` output dimensions.
+for `conditions` which have `len` output dimensions.
 The `affect` will be triggered with the additional `event_idx` argument to know in which
 dimension the zerocrossing was detected.
 
@@ -135,13 +135,13 @@ callbacks are collected for the whole network using [`get_callbacks(::Network)`]
 [`DiffEq.jl docs`](https://docs.sciml.ai/DiffEqDocs/stable/features/callback_functions/)
 for available options.
 """
-struct VectorContinousComponentCallback{C,A,CDIM,CPDIM,ADIM,APDIM} <: ComponentCallback
+struct VectorContinuousComponentCallback{C,A,CDIM,CPDIM,ADIM,APDIM} <: ComponentCallback
     condition::ComponentCondition{C,CDIM,CPDIM}
     affect::ComponentAffect{A,ADIM,APDIM}
     len::Int
     kwargs::NamedTuple
 end
-function VectorContinousComponentCallback(condition, affect, len; kwargs...)
+function VectorContinuousComponentCallback(condition, affect, len; kwargs...)
     if haskey(kwargs, :affect_neg!)
         throw(ArgumentError("affect_neg! not supported yet. Please raise issue."))
     end
@@ -151,7 +151,7 @@ end
 """
     DiscreteComponentCallback(condition, affect; kwargs...)
 
-Connect a [`ComponentCondition`](@ref) and a [`ComponentAffect`)[@ref] to a
+Connect a [`ComponentCondition`](@ref) and a [`ComponentAffect`](@ref) to a
 discrete callback which can be attached to a component model using
 [`add_callback!`](@ref) or [`set_callback!`](@ref).
 
@@ -175,7 +175,7 @@ end
 """
     PresetTimeComponentCallback(ts, affect; kwargs...)
 
-Tirgger a [`ComponentAffect`](@ref) at given timesteps `ts` in discrete
+Trigger a [`ComponentAffect`](@ref) at given timesteps `ts` in discrete
 callback, which can be attached to a component model using
 [`add_callback!`](@ref) or [`set_callback!`](@ref).
 
@@ -209,21 +209,21 @@ function get_callbacks(nw::Network)
     elseif length(cbbs) == 1
         return to_callback(only(cbbs))
     else
-        # we split in discrete and continous manually, otherwise the CallbackSet
+        # we split in discrete and continuous manually, otherwise the CallbackSet
         # construction can take forever
         discrete_cb = []
-        continous_cb = []
+        continuous_cb = []
         for batch in cbbs
             cb = to_callback(batch)
             if cb isa SciMLBase.AbstractContinuousCallback
-                push!(continous_cb, cb)
+                push!(continuous_cb, cb)
             elseif cb isa SciMLBase.AbstractDiscreteCallback
                 push!(discrete_cb, cb)
             else
                 error("Unknown callback type, should never be reached. Please report this issue.")
             end
         end
-        CallbackSet(Tuple(continous_cb), Tuple(discrete_cb));
+        CallbackSet(Tuple(continuous_cb), Tuple(discrete_cb));
     end
 end
 
@@ -333,7 +333,7 @@ function collect_c_or_a_indices(cw::CallbackWrapper, c_or_a, u_or_p)
 end
 
 ####
-#### wrapping of continous callbacks
+#### wrapping of continuous callbacks
 ####
 struct ContinousCallbackWrapper{T<:ComponentCallback,C,ST<:SymbolicIndex} <: CallbackWrapper
     nw::Network