Package evaluation to test AutoGrad on Julia 1.14.0-DEV.3055 (7e75a8061a*) started at 2026-08-27T17:44:14.813 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Activating project at `~/.julia/environments/v1.14` Set-up completed after 15.55s ################################################################################ # Installation # Installing AutoGrad... Resolving package versions... Updating `~/.julia/environments/v1.14/Project.toml` [6710c13c] + AutoGrad v1.2.5 Updating `~/.julia/environments/v1.14/Manifest.toml` [6710c13c] + AutoGrad v1.2.5 [ffbed154] + DocStringExtensions v0.9.5 [e2ba6199] + ExprTools v0.1.11 [92d709cd] + IrrationalConstants v0.2.6 [692b3bcd] + JLLWrappers v1.8.0 [2ab3a3ac] + LogExpFunctions v1.0.1 [21216c6a] + Preferences v1.5.2 [276daf66] + SpecialFunctions v2.9.0 [10745b16] + Statistics v1.11.1 ⌅ [a759f4b9] + TimerOutputs v0.5.29 [efe28fd5] + OpenSpecFun_jll v0.5.6+0 [56f22d72] + Artifacts v1.11.0 [ade2ca70] + Dates v1.11.0 [8f399da3] + Libdl v1.11.0 [37e2e46d] + LinearAlgebra v1.14.0 [de0858da] + Printf v1.11.0 [fa267f1f] + TOML v1.0.3 [4ec0a83e] + Unicode v1.11.0 [e66e0078] + CompilerSupportLibraries_jll v1.5.7+0 [4536629a] + OpenBLAS_jll v0.3.34+0 [05823500] + OpenLibm_jll v0.8.7+0 [8e850b90] + libblastrampoline_jll v5.15.0+0 Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. To see why use `status --outdated -m` Installation completed after 2.67s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Precompiling package dependencies... Precompiling project... 11.8 s ✓ AutoGrad 1 dependency successfully precompiled in 14 seconds. 23 already precompiled. Precompilation completed after 37.06s ################################################################################ # Testing # Testing AutoGrad Status `/tmp/jl_zV3QAO/Project.toml` [6710c13c] AutoGrad v1.2.5 [276daf66] SpecialFunctions v2.9.0 [10745b16] Statistics v1.11.1 ⌅ [a759f4b9] TimerOutputs v0.5.29 [8f399da3] Libdl v1.11.0 [37e2e46d] LinearAlgebra v1.14.0 [9a3f8284] Random v1.11.0 [8dfed614] Test v1.11.0 Status `/tmp/jl_zV3QAO/Manifest.toml` [6710c13c] AutoGrad v1.2.5 [ffbed154] DocStringExtensions v0.9.5 [e2ba6199] ExprTools v0.1.11 [92d709cd] IrrationalConstants v0.2.6 [692b3bcd] JLLWrappers v1.8.0 [2ab3a3ac] LogExpFunctions v1.0.1 [21216c6a] Preferences v1.5.2 [276daf66] SpecialFunctions v2.9.0 [10745b16] Statistics v1.11.1 ⌅ [a759f4b9] TimerOutputs v0.5.29 [efe28fd5] OpenSpecFun_jll v0.5.6+0 [56f22d72] Artifacts v1.11.0 [2a0f44e3] Base64 v1.11.0 [ade2ca70] Dates v1.11.0 [b77e0a4c] InteractiveUtils v1.11.0 [ac6e5ff7] JuliaSyntaxHighlighting v1.13.0 [8f399da3] Libdl v1.11.0 [37e2e46d] LinearAlgebra v1.14.0 [56ddb016] Logging v1.11.0 [d6f4376e] Markdown v1.11.0 [de0858da] Printf v1.11.0 [9a3f8284] Random v1.11.0 [ea8e919c] SHA v1.13.0 [9e88b42a] Serialization v1.11.0 [f489334b] StyledStrings v1.13.0 [fa267f1f] TOML v1.0.3 [8dfed614] Test v1.11.0 [4ec0a83e] Unicode v1.11.0 [e66e0078] CompilerSupportLibraries_jll v1.5.7+0 [4536629a] OpenBLAS_jll v0.3.34+0 [05823500] OpenLibm_jll v0.8.7+0 [8e850b90] libblastrampoline_jll v5.15.0+0 Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. Testing Running tests... 169.113503 seconds (65.68 M allocations: 4.284 GiB, 1.59% gc time, 99.49% compilation time: 2% of which was recompilation) 30.219100 seconds (21.40 M allocations: 1.330 GiB, 2.26% gc time, 99.59% compilation time: 32% of which was recompilation) core: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:15 Test threw exception Expression: ∇(m, x, y) isa Dict MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float64}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Array{Float64}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Array{Float64}}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Vector{Float64}, xi::AutoGrad.Result{Vector{Float64}}, x::AutoGrad.Result{Vector{Array{Float64}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#loss#loss##0", ::Param{Dict{Symbol, Vector{Array{Float64}}}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Dict{Symbol, Vector{Array{Float64}}}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#loss#loss##0", Int64, Bool}})(::Dict{Symbol, Vector{Array{Float64}}}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#loss#loss##0", Int64, Bool}})(::Dict{Symbol, Vector{Array{Float64}}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/core.jl:7 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/core.jl:15 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] WARNING: Method definition loss(Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:12 overwritten at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:17. core: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:20 Test threw exception Expression: ∇(m, x, y) isa Dict MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float64}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Array{Float64}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Array{Float64}}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Vector{Float64}, xi::AutoGrad.Result{Vector{Float64}}, x::AutoGrad.Result{Vector{Array{Float64}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#loss#loss##0", ::Param{Dict{Symbol, Vector{Array{Float64}}}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Dict{Symbol, Vector{Array{Float64}}}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#loss#loss##0", Int64, Bool}})(::Dict{Symbol, Vector{Array{Float64}}}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#loss#loss##0", Int64, Bool}})(::Dict{Symbol, Vector{Array{Float64}}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/core.jl:7 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/core.jl:20 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] WARNING: Method definition pred(Any, Any) in module Main at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:11 overwritten at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:25. WARNING: Method definition loss(Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:17 overwritten at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:26. core: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:28 Test threw exception Expression: ∇(m, x, y) isa Array MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float64}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Array{Float64}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Array{Float64}}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Vector{Float64}, xi::AutoGrad.Result{Vector{Float64}}, x::Param{Vector{Array{Float64}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#loss#loss##0", ::Param{Vector{Array{Float64}}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Array{Float64}}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#loss#loss##0", Int64, Bool}})(::Vector{Array{Float64}}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#loss#loss##0", Int64, Bool}})(::Vector{Array{Float64}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/core.jl:7 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/core.jl:28 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] WARNING: Method definition loss(Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:26 overwritten at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:29. core: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:31 Test threw exception Expression: ∇(m, x, y) isa Array MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float64}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Array{Float64}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Array{Float64}}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Vector{Float64}, xi::AutoGrad.Result{Vector{Float64}}, x::Param{Vector{Array{Float64}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#loss#loss##0", ::Param{Vector{Array{Float64}}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Array{Float64}}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#loss#loss##0", Int64, Bool}})(::Vector{Array{Float64}}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#loss#loss##0", Int64, Bool}})(::Vector{Array{Float64}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/core.jl:7 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/core.jl:31 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] WARNING: Method definition f(Any) in module Main at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:47 overwritten at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:62. ┌ Warning: Output independent of params └ @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:159 WARNING: Method definition f(Any) in module Main at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:62 overwritten at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:67. WARNING: Method definition loss(Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:29 overwritten at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:86. core: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:4 Got exception outside of a @test MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Vector{Float64}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Vector{Float64}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Vector{Float64}}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Vector{Float64}, xi::AutoGrad.Result{Vector{Float64}}, x::Param{Vector{Vector{Float64}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#86#87"{Param{Vector{Vector{Float64}}}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/core.jl:7 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [13] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/core.jl:88 [inlined] 47.281427 seconds (17.33 M allocations: 1.065 GiB, 0.81% gc time, 97.61% compilation time: 2% of which was recompilation) Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float32, xi::AutoGrad.Result{Float32}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float32, xi::AutoGrad.Result{Float32}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float32, xi::AutoGrad.Result{Float32}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float32, xi::AutoGrad.Result{Float32}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float32, xi::AutoGrad.Result{Float32}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float32, xi::AutoGrad.Result{Float32}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] indexing: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:78 Test threw exception Expression: gradcheck(s1sum, t1) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float32, xi::AutoGrad.Result{Float32}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(f::var"#s0#s0##0", x::Param{Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}})(args::Vector{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}})(args::Vector{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [inlined] [13] (::var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}})(x::Vector{Any}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:71 [14] gcsum(f::var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, x::Vector{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Tuple{Float32, Float32, Nothing}, f0::Float32, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [17] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float32, var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [18] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float32, var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [19] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [20] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float32, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [21] (::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float32})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [22] _all(f::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float32}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [23] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [24] gradcheck(f::var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, x::Tuple{Float32, Float32, Float32}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [25] gradcheck(f::Function, x::Tuple{Float32, Float32, Float32}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [26] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [27] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [28] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [29] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:65 [inlined] [30] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [31] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:78 [inlined] [32] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] indexing: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:89 Test threw exception Expression: gradcheck(f1sum, t1) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float32, xi::AutoGrad.Result{Float32}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(f::var"#97#98", x::Param{Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}})(args::Vector{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}})(args::Vector{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [inlined] [13] (::var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}})(x::Vector{Any}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:83 [14] gcsum(f::var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, x::Vector{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Tuple{Float32, Float32, Float32}, f0::Float32, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [17] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float32, var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [18] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float32, var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [19] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [20] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float32, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [21] (::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float32})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [22] _all(f::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float32}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [23] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [24] gradcheck(f::var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, x::Tuple{Float32, Float32, Float32}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [25] gradcheck(f::Function, x::Tuple{Float32, Float32, Float32}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [26] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [27] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [28] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [29] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:65 [inlined] [30] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [31] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:89 [inlined] [32] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] indexing: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:100 Test threw exception Expression: gradcheck(r1sum, t1) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float32, xi::AutoGrad.Result{Float32}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(f::var"#r0#r0##0", x::Param{Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}})(args::Vector{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}})(args::Vector{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [inlined] [13] (::var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}})(x::Vector{Any}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:94 [14] gcsum(f::var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, x::Vector{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Tuple{Float32, Float32, Float32}, f0::Float32, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [17] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float32, var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [18] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float32, var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [19] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [20] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float32, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [21] (::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float32})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [22] _all(f::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float32}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [23] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [24] gradcheck(f::var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, x::Tuple{Float32, Float32, Float32}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [25] gradcheck(f::Function, x::Tuple{Float32, Float32, Float32}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [26] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [27] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [28] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [29] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:65 [inlined] [30] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [31] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:100 [inlined] [32] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] indexing: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:78 Test threw exception Expression: gradcheck(s1sum, t1) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(f::var"#s0#s0##0", x::Param{Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}})(args::Vector{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}})(args::Vector{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [inlined] [13] (::var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}})(x::Vector{Any}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:71 [14] gcsum(f::var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, x::Vector{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Tuple{Float64, Float64, Nothing}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [17] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [18] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [19] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [20] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [21] (::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float64})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [22] _all(f::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [23] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [24] gradcheck(f::var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, x::Tuple{Float64, Float64, Float64}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [25] gradcheck(f::Function, x::Tuple{Float64, Float64, Float64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [26] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [27] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [28] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [29] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:65 [inlined] [30] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [31] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:78 [inlined] [32] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] indexing: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:89 Test threw exception Expression: gradcheck(f1sum, t1) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(f::var"#97#98", x::Param{Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}})(args::Vector{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}})(args::Vector{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [inlined] [13] (::var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}})(x::Vector{Any}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:83 [14] gcsum(f::var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, x::Vector{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Tuple{Float64, Float64, Float64}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [17] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [18] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [19] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [20] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [21] (::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float64})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [22] _all(f::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [23] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [24] gradcheck(f::var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, x::Tuple{Float64, Float64, Float64}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [25] gradcheck(f::Function, x::Tuple{Float64, Float64, Float64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [26] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [27] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [28] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [29] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:65 [inlined] [30] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [31] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:89 [inlined] [32] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] indexing: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:100 Test threw exception Expression: gradcheck(r1sum, t1) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(f::var"#r0#r0##0", x::Param{Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}})(args::Vector{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}})(args::Vector{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [inlined] [13] (::var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}})(x::Vector{Any}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:94 [14] gcsum(f::var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, x::Vector{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Tuple{Float64, Float64, Float64}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [17] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [18] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [19] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [20] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [21] (::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float64})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [22] _all(f::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [23] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [24] gradcheck(f::var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, x::Tuple{Float64, Float64, Float64}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [25] gradcheck(f::Function, x::Tuple{Float64, Float64, Float64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [26] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [27] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [28] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [29] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:65 [inlined] [30] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [31] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:100 [inlined] [32] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] getindex: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:124 Test threw exception Expression: g1(a) == g2(a) MethodError: Cannot `convert` an object of type Tuple{Int64, Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64, Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64, Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64, Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float32}}})(::Nothing, d::Tuple{Int64, Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Matrix{Array{Float32}}, dxi::Vector{Float32}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Matrix{Array{Float32}}}, dxi::Vector{Float32}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Vector{Float32}, xi::AutoGrad.Result{Vector{Float32}}, x::Param{Matrix{Array{Float32}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(f::var"#109#110", x::Param{Matrix{Array{Float32}}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(f::Function, x::Param{Matrix{Array{Float32}}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#109#110", Int64, Bool}})(args::Matrix{Array{Float32}}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#109#110", Int64, Bool}})(args::Matrix{Array{Float32}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:124 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] 126.585731 seconds (45.52 M allocations: 2.777 GiB, 0.73% gc time, 98.44% compilation time) 24.408975 seconds (7.59 M allocations: 479.110 MiB, 0.81% gc time, 99.30% compilation time) iterate: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:34 Test threw exception Expression: gradcheck(itr1, warray; o...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float32, 3}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Array{Float32, 3}}, dxi::Array{Float64, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Array{Float32, 3}}}, dxi::Array{Float64, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Array{Float64, 3}, xi::AutoGrad.Result{Array{Float32, 3}}, x::Param{Vector{Array{Float32, 3}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr1#itr1##0", Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr1#itr1##0", Vector{Any}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [inlined] [11] gradcheck(f::var"#itr1#itr1##0", x::Vector{Array{Float32, 3}}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:39 [12] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:4 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:34 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] iterate: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:35 Test threw exception Expression: gradcheck(itr2, warray; o...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float32, 3}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Array{Float32, 3}}, dxi::Array{Float64, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Array{Float32, 3}}}, dxi::Array{Float64, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Array{Float64, 3}, xi::AutoGrad.Result{Array{Float32, 3}}, x::Param{Vector{Array{Float32, 3}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr2#itr2##0", Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr2#itr2##0", Vector{Any}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [inlined] [11] gradcheck(f::var"#itr2#itr2##0", x::Vector{Array{Float32, 3}}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:39 [12] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:4 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:35 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] iterate: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:39 Test threw exception Expression: gradcheck(itr4, warray; o...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float32, 3}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Array{Float32, 3}}, dxi::Array{Float32, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Array{Float32, 3}}}, dxi::Array{Float32, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Array{Float32, 3}, xi::AutoGrad.Result{Array{Float32, 3}}, x::Param{Vector{Array{Float32, 3}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr4#itr4##0", Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr4#itr4##0", Vector{Any}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [inlined] [11] gradcheck(f::var"#itr4#itr4##0", x::Vector{Array{Float32, 3}}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:39 [12] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:4 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:39 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] iterate: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:34 Test threw exception Expression: gradcheck(itr1, warray; o...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float64, 3}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Array{Float64, 3}}, dxi::Array{Float64, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Array{Float64, 3}}}, dxi::Array{Float64, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Array{Float64, 3}, xi::AutoGrad.Result{Array{Float64, 3}}, x::Param{Vector{Array{Float64, 3}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr1#itr1##0", Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr1#itr1##0", Vector{Any}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [inlined] [11] gradcheck(f::var"#itr1#itr1##0", x::Vector{Array{Float64, 3}}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:39 [12] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:4 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:34 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] iterate: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:35 Test threw exception Expression: gradcheck(itr2, warray; o...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float64, 3}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Array{Float64, 3}}, dxi::Array{Float64, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Array{Float64, 3}}}, dxi::Array{Float64, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Array{Float64, 3}, xi::AutoGrad.Result{Array{Float64, 3}}, x::Param{Vector{Array{Float64, 3}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr2#itr2##0", Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr2#itr2##0", Vector{Any}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [inlined] [11] gradcheck(f::var"#itr2#itr2##0", x::Vector{Array{Float64, 3}}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:39 [12] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:4 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:35 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] iterate: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:39 Test threw exception Expression: gradcheck(itr4, warray; o...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float64, 3}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Array{Float64, 3}}, dxi::Array{Float64, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Array{Float64, 3}}}, dxi::Array{Float64, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Array{Float64, 3}, xi::AutoGrad.Result{Array{Float64, 3}}, x::Param{Vector{Array{Float64, 3}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr4#itr4##0", Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr4#itr4##0", Vector{Any}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [inlined] [11] gradcheck(f::var"#itr4#itr4##0", x::Vector{Array{Float64, 3}}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:39 [12] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:4 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:39 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] 13.627341 seconds (5.19 M allocations: 324.335 MiB, 0.44% gc time, 97.29% compilation time) 39.599438 seconds (12.87 M allocations: 827.195 MiB, 0.71% gc time, 99.54% compilation time) 191.421840 seconds (74.51 M allocations: 4.564 GiB, 1.01% gc time, 99.42% compilation time) neuralnet: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:13 Test threw exception Expression: gradcheck(n0, wa, rand(3, 10), rand(2, 10)) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Vector{Float64}, xi::AutoGrad.Result{Vector{Float64}}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::AutoGrad.var"#207#208"{Tuple{}, typeof(n0), Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::AutoGrad.var"#207#208"{Tuple{}, typeof(n0), Vector{Any}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [inlined] [11] gradcheck(::typeof(n0), ::Vector{Any}, ::Vararg{Any}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:39 [12] gradcheck(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [13] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [14] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:13 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [16] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:13 [inlined] [17] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::AutoGrad.Result{Vector{Float64}}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::AutoGrad.Result{Vector{Float64}}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:91 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::AutoGrad.Result{Vector{Float64}}, xi::AutoGrad.Result{Vector{Float64}}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::typeof(n0), ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{typeof(n0), Int64, Bool}})(::Param{Vector{Any}}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{typeof(n0), Int64, Bool}})(::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] n1sum(w::Param{Vector{Any}}, x::Param{Matrix{Float64}}, y::Param{Matrix{Float64}}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:6 [14] gcsum(::typeof(n1sum), ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] (::AutoGrad.var"#207#208"{Tuple{}, typeof(n1sum), Vector{Any}})() @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:205 [inlined] [17] differentiate(::AutoGrad.var"#207#208"{Tuple{}, typeof(n1sum), Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:144 [18] differentiate(::AutoGrad.var"#207#208"{Tuple{}, typeof(n1sum), Vector{Any}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [inlined] [19] gradcheck(::typeof(n1sum), ::Vector{Any}, ::Vararg{Any}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:39 [20] gradcheck(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [21] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [22] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:13 [23] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [24] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:16 [inlined] [25] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [26] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:335 [27] macro expansion @ ./timing.jl:741 [inlined] [28] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/runtests.jl:14 [inlined] [29] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [30] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/runtests.jl:3 [31] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:335 [32] top-level scope @ none:6 [33] eval(m::Module, e::Any) @ Core boot.jl:618 [34] __script_entry_eval(mod::Module, ex::Any) @ Base client.jl:106 [inlined] [35] exec_options(opts::Base.JLOptions) @ Base client.jl:350 [36] _start() @ Base client.jl:695 neuralnet: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:16 Test threw exception Expression: gradcheck(n1sum, wa, rand(3, 10), rand(2, 10)) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] differentiate(::AutoGrad.var"#207#208"{Tuple{}, typeof(n1sum), Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:148 [2] differentiate(::AutoGrad.var"#207#208"{Tuple{}, typeof(n1sum), Vector{Any}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [inlined] [3] gradcheck(::typeof(n1sum), ::Vector{Any}, ::Vararg{Any}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:39 [4] gradcheck(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [5] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [6] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:13 [7] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [8] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:16 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] caused by: MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::AutoGrad.Result{Vector{Float64}}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::AutoGrad.Result{Vector{Float64}}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:91 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::AutoGrad.Result{Vector{Float64}}, xi::AutoGrad.Result{Vector{Float64}}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::typeof(n0), ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{typeof(n0), Int64, Bool}})(::Param{Vector{Any}}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{typeof(n0), Int64, Bool}})(::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] n1sum(w::Param{Vector{Any}}, x::Param{Matrix{Float64}}, y::Param{Matrix{Float64}}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:6 [14] gcsum(::typeof(n1sum), ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] (::AutoGrad.var"#207#208"{Tuple{}, typeof(n1sum), Vector{Any}})() @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:205 [inlined] [17] differentiate(::AutoGrad.var"#207#208"{Tuple{}, typeof(n1sum), Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:144 [18] differentiate(::AutoGrad.var"#207#208"{Tuple{}, typeof(n1sum), Vector{Any}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [inlined] [19] gradcheck(::typeof(n1sum), ::Vector{Any}, ::Vararg{Any}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:39 [20] gradcheck(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [21] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [22] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:13 [23] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [24] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:16 [inlined] [25] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] neuralnet: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:17 Test threw exception Expression: gradcheck(n1sum, wt, rand(3, 10), rand(2, 10)) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Vector{Float64}, xi::AutoGrad.Result{Vector{Float64}}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::typeof(n0), ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{typeof(n0), Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{typeof(n0), Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] n1sum(w::Vector{Any}, x::Matrix{Float64}, y::Matrix{Float64}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:6 [14] gcsum(::typeof(n1sum), ::Vector{Any}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] gcwalk(i::Int64, xptr::Matrix{Float64}, gptr::Matrix{Float64}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [17] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Tuple{Matrix{Float64}, Vector{Float64}, Matrix{Float64}, Vector{Float64}}, Float64, typeof(n1sum), Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [18] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Tuple{Matrix{Float64}, Vector{Float64}, Matrix{Float64}, Vector{Float64}}, Float64, typeof(n1sum), Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [19] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [20] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Tuple{Matrix{Float64}, Vector{Float64}, Matrix{Float64}, Vector{Float64}}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [21] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, typeof(n1sum), Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [22] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, typeof(n1sum), Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [23] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [24] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [25] (::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, typeof(n1sum), Vector{Any}, Vector{Any}, Float64})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [26] _all(f::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, typeof(n1sum), Vector{Any}, Vector{Any}, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [27] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [28] gradcheck(::typeof(n1sum), ::Tuple{Matrix{Float64}, Vector{Float64}, Matrix{Float64}, Vector{Float64}}, ::Vararg{Any}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [29] gradcheck(::Function, ::Tuple{Matrix{Float64}, Vector{Float64}, Matrix{Float64}, Vector{Float64}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [30] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [31] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:13 [32] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [33] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:17 [inlined] [34] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] 36.137226 seconds (8.18 M allocations: 533.865 MiB, 0.75% gc time, 98.53% compilation time) rosenbrock: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/rosenbrock.jl:13 Test threw exception Expression: gradcheck(b1sum, (randn(2)...,)) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(f::var"#b0#b0##0", x::Param{Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}})(args::Vector{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}})(args::Vector{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [inlined] [13] (::var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}})(x::Vector{Any}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/rosenbrock.jl:7 [14] gcsum(f::var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, x::Vector{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Tuple{Float64, Float64}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [17] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [18] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [19] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [20] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [21] (::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float64})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [22] _all(f::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [23] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [24] gradcheck(f::var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, x::Tuple{Float64, Float64}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [25] gradcheck(f::Function, x::Tuple{Float64, Float64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [26] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [27] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [28] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/rosenbrock.jl:13 [inlined] [29] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [30] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/rosenbrock.jl:5 rosenbrock: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/rosenbrock.jl:15 Test threw exception Expression: gradcheck(b1sum, (randn(3)...,)) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(f::var"#b0#b0##0", x::Param{Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}})(args::Vector{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}})(args::Vector{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [inlined] [13] (::var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}})(x::Vector{Any}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/rosenbrock.jl:7 [14] gcsum(f::var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, x::Vector{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Tuple{Float64, Float64, Float64}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [17] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [18] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [19] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [20] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [21] (::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float64})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [22] _all(f::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [23] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [24] gradcheck(f::var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, x::Tuple{Float64, Float64, Float64}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [25] gradcheck(f::Function, x::Tuple{Float64, Float64, Float64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [26] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [27] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [28] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/rosenbrock.jl:15 [inlined] [29] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [30] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/rosenbrock.jl:5 5.657786 seconds (3.65 M allocations: 119.567 MiB) 18.016509 seconds (6.88 M allocations: 318.594 MiB, 0.42% gc time, 66.92% compilation time) WARNING: Method definition foo(Any) in module Main at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/sparse.jl:20 overwritten at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/sparse.jl:26. 10.240686 seconds (3.15 M allocations: 197.423 MiB, 0.76% gc time, 99.02% compilation time) 97.719351 seconds (30.23 M allocations: 1.830 GiB, 1.21% gc time, 99.38% compilation time) statistics: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:16 Test threw exception Expression: gradcheck(var, randn(T, 2, 3); kw = [:dims => 1], o...) MethodError: no method matching reducedim1(::Matrix{Float32}, ::Matrix{Float32}) The function `reducedim1` exists, but no method is defined for this combination of argument types. Closest candidates are: reducedim1(::Any) @ Base reducedim.jl:1229 Stacktrace: [1] centralize_sumabs2!(R::Matrix{Float32}, A::Matrix{Float32}, means::Matrix{Float32}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:282 [2] varm!(R::Matrix{Float32}, A::Matrix{Float32}, m::Matrix{Float32}; corrected::Bool) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:309 [3] _varm(A::Matrix{Float32}, m::Matrix{Float32}, corrected::Bool, region::Int64) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:341 [4] varm(A::Matrix{Float32}, m::Matrix{Float32}; corrected::Bool, dims::Int64) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:339 [inlined] [5] _var(A::Matrix{Float32}, corrected::Bool, mean::Nothing, dims::Int64) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:386 [inlined] [6] var(A::Matrix{Float32}; corrected::Bool, mean::Nothing, dims::Int64) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:380 [inlined] [7] gcsum(f::typeof(var), x::Matrix{Float32}; o::@Kwargs{dims::Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [8] gcwalk(i::Int64, xptr::Matrix{Float32}, gptr::Matrix{Float32}, f0::Float32, f::Function, x::Vector{Any}, kw::Vector{Pair{Symbol, Int64}}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [9] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float32, typeof(var), Vector{Any}, Vector{Pair{Symbol, Int64}}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [10] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float32, typeof(var), Vector{Any}, Vector{Pair{Symbol, Int64}}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [11] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [12] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float32, f::Function, x::Vector{Any}, kw::Vector{Pair{Symbol, Int64}}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [13] (::AutoGrad.var"#209#210"{Vector{Pair{Symbol, Int64}}, Int64, Int64, Float64, Float64, Float64, typeof(var), Vector{Any}, Vector{Any}, Float32})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [14] _all(f::AutoGrad.var"#209#210"{Vector{Pair{Symbol, Int64}}, Int64, Int64, Float64, Float64, Float64, typeof(var), Vector{Any}, Vector{Any}, Float32}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [15] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [16] gradcheck(f::typeof(var), x::Matrix{Float32}; kw::Vector{Pair{Symbol, Int64}}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [17] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:16 [inlined] [20] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [21] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:8 statistics: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:17 Test threw exception Expression: gradcheck(var, randn(T, 2, 3); kw = [:dims => (1, 2)], o...) MethodError: no method matching reducedim1(::Matrix{Float32}, ::Matrix{Float32}) The function `reducedim1` exists, but no method is defined for this combination of argument types. Closest candidates are: reducedim1(::Any) @ Base reducedim.jl:1229 Stacktrace: [1] centralize_sumabs2!(R::Matrix{Float32}, A::Matrix{Float32}, means::Matrix{Float32}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:282 [2] varm!(R::Matrix{Float32}, A::Matrix{Float32}, m::Matrix{Float32}; corrected::Bool) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:309 [3] _varm(A::Matrix{Float32}, m::Matrix{Float32}, corrected::Bool, region::Tuple{Int64, Int64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:341 [inlined] [4] varm(A::Matrix{Float32}, m::Matrix{Float32}; corrected::Bool, dims::Tuple{Int64, Int64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:339 [inlined] [5] _var(A::Matrix{Float32}, corrected::Bool, mean::Nothing, dims::Tuple{Int64, Int64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:386 [inlined] [6] var(A::Matrix{Float32}; corrected::Bool, mean::Nothing, dims::Tuple{Int64, Int64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:380 [inlined] [7] gcsum(f::typeof(var), x::Matrix{Float32}; o::@Kwargs{dims::Tuple{Int64, Int64}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [8] gcwalk(i::Int64, xptr::Matrix{Float32}, gptr::Matrix{Float32}, f0::Float32, f::Function, x::Vector{Any}, kw::Vector{Pair{Symbol, Tuple{Int64, Int64}}}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [9] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float32, typeof(var), Vector{Any}, Vector{Pair{Symbol, Tuple{Int64, Int64}}}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [10] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float32, typeof(var), Vector{Any}, Vector{Pair{Symbol, Tuple{Int64, Int64}}}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [11] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [12] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float32, f::Function, x::Vector{Any}, kw::Vector{Pair{Symbol, Tuple{Int64, Int64}}}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [13] (::AutoGrad.var"#209#210"{Vector{Pair{Symbol, Tuple{Int64, Int64}}}, Int64, Int64, Float64, Float64, Float64, typeof(var), Vector{Any}, Vector{Any}, Float32})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [14] _all(f::AutoGrad.var"#209#210"{Vector{Pair{Symbol, Tuple{Int64, Int64}}}, Int64, Int64, Float64, Float64, Float64, typeof(var), Vector{Any}, Vector{Any}, Float32}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [15] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [16] gradcheck(f::typeof(var), x::Matrix{Float32}; kw::Vector{Pair{Symbol, Tuple{Int64, Int64}}}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [17] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:17 [inlined] [20] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [21] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:8 statistics: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:19 Test threw exception Expression: gradcheck(std, randn(T, 2, 3); kw = [:dims => 1], o...) MethodError: no method matching reducedim1(::Matrix{Float32}, ::Matrix{Float32}) The function `reducedim1` exists, but no method is defined for this combination of argument types. Closest candidates are: reducedim1(::Any) @ Base reducedim.jl:1229 Stacktrace: [1] centralize_sumabs2!(R::Matrix{Float32}, A::Matrix{Float32}, means::Matrix{Float32}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:282 [2] varm!(R::Matrix{Float32}, A::Matrix{Float32}, m::Matrix{Float32}; corrected::Bool) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:309 [3] _varm(A::Matrix{Float32}, m::Matrix{Float32}, corrected::Bool, region::Int64) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:341 [4] varm(A::Matrix{Float32}, m::Matrix{Float32}; corrected::Bool, dims::Int64) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:339 [inlined] [5] _var(A::Matrix{Float32}, corrected::Bool, mean::Nothing, dims::Int64) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:386 [inlined] [6] var(A::Matrix{Float32}; corrected::Bool, mean::Nothing, dims::Int64) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:380 [inlined] [7] _std(A::Matrix{Float32}, corrected::Bool, mean::Nothing, dims::Int64) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:469 [8] std(A::Matrix{Float32}; corrected::Bool, mean::Nothing, dims::Int64) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:461 [inlined] [9] gcsum(f::typeof(std), x::Matrix{Float32}; o::@Kwargs{dims::Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [10] gcwalk(i::Int64, xptr::Matrix{Float32}, gptr::Matrix{Float32}, f0::Float32, f::Function, x::Vector{Any}, kw::Vector{Pair{Symbol, Int64}}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [11] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float32, typeof(std), Vector{Any}, Vector{Pair{Symbol, Int64}}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [12] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float32, typeof(std), Vector{Any}, Vector{Pair{Symbol, Int64}}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [13] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [14] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float32, f::Function, x::Vector{Any}, kw::Vector{Pair{Symbol, Int64}}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [15] (::AutoGrad.var"#209#210"{Vector{Pair{Symbol, Int64}}, Int64, Int64, Float64, Float64, Float64, typeof(std), Vector{Any}, Vector{Any}, Float32})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [16] _all(f::AutoGrad.var"#209#210"{Vector{Pair{Symbol, Int64}}, Int64, Int64, Float64, Float64, Float64, typeof(std), Vector{Any}, Vector{Any}, Float32}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [17] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [18] gradcheck(f::typeof(std), x::Matrix{Float32}; kw::Vector{Pair{Symbol, Int64}}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [19] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [20] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [21] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:19 [inlined] [22] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [23] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:8 statistics: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:20 Test threw exception Expression: gradcheck(std, randn(T, 2, 3); kw = [:dims => (1, 2)], o...) MethodError: no method matching reducedim1(::Matrix{Float32}, ::Matrix{Float32}) The function `reducedim1` exists, but no method is defined for this combination of argument types. Closest candidates are: reducedim1(::Any) @ Base reducedim.jl:1229 Stacktrace: [1] centralize_sumabs2!(R::Matrix{Float32}, A::Matrix{Float32}, means::Matrix{Float32}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:282 [2] varm!(R::Matrix{Float32}, A::Matrix{Float32}, m::Matrix{Float32}; corrected::Bool) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:309 [3] _varm(A::Matrix{Float32}, m::Matrix{Float32}, corrected::Bool, region::Tuple{Int64, Int64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:341 [inlined] [4] varm(A::Matrix{Float32}, m::Matrix{Float32}; corrected::Bool, dims::Tuple{Int64, Int64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:339 [inlined] [5] _var(A::Matrix{Float32}, corrected::Bool, mean::Nothing, dims::Tuple{Int64, Int64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:386 [inlined] [6] var(A::Matrix{Float32}; corrected::Bool, mean::Nothing, dims::Tuple{Int64, Int64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:380 [inlined] [7] _std(A::Matrix{Float32}, corrected::Bool, mean::Nothing, dims::Tuple{Int64, Int64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:469 [8] std(A::Matrix{Float32}; corrected::Bool, mean::Nothing, dims::Tuple{Int64, Int64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:461 [inlined] [9] gcsum(f::typeof(std), x::Matrix{Float32}; o::@Kwargs{dims::Tuple{Int64, Int64}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [10] gcwalk(i::Int64, xptr::Matrix{Float32}, gptr::Matrix{Float32}, f0::Float32, f::Function, x::Vector{Any}, kw::Vector{Pair{Symbol, Tuple{Int64, Int64}}}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [11] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float32, typeof(std), Vector{Any}, Vector{Pair{Symbol, Tuple{Int64, Int64}}}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [12] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float32, typeof(std), Vector{Any}, Vector{Pair{Symbol, Tuple{Int64, Int64}}}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [13] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [14] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float32, f::Function, x::Vector{Any}, kw::Vector{Pair{Symbol, Tuple{Int64, Int64}}}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [15] (::AutoGrad.var"#209#210"{Vector{Pair{Symbol, Tuple{Int64, Int64}}}, Int64, Int64, Float64, Float64, Float64, typeof(std), Vector{Any}, Vector{Any}, Float32})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [16] _all(f::AutoGrad.var"#209#210"{Vector{Pair{Symbol, Tuple{Int64, Int64}}}, Int64, Int64, Float64, Float64, Float64, typeof(std), Vector{Any}, Vector{Any}, Float32}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [17] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [18] gradcheck(f::typeof(std), x::Matrix{Float32}; kw::Vector{Pair{Symbol, Tuple{Int64, Int64}}}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [19] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [20] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [21] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:20 [inlined] [22] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [23] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:8 statistics: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:16 Test threw exception Expression: gradcheck(var, randn(T, 2, 3); kw = [:dims => 1], o...) MethodError: no method matching reducedim1(::Matrix{Float64}, ::Matrix{Float64}) The function `reducedim1` exists, but no method is defined for this combination of argument types. Closest candidates are: reducedim1(::Any) @ Base reducedim.jl:1229 Stacktrace: [1] centralize_sumabs2!(R::Matrix{Float64}, A::Matrix{Float64}, means::Matrix{Float64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:282 [2] varm!(R::Matrix{Float64}, A::Matrix{Float64}, m::Matrix{Float64}; corrected::Bool) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:309 [3] _varm(A::Matrix{Float64}, m::Matrix{Float64}, corrected::Bool, region::Int64) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:341 [4] varm(A::Matrix{Float64}, m::Matrix{Float64}; corrected::Bool, dims::Int64) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:339 [inlined] [5] _var(A::Matrix{Float64}, corrected::Bool, mean::Nothing, dims::Int64) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:386 [inlined] [6] var(A::Matrix{Float64}; corrected::Bool, mean::Nothing, dims::Int64) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:380 [inlined] [7] gcsum(f::typeof(var), x::Matrix{Float64}; o::@Kwargs{dims::Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [8] gcwalk(i::Int64, xptr::Matrix{Float64}, gptr::Matrix{Float64}, f0::Float64, f::Function, x::Vector{Any}, kw::Vector{Pair{Symbol, Int64}}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [9] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, typeof(var), Vector{Any}, Vector{Pair{Symbol, Int64}}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [10] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, typeof(var), Vector{Any}, Vector{Pair{Symbol, Int64}}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [11] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [12] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float64, f::Function, x::Vector{Any}, kw::Vector{Pair{Symbol, Int64}}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [13] (::AutoGrad.var"#209#210"{Vector{Pair{Symbol, Int64}}, Int64, Int64, Float64, Float64, Float64, typeof(var), Vector{Any}, Vector{Any}, Float64})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [14] _all(f::AutoGrad.var"#209#210"{Vector{Pair{Symbol, Int64}}, Int64, Int64, Float64, Float64, Float64, typeof(var), Vector{Any}, Vector{Any}, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [15] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [16] gradcheck(f::typeof(var), x::Matrix{Float64}; kw::Vector{Pair{Symbol, Int64}}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [17] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:16 [inlined] [20] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [21] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:8 statistics: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:17 Test threw exception Expression: gradcheck(var, randn(T, 2, 3); kw = [:dims => (1, 2)], o...) MethodError: no method matching reducedim1(::Matrix{Float64}, ::Matrix{Float64}) The function `reducedim1` exists, but no method is defined for this combination of argument types. Closest candidates are: reducedim1(::Any) @ Base reducedim.jl:1229 Stacktrace: [1] centralize_sumabs2!(R::Matrix{Float64}, A::Matrix{Float64}, means::Matrix{Float64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:282 [2] varm!(R::Matrix{Float64}, A::Matrix{Float64}, m::Matrix{Float64}; corrected::Bool) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:309 [3] _varm(A::Matrix{Float64}, m::Matrix{Float64}, corrected::Bool, region::Tuple{Int64, Int64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:341 [inlined] [4] varm(A::Matrix{Float64}, m::Matrix{Float64}; corrected::Bool, dims::Tuple{Int64, Int64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:339 [inlined] [5] _var(A::Matrix{Float64}, corrected::Bool, mean::Nothing, dims::Tuple{Int64, Int64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:386 [inlined] [6] var(A::Matrix{Float64}; corrected::Bool, mean::Nothing, dims::Tuple{Int64, Int64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:380 [inlined] [7] gcsum(f::typeof(var), x::Matrix{Float64}; o::@Kwargs{dims::Tuple{Int64, Int64}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [8] gcwalk(i::Int64, xptr::Matrix{Float64}, gptr::Matrix{Float64}, f0::Float64, f::Function, x::Vector{Any}, kw::Vector{Pair{Symbol, Tuple{Int64, Int64}}}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [9] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, typeof(var), Vector{Any}, Vector{Pair{Symbol, Tuple{Int64, Int64}}}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [10] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, typeof(var), Vector{Any}, Vector{Pair{Symbol, Tuple{Int64, Int64}}}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [11] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [12] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float64, f::Function, x::Vector{Any}, kw::Vector{Pair{Symbol, Tuple{Int64, Int64}}}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [13] (::AutoGrad.var"#209#210"{Vector{Pair{Symbol, Tuple{Int64, Int64}}}, Int64, Int64, Float64, Float64, Float64, typeof(var), Vector{Any}, Vector{Any}, Float64})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [14] _all(f::AutoGrad.var"#209#210"{Vector{Pair{Symbol, Tuple{Int64, Int64}}}, Int64, Int64, Float64, Float64, Float64, typeof(var), Vector{Any}, Vector{Any}, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [15] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [16] gradcheck(f::typeof(var), x::Matrix{Float64}; kw::Vector{Pair{Symbol, Tuple{Int64, Int64}}}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [17] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:17 [inlined] [20] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [21] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:8 statistics: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:19 Test threw exception Expression: gradcheck(std, randn(T, 2, 3); kw = [:dims => 1], o...) MethodError: no method matching reducedim1(::Matrix{Float64}, ::Matrix{Float64}) The function `reducedim1` exists, but no method is defined for this combination of argument types. Closest candidates are: reducedim1(::Any) @ Base reducedim.jl:1229 Stacktrace: [1] centralize_sumabs2!(R::Matrix{Float64}, A::Matrix{Float64}, means::Matrix{Float64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:282 [2] varm!(R::Matrix{Float64}, A::Matrix{Float64}, m::Matrix{Float64}; corrected::Bool) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:309 [3] _varm(A::Matrix{Float64}, m::Matrix{Float64}, corrected::Bool, region::Int64) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:341 [4] varm(A::Matrix{Float64}, m::Matrix{Float64}; corrected::Bool, dims::Int64) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:339 [inlined] [5] _var(A::Matrix{Float64}, corrected::Bool, mean::Nothing, dims::Int64) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:386 [inlined] [6] var(A::Matrix{Float64}; corrected::Bool, mean::Nothing, dims::Int64) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:380 [inlined] [7] _std(A::Matrix{Float64}, corrected::Bool, mean::Nothing, dims::Int64) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:469 [8] std(A::Matrix{Float64}; corrected::Bool, mean::Nothing, dims::Int64) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:461 [inlined] [9] gcsum(f::typeof(std), x::Matrix{Float64}; o::@Kwargs{dims::Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [10] gcwalk(i::Int64, xptr::Matrix{Float64}, gptr::Matrix{Float64}, f0::Float64, f::Function, x::Vector{Any}, kw::Vector{Pair{Symbol, Int64}}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [11] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, typeof(std), Vector{Any}, Vector{Pair{Symbol, Int64}}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [12] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, typeof(std), Vector{Any}, Vector{Pair{Symbol, Int64}}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [13] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [14] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float64, f::Function, x::Vector{Any}, kw::Vector{Pair{Symbol, Int64}}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [15] (::AutoGrad.var"#209#210"{Vector{Pair{Symbol, Int64}}, Int64, Int64, Float64, Float64, Float64, typeof(std), Vector{Any}, Vector{Any}, Float64})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [16] _all(f::AutoGrad.var"#209#210"{Vector{Pair{Symbol, Int64}}, Int64, Int64, Float64, Float64, Float64, typeof(std), Vector{Any}, Vector{Any}, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [17] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [18] gradcheck(f::typeof(std), x::Matrix{Float64}; kw::Vector{Pair{Symbol, Int64}}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [19] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [20] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [21] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:19 [inlined] [22] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [23] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:8 statistics: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:20 Test threw exception Expression: gradcheck(std, randn(T, 2, 3); kw = [:dims => (1, 2)], o...) MethodError: no method matching reducedim1(::Matrix{Float64}, ::Matrix{Float64}) The function `reducedim1` exists, but no method is defined for this combination of argument types. Closest candidates are: reducedim1(::Any) @ Base reducedim.jl:1229 Stacktrace: [1] centralize_sumabs2!(R::Matrix{Float64}, A::Matrix{Float64}, means::Matrix{Float64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:282 [2] varm!(R::Matrix{Float64}, A::Matrix{Float64}, m::Matrix{Float64}; corrected::Bool) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:309 [3] _varm(A::Matrix{Float64}, m::Matrix{Float64}, corrected::Bool, region::Tuple{Int64, Int64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:341 [inlined] [4] varm(A::Matrix{Float64}, m::Matrix{Float64}; corrected::Bool, dims::Tuple{Int64, Int64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:339 [inlined] [5] _var(A::Matrix{Float64}, corrected::Bool, mean::Nothing, dims::Tuple{Int64, Int64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:386 [inlined] [6] var(A::Matrix{Float64}; corrected::Bool, mean::Nothing, dims::Tuple{Int64, Int64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:380 [inlined] [7] _std(A::Matrix{Float64}, corrected::Bool, mean::Nothing, dims::Tuple{Int64, Int64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:469 [8] std(A::Matrix{Float64}; corrected::Bool, mean::Nothing, dims::Tuple{Int64, Int64}) @ Statistics ~/.julia/packages/Statistics/gbcbG/src/Statistics.jl:461 [inlined] [9] gcsum(f::typeof(std), x::Matrix{Float64}; o::@Kwargs{dims::Tuple{Int64, Int64}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [10] gcwalk(i::Int64, xptr::Matrix{Float64}, gptr::Matrix{Float64}, f0::Float64, f::Function, x::Vector{Any}, kw::Vector{Pair{Symbol, Tuple{Int64, Int64}}}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [11] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, typeof(std), Vector{Any}, Vector{Pair{Symbol, Tuple{Int64, Int64}}}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [12] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, typeof(std), Vector{Any}, Vector{Pair{Symbol, Tuple{Int64, Int64}}}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [13] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [14] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float64, f::Function, x::Vector{Any}, kw::Vector{Pair{Symbol, Tuple{Int64, Int64}}}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [15] (::AutoGrad.var"#209#210"{Vector{Pair{Symbol, Tuple{Int64, Int64}}}, Int64, Int64, Float64, Float64, Float64, typeof(std), Vector{Any}, Vector{Any}, Float64})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [16] _all(f::AutoGrad.var"#209#210"{Vector{Pair{Symbol, Tuple{Int64, Int64}}}, Int64, Int64, Float64, Float64, Float64, typeof(std), Vector{Any}, Vector{Any}, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [17] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:1001 [18] gradcheck(f::typeof(std), x::Matrix{Float64}; kw::Vector{Pair{Symbol, Tuple{Int64, Int64}}}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [19] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [20] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [21] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:20 [inlined] [22] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2247 [inlined] [23] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/statistics.jl:8 34.417534 seconds (11.97 M allocations: 791.702 MiB, 0.68% gc time, 96.76% compilation time: <1% of which was recompilation) Test Summary: | Pass Error Broken Total Time AutoGrad | 530 43 15 588 14m00.2s base | 111 111 2m45.7s cat | 20 20 20.7s core | 13 5 18 46.9s getindex | 206 19 225 2m06.3s Array | 73 73 33.7s Tuple | 8 6 14 7.2s Dict | 2 2 1.9s size | 3 3 1.6s indexing | 15 3 18 20.3s view | 2 2 8.2s Array | 73 73 26.3s Tuple | 8 6 14 4.5s Dict | 2 2 1.7s size | 3 3 0.0s indexing | 15 3 18 13.3s view | 2 2 5.2s highorder | 17 1 18 24.3s iterate | 8 6 14 13.6s LinearAlgebra | 34 14 48 39.5s math | 62 62 3m11.2s neuralnet | 3 3 6 36.1s rosenbrock | 6 2 8 16.9s sparse | 8 8 10.2s specialfunctions | 28 28 1m37.6s statistics | 14 8 22 33.7s RNG of the outermost testset: Xoshiro(0x12e2f078e943de0c, 0x8b16c19713fdef98, 0x17c1b04f4b0c6b20, 0xc68742c871751e7a, 0x98a27a45b6af99ca) ERROR: LoadError: Some tests did not pass: 530 passed, 0 failed, 43 errored, 15 broken. in expression starting at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/runtests.jl:2 Testing failed after 829.98s ERROR: LoadError: Package AutoGrad errored during testing Stacktrace: [1] pkgerror(msg::String) @ Pkg.Types /opt/julia/share/julia/stdlib/v1.14/Pkg/src/Types.jl:68 [2] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, julia_args::Cmd, test_args::Cmd, test_fn::Nothing, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool) @ Pkg.Operations /opt/julia/share/julia/stdlib/v1.14/Pkg/src/Operations.jl:3283 [3] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, test_fn::Nothing, julia_args::Cmd, test_args::Cmd, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool, kwargs::@Kwargs{io::IOContext{IO}}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:587 [4] test(pkgs::Vector{PackageSpec}; io::IOContext{IO}, kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:172 [5] test(pkgs::Vector{String}; kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:160 [6] test(pkg::String; kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:159 [inlined] [7] top-level scope @ /PkgEval.jl/scripts/evaluate.jl:223 in expression starting at /PkgEval.jl/scripts/evaluate.jl:214 PkgEval failed after 947.79s: package tests unexpectedly errored