fix spelling mistakes

Author: hexaeder

NEWS.md

@@ -6,6 +6,7 @@
   - 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
+  - **Fixed spelling**: `ContinousComponentCallback` → `ContinuousComponentCallback` and `VectorContinousComponentCallback` → `VectorContinuousComponentCallback` (old names maintained as deprecated aliases for backward compatibility)
 
 ## v0.10.2 Changelog
 - [#299](https://github.com/JuliaDynamics/NetworkDynamics.jl/pull/299) enhance metadata system with pattern matching and utility functions:

NetworkDynamicsInspector/test/runtests.jl

@@ -44,7 +44,7 @@ function get_sol(;limit=1.0)
         @info "Trip line $(ctx.eidx) between $(ctx.src) and $(ctx.dst) at t=$(ctx.t)"
         p[:active] = 0
     end
-    cb = ContinousComponentCallback(cond, affect)
+    cb = ContinuousComponentCallback(cond, affect)
     set_callback!.(ls, Ref(cb))
 
     tripfirst = PresetTimeComponentCallback(1.0, affect) # reuse the same affect

docs/examples/cascading_failure.jl

@@ -108,7 +108,7 @@ affect = ComponentAffect([], [:K]) do u, p, ctx
     println("Line $(ctx.eidx) tripped at t=$(ctx.integrator.t)")
     p[:K] = 0
 end
-edge_cb = ContinousComponentCallback(cond, affect)
+edge_cb = ContinuousComponentCallback(cond, affect)
 #=
 To enable the callback in simulation, we need to attach them to the individual
 edgemodels/vertexmodels.
@@ -155,14 +155,14 @@ plot(sol; idxs=eidxs(sol, :, :P))
 ## System wide Callbacks
 
 The above solution relies on the `ComponentCallback` features of
-NetworkDyanmics. The "low-level" API would be to use `VectorContinousCallback`
+NetworkDynamics. The "low-level" API would be to use `VectorContinuousCallback`
 and `PresetTimeCallback` directly to achieve the same effect, essentially doing
 manually what [`get_callbacks(::Network)`](@ref) is doing for us.
 
-While not necessary in this case, this method offers more flexiblity then the
-component based appraoch.
+While not necessary in this case, this method offers more flexibility than the
+component based approach.
 
-In order to implement the line failures, we need to create a `VectorContinousCallback`.
+In order to implement the line failures, we need to create a `VectorContinuousCallback`.
 In the callback, we compare the current flow on the line with the limit. If the limit is reached,
 the coupling `K` is set to 0.
 

docs/src/callbacks.md

@@ -24,10 +24,10 @@ specific component or type of component. `NetworkDynamics.jl` provides a way of
 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),
-[`VectorContinousComponentCallback`](@ref) and [`DiscreteComponentCallback`](@ref). All of those objects combine a [`ComponentCondition`](@ref) with an [`ComponentAffect`](@ref).
+The main entry points are the types [`ContinuousComponentCallback`](@ref),
+[`VectorContinuousComponentCallback`](@ref) and [`DiscreteComponentCallback`](@ref). All of those objects combine a [`ComponentCondition`](@ref) with an [`ComponentAffect`](@ref).
 
-The "normal" [`ContinousComponentCallback`](@ref) and [`DiscreteComponentCallback`](@ref) have a condition which returns a single value. The corresponding affect is triggered when the return value hits zero.
+The "normal" [`ContinuousComponentCallback`](@ref) and [`DiscreteComponentCallback`](@ref) have a condition which returns a single value. The corresponding affect is triggered when the return value hits zero.
 In contrast, the "vector" version has an in-place condition which writes `len` outputs. When any of those outputs hits zero, the affect is triggered with an additional argument `event_idx` which tells the effect which dimension encountered the zerocrossing.
 
 There is a special type [`PresetTimeComponentCallback`](@ref) which has no explicit condition and triggers the affect at given times.
@@ -43,7 +43,7 @@ condition = ComponentCond([:x, :y], [:p1, :p2]) do u, p, t
     return some_condition(u[:x], u[:y], ...)
 end
 ```
-In case of a `VectorContinousComponentCallback`, the function signature looks slightly different:
+In case of a `VectorContinuousComponentCallback`, the function signature looks slightly different:
 ```julia
 vectorcondition = ComponentCond([:x, :y], [:p1, :p2]) do out, u, p, t
     out[1] = some_condition(u[...], p[...])
@@ -77,8 +77,8 @@ However the affect gets passed a `ctx` "context" object, which is a named tuple
 
 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...)
+ccb  = ContinuousComponentCallback(condition, affect; kwargs...)
+vccb = VectorContinuousComponentCallback(condition, affect; kwargs...)
 ```
 where the `kwargs` are passed to the underlying [`SciMLBase.VectorContinuousCallback`](@extref) to finetune the zerocrossing-detection.
 

docs/src/inspector.md

@@ -46,7 +46,7 @@ First, we need to define the system we want to inspect.
             @info "Trip line $(ctx.eidx) between $(ctx.src) and $(ctx.dst) at t=$(ctx.t)"
             p[:active] = 0
         end
-        cb = ContinousComponentCallback(cond, affect)
+        cb = ContinuousComponentCallback(cond, affect)
         set_callback!.(ls, Ref(cb))
 
         tripfirst = PresetTimeComponentCallback(1.0, affect) # reuse the same affect

src/NetworkDynamics.jl

@@ -69,6 +69,7 @@ export variable_symbols, parameter_symbols
 include("symbolicindexing.jl")
 
 export ComponentCondition, ComponentAffect
+# Export deprecated aliases (constants defined at bottom of callbacks.jl)
 export ContinousComponentCallback, VectorContinousComponentCallback
 export DiscreteComponentCallback, PresetTimeComponentCallback
 export SymbolicView

src/callbacks.jl

@@ -10,7 +10,7 @@ On a Network level, you can automatically create network wide `CallbackSet`s usi
 [`get_callbacks`](@ref).
 
 See
-[`ContinousComponentCallback`](@ref) and [`VectorContinousComponentCallback`](@ref) for concrete
+[`ContinuousComponentCallback`](@ref) and [`VectorContinuousComponentCallback`](@ref) for concrete
 implementations of this abstract type.
 """
 abstract type ComponentCallback end
@@ -60,13 +60,13 @@ end
 
 Creates a callback condition for a [`ComponentCallback`].
 - `f`: The affect function. Must be a function of the form `f(u, p, [event_idx], ctx)` where `event_idx`
-  is only available in [`VectorContinousComponentCallback`](@ref).
+  is only available in [`VectorContinuousComponentCallback`](@ref).
   - Arguments of `f`
     - `u`: The current (mutable) value of the selected `sym` states, provided as a [`SymbolicView`](@ref) object.
     - `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.model`: a reference to the component model
        - `ctx.vidx`/`ctx.eidx`: The index of the vertex/edge model.
        - `ctx.src`/`ctx.dst`: src and dst indices (only for edge models).
        - `ctx.integrator`: The integrator object. Use [`extract_nw`](@ref) to obtain the network.
@@ -145,7 +145,7 @@ function VectorContinuousComponentCallback(condition, affect, len; kwargs...)
     if haskey(kwargs, :affect_neg!)
         throw(ArgumentError("affect_neg! not supported yet. Please raise issue."))
     end
-    VectorContinousComponentCallback(condition, affect, len, NamedTuple(kwargs))
+    VectorContinuousComponentCallback(condition, affect, len, NamedTuple(kwargs))
 end
 
 """
@@ -254,8 +254,8 @@ function wrap_component_callbacks(nw)
     for typeidx in idx_per_type
         batchcomps = components[typeidx]
         batchcbs = callbacks[typeidx]
-        if first(batchcbs) isa Union{ContinousComponentCallback, VectorContinousComponentCallback}
-            cb = ContinousCallbackWrapper(nw, batchcomps, batchcbs)
+        if first(batchcbs) isa Union{ContinuousComponentCallback, VectorContinuousComponentCallback}
+            cb = ContinuousCallbackWrapper(nw, batchcomps, batchcbs)
         elseif first(batchcbs) isa DiscreteComponentCallback
             cb = DiscreteCallbackWrapper(nw, batchcomps, batchcbs)
         elseif first(batchcbs) isa PresetTimeComponentCallback
@@ -270,12 +270,12 @@ function wrap_component_callbacks(nw)
     return batches
 end
 _batchequal(a, b) = false
-function _batchequal(a::ContinousComponentCallback, b::ContinousComponentCallback)
+function _batchequal(a::ContinuousComponentCallback, b::ContinuousComponentCallback)
     _batchequal(a.condition, b.condition) || return false
     _batchequal(a.kwargs, b.kwargs)       || return false
     return true
 end
-function _batchequal(a::VectorContinousComponentCallback, b::VectorContinousComponentCallback)
+function _batchequal(a::VectorContinuousComponentCallback, b::VectorContinuousComponentCallback)
     _batchequal(a.condition, b.condition) || return false
     _batchequal(a.kwargs, b.kwargs)       || return false
     a.len == b.len                       || return false
@@ -335,40 +335,40 @@ end
 ####
 #### wrapping of continuous callbacks
 ####
-struct ContinousCallbackWrapper{T<:ComponentCallback,C,ST<:SymbolicIndex} <: CallbackWrapper
+struct ContinuousCallbackWrapper{T<:ComponentCallback,C,ST<:SymbolicIndex} <: CallbackWrapper
     nw::Network
     components::Vector{ST}
     callbacks::Vector{T}
     sublen::Int # length of each callback
     condition::C
 end
-function ContinousCallbackWrapper(nw, components, callbacks)
+function ContinuousCallbackWrapper(nw, components, callbacks)
     if !isconcretetype(eltype(components))
         components = [c for c in components]
     end
     if !isconcretetype(eltype(callbacks))
         callbacks = [cb for cb in callbacks]
     end
-    sublen = eltype(callbacks) <: ContinousComponentCallback ? 1 : first(callbacks).len
+    sublen = eltype(callbacks) <: ContinuousComponentCallback ? 1 : first(callbacks).len
     condition = first(callbacks).condition.f
-    ContinousCallbackWrapper(nw, components, callbacks, sublen, condition)
+    ContinuousCallbackWrapper(nw, components, callbacks, sublen, condition)
 end
 
 # Continuous-specific functions (for vector callbacks)
-condition_outrange(ccw::ContinousCallbackWrapper, i) = (1 + (i-1)*ccw.sublen) : i*ccw.sublen
+condition_outrange(ccw::ContinuousCallbackWrapper, i) = (1 + (i-1)*ccw.sublen) : i*ccw.sublen
 
-cbidx_from_outidx(ccw::ContinousCallbackWrapper, outidx) = div(outidx-1, ccw.sublen) + 1
-subidx_from_outidx(ccw::ContinousCallbackWrapper, outidx) = mod(outidx, 1:ccw.sublen)
+cbidx_from_outidx(ccw::ContinuousCallbackWrapper, outidx) = div(outidx-1, ccw.sublen) + 1
+subidx_from_outidx(ccw::ContinuousCallbackWrapper, outidx) = mod(outidx, 1:ccw.sublen)
 
-# generate VectorContinuousCallback from a ContinousCallbackWrapper
-function to_callback(ccw::ContinousCallbackWrapper)
+# generate VectorContinuousCallback from a ContinuousCallbackWrapper
+function to_callback(ccw::ContinuousCallbackWrapper)
     kwargs = first(ccw.callbacks).kwargs
     cond = _batch_condition(ccw)
     affect = _batch_affect(ccw)
     len = ccw.sublen * length(ccw.callbacks)
     VectorContinuousCallback(cond, affect, len; kwargs...)
 end
-function _batch_condition(ccw::ContinousCallbackWrapper)
+function _batch_condition(ccw::ContinuousCallbackWrapper)
     usymidxs = collect_c_or_a_indices(ccw, :condition, :sym)
     psymidxs = collect_c_or_a_indices(ccw, :condition, :psym)
     ucache = DiffCache(zeros(length(usymidxs)), 12)
@@ -396,10 +396,10 @@ function _batch_condition(ccw::ContinousCallbackWrapper)
             pv = view(integrator.p, pidxsv)
             _p = SymbolicView(pv, ccw.callbacks[i].condition.psym)
 
-            if cbtype(ccw) <: ContinousComponentCallback
+            if cbtype(ccw) <: ContinuousComponentCallback
                 oidx = only(condition_outrange(ccw, i))
                 out[oidx] = ccw.condition(_u, _p, t)
-            elseif cbtype(ccw) <: VectorContinousComponentCallback
+            elseif cbtype(ccw) <: VectorContinuousComponentCallback
                 @views _out = out[condition_outrange(ccw, i)]
                 ccw.condition(_out, _u, _p, t)
             else
@@ -409,7 +409,7 @@ function _batch_condition(ccw::ContinousCallbackWrapper)
         nothing
     end
 end
-function _batch_affect(ccw::ContinousCallbackWrapper)
+function _batch_affect(ccw::ContinuousCallbackWrapper)
     usymidxs = collect_c_or_a_indices(ccw, :affect, :sym)
     psymidxs = collect_c_or_a_indices(ccw, :affect, :psym)
 
@@ -449,9 +449,9 @@ function _batch_affect(ccw::ContinousCallbackWrapper)
 
         uhash = hash(uv)
         phash = hash(pv)
-        if cbtype(ccw) <: ContinousComponentCallback
+        if cbtype(ccw) <: ContinuousComponentCallback
             ccw.callbacks[i].affect.f(_u, _p, ctx)
-        elseif cbtype(ccw) <: VectorContinousComponentCallback
+        elseif cbtype(ccw) <: VectorContinuousComponentCallback
             num = subidx_from_outidx(ccw, outidx)
             ccw.callbacks[i].affect.f(_u, _p, num, ctx)
         else
@@ -710,3 +710,9 @@ function assert_cb_compat(comp::ComponentModel, cb)
     end
     cb
 end
+
+####
+#### Backward compatibility aliases for old misspellings (deprecated)
+####
+const ContinousComponentCallback = ContinuousComponentCallback
+const VectorContinousComponentCallback = VectorContinuousComponentCallback

src/show.jl

@@ -443,7 +443,7 @@ function Base.show(io::IO, ::MIME"text/plain", @nospecialize(cb::ComponentCallba
     print(io, basename)
     print(io, "(")
     print(io, shortrepr(cb))
-    if cb isa VectorContinousComponentCallback
+    if cb isa VectorContinuousComponentCallback
         print(io, ", len=", cb.len)
     end
     print(io, ")")

test/callbacks_test.jl

@@ -30,7 +30,7 @@ function basenetwork()
     nw
 end
 
-@testset "continous callback batch tests" begin
+@testset "continuous callback batch tests" begin
     nw = basenetwork()
 
     tript = Float64[]
@@ -44,7 +44,7 @@ end
         push!(tripi, ctx.eidx)
         p[:active] = 0
     end
-    cb = ContinousComponentCallback(cond, affect)
+    cb = ContinuousComponentCallback(cond, affect)
     set_callback!.(nw.im.edgem, Ref(cb))
 
     batches = NetworkDynamics.wrap_component_callbacks(nw);
@@ -110,12 +110,12 @@ end
 
     cond = ComponentCondition(identity, [:θ, :ω], [])
     affect = ComponentAffect(identity, [:θ, :ω],[])
-    cb = VectorContinousComponentCallback(cond, affect, 2)
+    cb = VectorContinuousComponentCallback(cond, affect, 2)
     add_callback!(v, cb)
     display(v)
     cond = ComponentCondition(identity, [:θ], [])
     affect = ComponentAffect(identity, [],[:M])
-    cb2 = ContinousComponentCallback(cond, affect)
+    cb2 = ContinuousComponentCallback(cond, affect)
     add_callback!(v, cb2)
     display(v)
     display(nw)
@@ -138,7 +138,7 @@ end
         push!(events, (;θ=u[:θ], ω=u[:ω], t=ctx.t, vidx=ctx.vidx, event_idx=event_idx))
         @info "Triggered event_idx $event_idx t=$(ctx.t) on $(ctx.vidx)"
     end
-    ccb = VectorContinousComponentCallback(cond, affect, 2)
+    ccb = VectorContinuousComponentCallback(cond, affect, 2)
     set_callback!(nw.im.vertexm[1], ccb)
     set_callback!(nw.im.vertexm[2], ccb)
 
@@ -199,7 +199,7 @@ end
     # invalid obs in affect u
     cond = ComponentCondition((args...)->nothing, [:P, :₋P, :srcθ, :limit], [:limit, :K])
     affect = ComponentAffect((args...)->nothing, [:₋P],[:active])
-    cb = ContinousComponentCallback(cond, affect)
+    cb = ContinuousComponentCallback(cond, affect)
     set_callback!.(nw.im.edgem, Ref(cb); check=false);
     cbb = only(NetworkDynamics.wrap_component_callbacks(nw));
     # oserved can handle parameters now!
@@ -209,7 +209,7 @@ end
     # invalid state in condition p
     cond = ComponentCondition((args...)->nothing, [:P, :₋P, :srcθ], [:limit, :K, :P])
     affect = ComponentAffect((args...)->nothing, [],[:active, :₋P])
-    cb = ContinousComponentCallback(cond, affect)
+    cb = ContinuousComponentCallback(cond, affect)
     set_callback!.(nw.im.edgem, Ref(cb); check=false);
     cbb = only(NetworkDynamics.wrap_component_callbacks(nw));
     @test_throws ArgumentError NetworkDynamics._batch_condition(cbb)
@@ -218,19 +218,19 @@ end
     # test on set_callback
     cond = ComponentCondition((args...)->nothing, [:P, :₋P, :srcθ, :limit], [:limit, :K])
     affect = ComponentAffect((args...)->nothing, [],[:active])
-    cb = ContinousComponentCallback(cond, affect)
+    cb = ContinuousComponentCallback(cond, affect)
     @test_throws ArgumentError set_callback!(nw.im.edgem[1], cb)
     cond = ComponentCondition((args...)->nothing, [:P, :₋P, :srcθ], [:limit, :K, :P])
     affect = ComponentAffect((args...)->nothing, [],[:active])
-    cb = ContinousComponentCallback(cond, affect)
+    cb = ContinuousComponentCallback(cond, affect)
     @test_throws ArgumentError set_callback!(nw.im.edgem[1], cb)
     cond = ComponentCondition((args...)->nothing, [:P, :₋P, :srcθ], [:limit, :K])
     affect = ComponentAffect((args...)->nothing, [:₋P],[:active])
-    cb = ContinousComponentCallback(cond, affect)
+    cb = ContinuousComponentCallback(cond, affect)
     @test_throws ArgumentError set_callback!(nw.im.edgem[1], cb)
     cond = ComponentCondition((args...)->nothing, [:P, :₋P, :srcθ], [:limit, :K])
     affect = ComponentAffect((args...)->nothing, [],[:active, :P])
-    cb = ContinousComponentCallback(cond, affect)
+    cb = ContinuousComponentCallback(cond, affect)
     @test_throws ArgumentError set_callback!(nw.im.edgem[1], cb)
 end
 

test/metadata_test.jl

@@ -214,15 +214,15 @@ end
     @test get_marker(nw, VIndex(1)) == :circle
 
     # Test callbacks
-    cb = ContinousComponentCallback(
+    cb = ContinuousComponentCallback(
         ComponentCondition(nothing, [], []),
         ComponentAffect(nothing, [], [])
     )
     set_callback!(nw, VIndex(1), cb)
     @test has_callback(nw, VIndex(1))
     @test get_callbacks(nw, VIndex(1)) == (cb,)
 
-    cb2 = ContinousComponentCallback(
+    cb2 = ContinuousComponentCallback(
         ComponentCondition(nothing, [], []),
         ComponentAffect(nothing, [], [])
     )