format

Author: ChrisRackauckas

docs/pages.jl

@@ -3,5 +3,5 @@
 pages = [
     "Home" => "index.md",
     "array_types.md",
-    "recursive_array_functions.md",
+    "recursive_array_functions.md"
 ]

ext/RecursiveArrayToolsFastBroadcastExt.jl

@@ -4,13 +4,17 @@ using RecursiveArrayTools
 using FastBroadcast
 using StaticArraysCore
 
-const AbstractVectorOfSArray = AbstractVectorOfArray{T,N,<:AbstractVector{<:StaticArraysCore.SArray}} where {T,N}
+const AbstractVectorOfSArray = AbstractVectorOfArray{
+    T, N, <:AbstractVector{<:StaticArraysCore.SArray}} where {T, N}
 
-@inline function FastBroadcast.fast_materialize!(::FastBroadcast.Static.False, ::DB, dst::AbstractVectorOfSArray, bc::Broadcast.Broadcasted{S}) where {S,DB}
+@inline function FastBroadcast.fast_materialize!(
+        ::FastBroadcast.Static.False, ::DB, dst::AbstractVectorOfSArray,
+        bc::Broadcast.Broadcasted{S}) where {S, DB}
     if FastBroadcast.use_fast_broadcast(S)
         for i in 1:length(dst.u)
             unpacked = RecursiveArrayTools.unpack_voa(bc, i)
-            dst.u[i] = StaticArraysCore.similar_type(dst.u[i])(unpacked[j] for j in eachindex(unpacked))
+            dst.u[i] = StaticArraysCore.similar_type(dst.u[i])(unpacked[j]
+            for j in eachindex(unpacked))
         end
     else
         Broadcast.materialize!(dst, bc)

ext/RecursiveArrayToolsMeasurementsExt.jl

@@ -4,7 +4,7 @@ import RecursiveArrayTools
 isdefined(Base, :get_extension) ? (import Measurements) : (import ..Measurements)
 
 function RecursiveArrayTools.recursive_unitless_bottom_eltype(a::Type{
-    <:Measurements.Measurement,
+        <:Measurements.Measurement,
 })
     typeof(oneunit(a))
 end

ext/RecursiveArrayToolsMonteCarloMeasurementsExt.jl

@@ -5,13 +5,13 @@ isdefined(Base, :get_extension) ? (import MonteCarloMeasurements) :
 (import ..MonteCarloMeasurements)
 
 function RecursiveArrayTools.recursive_unitless_bottom_eltype(a::Type{
-    <:MonteCarloMeasurements.Particles,
+        <:MonteCarloMeasurements.Particles,
 })
     typeof(one(a))
 end
 
 function RecursiveArrayTools.recursive_unitless_eltype(a::Type{
-    <:MonteCarloMeasurements.Particles,
+        <:MonteCarloMeasurements.Particles,
 })
     typeof(one(a))
 end

ext/RecursiveArrayToolsReverseDiffExt.jl

@@ -5,13 +5,13 @@ using ReverseDiff
 using Zygote: @adjoint
 
 function trackedarraycopyto!(dest, src)
-        for (i, slice) in zip(eachindex(dest.u), eachslice(src, dims=ndims(src)))
-            if dest.u[i] isa AbstractArray
-                dest.u[i] = reshape(reduce(vcat, slice), size(dest.u[i]))
-            else
-                trackedarraycopyto!(dest.u[i], slice)
-            end
+    for (i, slice) in zip(eachindex(dest.u), eachslice(src, dims = ndims(src)))
+        if dest.u[i] isa AbstractArray
+            dest.u[i] = reshape(reduce(vcat, slice), size(dest.u[i]))
+        else
+            trackedarraycopyto!(dest.u[i], slice)
         end
+    end
 end
 
 @adjoint function Array(VA::AbstractVectorOfArray{<:ReverseDiff.TrackedReal})

ext/RecursiveArrayToolsTrackerExt.jl

@@ -4,12 +4,12 @@ import RecursiveArrayTools
 isdefined(Base, :get_extension) ? (import Tracker) : (import ..Tracker)
 
 function RecursiveArrayTools.recursivecopy!(b::AbstractArray{T, N},
-    a::AbstractArray{T2, N}) where {
-    T <:
-    Tracker.TrackedArray,
-    T2 <:
-    Tracker.TrackedArray,
-    N}
+        a::AbstractArray{T2, N}) where {
+        T <:
+        Tracker.TrackedArray,
+        T2 <:
+        Tracker.TrackedArray,
+        N}
     @inbounds for i in eachindex(a)
         b[i] = copy(a[i])
     end