Access to undefined reference at let keyword #224

jakobnissen · 2021-07-24T19:44:34Z

Running JET.report_packge(ScanByte) of ScanByte commit a8b430d returns:

[toplevel-info] virtualized the context of Main (took 0.031 sec)
[toplevel-info] entered into /home/jakob/code/ScanByte.jl/src/ScanByte.jl
[toplevel-info] entered into /home/jakob/code/ScanByte.jl/src/byteset.jl
[toplevel-info]  exited from /home/jakob/code/ScanByte.jl/src/byteset.jl (took 0.227 sec)
[toplevel-info] entered into /home/jakob/code/ScanByte.jl/src/codegen.jl
[toplevel-info]  exited from /home/jakob/code/ScanByte.jl/src/codegen.jl (took 7.893 sec)
[toplevel-info]  exited from /home/jakob/code/ScanByte.jl/src/ScanByte.jl (took 10.286 sec)
═════ 1 toplevel error found ═════
┌ @ /home/jakob/code/ScanByte.jl/src/codegen.jl:20
│ UndefRefError: access to undefined reference
└──────────────────────────────────────────────────
(included_files = Set(["/home/jakob/code/ScanByte.jl/src/codegen.jl", "/home/jakob/code/ScanByte.jl/src/byteset.jl", "/home/jakob/code/ScanByte.jl/src/ScanByte.jl"]), any_reported = true)

This is weird because:

The package does actually work
It doesn't say which reference was accessed
The line it points at only consists of a let.

The text was updated successfully, but these errors were encountered:

ericphanson · 2021-07-24T20:28:05Z

Just to say I get this error as well with Convex.jl, pointing at this line: https://github.com/jump-dev/Convex.jl/blob/8707062cd1549a74b9397373e9178e4481f4fd8e/src/variable.jl#L204

aviatesk · 2021-08-02T15:56:18Z

Thanks for your reports. These cases seem like to be from bugs within JET. I will take a look into this.

goerch · 2021-12-02T12:26:12Z

I checked the packages referenced by ScanByte with JET.report_package("Libdl") and JET.report_package("SIMD"). Libdl is fine, but SIMD shows some problems, especially

no matching method found for call signature (Tuple{typeof(FixedPointNumbers.rawone), Type{Union{}}}): FixedPointNumbers.rawone(_::Type{Union{}})

The same error shows up internally when checking ScanByte but is swallowed by the logic in

function get_reports(result::JETToplevelResult)
    res = result.res
    if !isempty(res.toplevel_error_reports)
        # non-empty `ret.toplevel_error_reports` means critical errors happened during
        # the AST transformation, so they always have precedence over `ret.inference_error_reports`
        return res.toplevel_error_reports
    else
        reports = res.inference_error_reports
        return _get_configured_reports(reports; res.defined_modules, result.jetconfigs...)
    end
end

I'm not sure how JET is intended to handle problems in hierarchies of packages.

aviatesk · 2021-12-03T09:00:27Z

Top-level errors are generally more critical than inference errors, since they indicate JET failed to understand the input package at all.
We could have inference errors only if JET can understand the package (i.e. without top-level errors).
So we should try to fix the top-level error first.

I'm not sure how JET is intended to handle problems in hierarchies of packages.

For now, JET just analyzes the input package, and just try to load all the packages loaded by the specified package.

goerch · 2021-12-03T10:42:06Z

OK, instrumenting the JuliaInterpreter overloads (with some interesting effects;) handle_err reports

handle_err UndefRefError() Frame for Main.##JETVirtualModule#278.ScanByte
   1 20  1 ─       Core.NewvarNode(:(features))
   2 20  │         Core.NewvarNode(:(features_cstring))
   3 20  │         Core.NewvarNode(:(gethostcpufeatures))
   4 20  │         Core.NewvarNode(:(libllvm))
   5 21  │         $(Expr(:thunk, CodeInfo(
    @ none within `top-level scope`
1 ─      global var"#3#4"
│        const var"#3#4"
│   %3 = Core._structtype(Main.##JETVirtualModule#278.ScanByte, Symbol("#3#4"), Core.svec(), Core.svec(), Core.svec(), false, 0)
│        var"#3#4" = %3
│        Core._setsuper!(var"#3#4", Core.Function)
│        Core._typebody!(var"#3#4", Core.svec())
└──      return nothing
)))
   6 21  │   %6  = Core.svec(var"#3#4", $(QuoteNode(Any)))
   7 21  │   %7  = Core.svec()
   8 21  │   %8  = Core.svec(%6, %7, $(QuoteNode(:(#= C:\Users\Win10\.julia\packages\ScanByte\BvBXC\src\codegen.jl:21 =#))))
   9 21  │         $(Expr(:method, false, :(%8), CodeInfo(
    @ C:\Users\Win10\.julia\packages\ScanByte\BvBXC\src\codegen.jl:21 within `#3`
1 ─ %1 = Main.##JETVirtualModule#278.ScanByte.basename(lib)
│   %2 = Main.##JETVirtualModule#278.ScanByte.occursin(r"LLVM\b", %1)
└──      return %2
)))
  10 21  │         #3 = %new(var"#3#4")
  11 21  │   %11 = #3
  12 21  │   %12 = Base.getproperty(Libdl, :dllist)
  13 21  │   %13 = (%12)()
  14 21  │         llvmpaths = filter(%11, %13)
  15 22  │   %15 = length(llvmpaths)
  16 22  │   %16 = %15 != 1
  17 22  └──       goto #3 if not %16
  18 23  2 ─ %18 = ArgumentError("Found one or multiple LLVM libraries")
  19 23  └──       throw(%18)
  20 25  3 ┄ %20 = Base.getproperty(Libdl, :dlopen)
  21 25  │   %21 = Base.getindex(llvmpaths, 1)
  22 25  │         libllvm = (%20)(%21)
  23 26  │   %23 = Base.getproperty(Libdl, :dlsym)
  24 26  │   %24 = libllvm
  25 26  │         gethostcpufeatures = (%23)(%24, :LLVMGetHostCPUFeatures)
  26 27  │   %26 = Core.svec()
  27 27  │         features_cstring = $(Expr(:foreigncall, :(gethostcpufeatures), :Cstring, :(%26), 0, :(:ccall)))
  28 28  │   %28 = unsafe_string(features_cstring)
  29 28  │         features = split(%28, ',')
  30 29  │   %30 = Base.getproperty(Libc, :free)
  31 29  │         (%30)(features_cstring)
  32 32  │   %32 = isequal("+ssse3")
  33 32  │   %33 = any(%32, features)
  34 32  │   %34 = isequal("+sse2")
  35 32  │   %35 = any(%34, features)
  36 32  │   %36 = %33 & %35
  37 32  │   %37 = Core._expr(:(=), :SSSE3, %36)
  38 32  │   %38 = Core._expr(:const, %37)
  39 32  │         Core.eval(Main.##JETVirtualModule#278.ScanByte, %38)
  40 33  │   %40 = isequal("+avx2")
  41 33  │   %41 = any(%40, features)
  42 33  │   %42 = Core._expr(:(=), :AVX2, %41)
  43 33  │   %43 = Core._expr(:const, %42)
  44 33  │         Core.eval(Main.##JETVirtualModule#278.ScanByte, %43)
  45 36  │   %45 = $(Expr(:copyast, :($(QuoteNode(:(const DEFVEC = if AVX2
              #= C:\Users\Win10\.julia\packages\ScanByte\BvBXC\src\codegen.jl:37 =#
              v256
          elseif #= C:\Users\Win10\.julia\packages\ScanByte\BvBXC\src\codegen.jl:38 =# SSSE3
              #= C:\Users\Win10\.julia\packages\ScanByte\BvBXC\src\codegen.jl:39 =#
              v128
          else
              #= C:\Users\Win10\.julia\packages\ScanByte\BvBXC\src\codegen.jl:41 =#
              #= C:\Users\Win10\.julia\packages\ScanByte\BvBXC\src\codegen.jl:41 =# @warn "SIMD capacity not detected by ScanByte, using scalar fallback"
              #= C:\Users\Win10\.julia\packages\ScanByte\BvBXC\src\codegen.jl:42 =#
              nothing
          end))))))
  46 36  │   %46 = Core.eval(Main.##JETVirtualModule#278.ScanByte, %45)
  47 36  └──       return %46
#3 = #3
features_cstring = Cstring(0x000000008da77600)
gethostcpufeatures = Ptr{Nothing} @0x000000000573ea10
libllvm = Ptr{Nothing} @0x0000000003f80000
llvmpaths = ["C:\\Users\\Win10\\AppData\\Local\\Programs\\Julia-1.8.0-DEV\\bin\\libLLVM.dll"]

and marks 31 in yellow

  30 29  │   %30 = Base.getproperty(Libc, :free)
  31 29  │         (%30)(features_cstring)

This corresponds to the following source code in ScanByte

let
    llvmpaths = filter(lib -> occursin(r"LLVM\b", basename(lib)), Libdl.dllist())
    if length(llvmpaths) != 1
        throw(ArgumentError("Found one or multiple LLVM libraries"))
    end
    libllvm = Libdl.dlopen(llvmpaths[1])
    gethostcpufeatures = Libdl.dlsym(libllvm, :LLVMGetHostCPUFeatures)
    features_cstring = ccall(gethostcpufeatures, Cstring, ())
    features = split(unsafe_string(features_cstring), ',')
    Libc.free(features_cstring)

aviatesk · 2021-12-03T10:53:56Z

A wonderful debugging! It seems like this entire let block needs to be loaded in order to analyze the ScanBytes package correctly?

Now I just wonder, as a simplest solution, when analyzing package (i.e. when using report_package), we may just want disable the partial interpretation and just interpret the package by selecting all statements?

When analyzing a top-level script, the partial interpretation would be critical in order to avoid (possibly heavy) runtime computations, but package isn't supposed to have such a heavy runtime computation in their top-level code. Rather their top-level code are collections of definitions and setups like the above snippet.

aviatesk · 2021-12-03T10:55:49Z

Currently we ask users to configure their JET settings like concretization_patterns = ["const x_ = y_", "Libc.free(features_cstring)"] to analyze this sort of package code correctly...

goerch · 2021-12-03T11:53:41Z

It seems like this entire let block needs to be loaded in order to analyze the ScanBytes package correctly?

I just tried to change _virtual_process! to handle let statements like globals

        # can't wrap `:global` or `:let` declaration into a block
        if @isexpr(x, :global) || @isexpr(x, :let)
            eval_with_err_handling(context, x)
            continue
        end

and this change yields for ScanByte

═════ 5 possible errors found ═════
┌ @ C:\Users\Win10\.julia\packages\ScanByte\BvBXC\src\byteset.jl:29 Base.getindex(ScanByte.iterate(s), 1)
│ for 1 of union split cases, no matching method found for call signatures (Tuple{typeof(getindex), Nothing, Int64})): Base.getindex(ScanByte.iterate(s::ScanByte.ByteSet)::Union{Nothing, Tuple{UInt8, UInt64}}, 1)
└───────────────────────────────────────────────────────────────────
┌ @ C:\Users\Win10\.julia\packages\ScanByte\BvBXC\src\byteset.jl:71 ScanByte.-(ScanByte.maximum(s), ScanByte.minimum(s))
│ for 1 of union split cases, no matching method found for call signatures (Tuple{typeof(-), Nothing, UInt8})): ScanByte.-(ScanByte.maximum(s::ScanByte.ByteSet)::Union{Nothing, UInt8}, ScanByte.minimum(s::ScanByte.ByteSet)::UInt8)
└───────────────────────────────────────────────────────────────────
┌ @ C:\Users\Win10\.julia\packages\ScanByte\BvBXC\src\codegen.jl:204 ScanByte.&(bitmap, ScanByte.bitshift_ones(ScanByte.shrl4(y)))
│┌ @ C:\Users\Win10\.julia\packages\SIMD\h9fcb\src\simdvec.jl:396 Core.apply_type(SIMD.Vec, _, _)(x)
││┌ @ C:\Users\Win10\.julia\packages\SIMD\h9fcb\src\simdvec.jl:20 SIMD.constantvector(v, Core.apply_type(SIMD.Vec, _, _))
│││┌ @ C:\Users\Win10\.julia\packages\SIMD\h9fcb\src\simdvec.jl:15 SIMD._unsafe_convert(_, v)
││││┌ @ C:\Users\Win10\.julia\packages\SIMD\h9fcb\src\simdvec.jl:13 SIMD.%(v, _)
│││││ no matching method found for call signature (Tuple{typeof(rem), Float32, Type{UInt8}}): SIMD.%(v::Float32, _::Type{UInt8})
││││└───────────────────────────────────────────────────────────────
││┌ @ C:\Users\Win10\.julia\packages\SIMD\h9fcb\src\simdvec.jl:20 SIMD.constantvector(v, Core.apply_type(SIMD.Vec, _, _))
│││┌ @ C:\Users\Win10\.julia\packages\SIMD\h9fcb\src\simdvec.jl:15 SIMD._unsafe_convert(_, v)
││││┌ @ C:\Users\Win10\.julia\packages\SIMD\h9fcb\src\simdvec.jl:13 SIMD.%(v, _)
│││││ no matching method found for call signature (Tuple{typeof(rem), Float64, Type{UInt8}}): SIMD.%(v::Float64, _::Type{UInt8})
││││└───────────────────────────────────────────────────────────────
┌ @ C:\Users\Win10\.julia\packages\ScanByte\BvBXC\src\codegen.jl:369 ScanByte.<(ScanByte.maximum(bs), 128)
│┌ @ operators.jl:352 Base.isless(x, y)
││ no matching method found for call signature (Tuple{typeof(isless), Nothing, Int64}): Base.isless(x::Nothing, y::Int64)
│└────────────────────

Unfortunately it breaks 9 tests.

aviatesk · 2021-12-03T11:57:53Z

Yeah, the report indicates JET analyzed ScanByte package correctly by that tweak.

Unfortunately it breaks 9 tests.

Yes, that's why I suggested to interpret entire top-level code only when analyzing a package. When analyzing arbitrary top-level user script, we definitely want to partially-interpret it and some test cases explicitly assert that functionality.

Use optimized JuliaInterpreter frames to support foreign calls. Fixes aviatesk#277 and aviatesk#224, but breaks `eval` tests.

fix #224 fix #281

aviatesk · 2021-12-05T08:41:25Z

@jakobnissen @ericphanson here are some results:

julia> using JET; report_package("ScanByte"):

┌ @ /Users/aviatesk/julia/packages/ScanByte/src/codegen.jl:204 ScanByte.&(bitmap, ScanByte.bitshift_ones(ScanByte.shrl4(y)))
│┌ @ /Users/aviatesk/.julia/packages/SIMD/AgnHl/src/simdvec.jl:396 Core.apply_type(SIMD.Vec, _, _)(x)
││┌ @ /Users/aviatesk/.julia/packages/SIMD/AgnHl/src/simdvec.jl:20 SIMD.constantvector(v, Core.apply_type(SIMD.Vec, _, _))
│││┌ @ /Users/aviatesk/.julia/packages/SIMD/AgnHl/src/simdvec.jl:15 SIMD._unsafe_convert(_, v)
││││┌ @ /Users/aviatesk/.julia/packages/SIMD/AgnHl/src/simdvec.jl:13 SIMD.%(v, _)
│││││ no matching method found for call signature (Tuple{typeof(rem), Float32, Type{UInt8}}): SIMD.%(v::Float32, _::Type{UInt8})
││││└────────────────────────────────────────────────────────────────
││┌ @ /Users/aviatesk/.julia/packages/SIMD/AgnHl/src/simdvec.jl:20 SIMD.constantvector(v, Core.apply_type(SIMD.Vec, _, _))
│││┌ @ /Users/aviatesk/.julia/packages/SIMD/AgnHl/src/simdvec.jl:15 SIMD._unsafe_convert(_, v)
││││┌ @ /Users/aviatesk/.julia/packages/SIMD/AgnHl/src/simdvec.jl:13 SIMD.%(v, _)
│││││ no matching method found for call signature (Tuple{typeof(rem), Float64, Type{UInt8}}): SIMD.%(v::Float64, _::Type{UInt8})
││││└────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/ScanByte/src/codegen.jl:369 ScanByte.<(ScanByte.maximum(bs), 128)
│┌ @ operators.jl:352 Base.isless(x, y)
││ no matching method found for call signature (Tuple{typeof(isless), Nothing, Int64}): Base.isless(x::Nothing, y::Int64)
│└────────────────────

julia> using JET; report_package("Convex")

═════ 149 possible errors found ═════
┌ @ /Users/aviatesk/julia/packages/Convex/src/expressions.jl:68 Convex.error(Base.string("monotonicity not implemented for ", Base.getproperty(x, :head), "."))
│┌ @ error.jl:33 error(::String)
││ may throw: Base.throw(Base.ErrorException(s::String)::ErrorException)
│└───────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/variable.jl:301 Convex.sparse(Convex.*(1.0, Convex.I), vec_size, vec_size)
│┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/SparseArrays/src/sparsematrix.jl:1041 SparseArrays.dimlub(I)
││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/SparseArrays/src/sparsematrix.jl:1037 SparseArrays.isempty(I)
│││┌ @ essentials.jl:790 Base.iterate(itr)
││││ no matching method found for call signature (Tuple{typeof(iterate), LinearAlgebra.UniformScaling{Float64}}): Base.iterate(itr::LinearAlgebra.UniformScaling{Float64})
│││└─────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/conic_form.jl:10 Base.convert(Core.fieldtype(Convex.ConicObj, 1), mapping)
│┌ @ /Users/aviatesk/.julia/packages/OrderedCollections/PRayh/src/ordered_dict.jl:97 Base.depwarn(Base.string("Conversion to OrderedDict is deprecated for unordered associative containers (in this case, ", OrderedCollections.typeof(d), "). Use an ordered or sorted associative type, such as SortedDict and OrderedDict."), :convert)
││┌ @ deprecated.jl:80 Base.#depwarn#922(false, #self#, msg, funcsym)
│││┌ @ deprecated.jl:92 Base.getproperty(Base.getproperty(caller, :linfo), :def)
││││┌ @ Base.jl:38 Base.getfield(x, f)
│││││ type Nothing has no field def
││││└──────────────
││││┌ @ Base.jl:38 Base.getfield(x, f)
│││││ type Core.CodeInfo has no field def
││││└──────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/conic_form.jl:80 x1 = Convex.repeat(Base.getindex(Base.getindex(new_obj, var), 1), vectorized_size, 1)
│ for 1 of union split cases, no matching method found for call signatures (Tuple{typeof(repeat), Number, Int64, Int64})): x1 = Convex.repeat(Base.getindex(Base.getindex(new_obj::Convex.ConicObj, var::UInt64)::Tuple{Union{Number, AbstractArray}, Union{Number, AbstractArray}}, 1)::Union{Number, AbstractArray}, vectorized_size::Int64, 1)
└──────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/conic_form.jl:81 x2 = Convex.repeat(Base.getindex(Base.getindex(new_obj, var), 2), vectorized_size, 1)
│ for 1 of union split cases, no matching method found for call signatures (Tuple{typeof(repeat), Number, Int64, Int64})): x2 = Convex.repeat(Base.getindex(Base.getindex(new_obj::Convex.ConicObj, var::UInt64)::Tuple{Union{Number, AbstractArray}, Union{Number, AbstractArray}}, 2)::Union{Number, AbstractArray}, vectorized_size::Int64, 1)
└──────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/conic_form.jl:111 Base.convert(Core.fieldtype(Convex.UniqueConicForms, 1), exp_map)
│┌ @ /Users/aviatesk/.julia/packages/OrderedCollections/PRayh/src/ordered_dict.jl:103 Base.setindex!(h, OrderedCollections.convert(_, v), ck)
││┌ @ /Users/aviatesk/.julia/packages/OrderedCollections/PRayh/src/ordered_dict.jl:330 Base.setindex!(Base.getproperty(h, :keys), key, index)
│││┌ @ array.jl:963 Base.convert(_, x)
││││┌ @ essentials.jl:338 Base._tuple_error(_, x)
│││││┌ @ essentials.jl:331 Base.throw(Base.MethodError(Base.convert, Core.tuple(T, x)))
││││││ MethodError: Cannot `convert` an object of type 
│││││└─────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:28 goto %12 if not Convex.==(vex, Convex.ConvexVexity())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %12 if not Convex.==(vex::Any, Convex.ConvexVexity()::Convex.ConvexVexity)::Union{Missing, Bool}
└───────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:28 goto %17 if not Convex.==(vex, Convex.ConcaveVexity())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %17 if not Convex.==(vex::Any, Convex.ConcaveVexity()::Convex.ConcaveVexity)::Union{Missing, Bool}
└───────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:36 goto %18 if not Convex.==(Convex.sign(Base.getproperty(c, :lhs)), Convex.ComplexSign())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %18 if not Convex.==(Convex.sign(Base.getproperty(c::Convex.EqConstraint, :lhs::Symbol)::Convex.AbstractExpr)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
└───────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:36 goto %40 if not Convex.!(_11)
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %40 if not Convex.!(_11::Union{Missing, Bool})::Union{Missing, Bool}
└───────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:88 goto %12 if not Convex.==(vex, Convex.ConcaveVexity())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %12 if not Convex.==(vex::Any, Convex.ConcaveVexity()::Convex.ConcaveVexity)::Union{Missing, Bool}
└───────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:140 goto %12 if not Convex.==(vex, Convex.ConcaveVexity())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %12 if not Convex.==(vex::Any, Convex.ConcaveVexity()::Convex.ConcaveVexity)::Union{Missing, Bool}
└────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:169 Convex.+(Base.vect(constraint_one), constraints_two)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:166 Convex.append!(constraints, constraints_two)
││┌ @ array.jl:1106 Base.copyto!(a, Base.+(Base.-(Base.length(a), n), 1), items, Base.first(itemindices), n)
│││┌ @ array.jl:317 Base._copyto_impl!(dest, doffs, src, soffs, n)
││││┌ @ array.jl:331 Base.unsafe_copyto!(dest, doffs, src, soffs, n)
│││││┌ @ array.jl:307 Base._unsafe_copyto!(dest, doffs, src, soffs, n)
││││││┌ @ array.jl:253 Base.getindex(src, Base.-(Base.+(soffs, i), 1))
│││││││┌ @ array.jl:921 Base.arrayref($(Expr(:boundscheck)), A, i1)
││││││││ invalid builtin function call: Base.arrayref($(Expr(:boundscheck)), A::Vector{Union{}}, i1::Int64)
│││││││└────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/soc_constraints.jl:28 Core.typeassert(args, Convex.AbstractExpr)
│ invalid builtin function call: Core.typeassert(args::Tuple{Vararg{Convex.AbstractExpr}}, Convex.AbstractExpr)
└───────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/exp_constraints.jl:26 Base.getproperty(c, :x)
│┌ @ Base.jl:38 Base.getfield(x, f)
││ type Convex.ExpConstraint has no field x
│└──────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/sdp_constraints.jl:25 goto %8 if not Convex.==(vex, Convex.AffineVexity())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %8 if not Convex.==(vex::Any, Convex.AffineVexity()::Convex.AffineVexity)::Union{Missing, Bool}
└───────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/sdp_constraints.jl:25 goto %14 if not Convex.==(vex, Convex.ConstVexity())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %14 if not Convex.==(vex::Any, Convex.ConstVexity()::Convex.ConstVexity)::Union{Missing, Bool}
└───────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problems.jl:60 objective = Convex.conic_form!(objective_var, unique_conic_forms)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/variable_conic_form.jl:7 Convex.evaluate(x)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/variable.jl:107 Convex.output(Convex._value(x))
│││ for 1 of union split cases, no matching method found for call signatures (Tuple{typeof(Convex.output), Nothing})): Convex.output(Convex._value(x::Convex.Variable)::Union{Nothing, Number, AbstractArray})
││└─────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/solution.jl:205 Convex.solve!(problem, optimizer)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/solution.jl:234 Convex.#solve!#17(true, true, false, false, #self#, problem, optimizer)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/solution.jl:246 Convex.load_MOI_model!(model, problem)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/solution.jl:163 var_to_indices = Convex.get_variable_indices!(model, conic_constraints, id_to_variables)
││││┌ @ /Users/aviatesk/julia/packages/Convex/src/solution.jl:138 MathOptInterface.add_variables(model, var_size)
│││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/bridge_optimizer.jl:1669 MathOptInterface.add_constrained_variables(b, MathOptInterface.Reals(n))
││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/bridge_optimizer.jl:1704 MathOptInterface.add_constrained_variables(Base.getproperty(b, :model), set)
│││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/bridge_optimizer.jl:1707 BridgeType = Base.getproperty(MathOptInterface.Bridges.Variable, :concrete_bridge_type)(b, MathOptInterface.Bridges.typeof(set))
││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/lazy_bridge_optimizer.jl:421 index = MathOptInterface.Bridges.bridge_index(b, S)
│││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/lazy_bridge_optimizer.jl:372 MathOptInterface.Bridges.node(b, S)
││││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/lazy_bridge_optimizer.jl:200 MathOptInterface.Bridges.node(b, FF, S)
│││││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/lazy_bridge_optimizer.jl:240 MathOptInterface.Bridges.edge(b, i, MathOptInterface.Bridges.Constraint.concrete_bridge_type(BT, F, S))
││││││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/lazy_bridge_optimizer.jl:129 Base.setindex!(Base._array_for(MathOptInterface.Bridges.VariableNode, MathOptInterface.Bridges.added_constrained_variable_types(BT), Base.IteratorSize(MathOptInterface.Bridges.added_constrained_variable_types(BT))), MathOptInterface.Bridges.node(b, Base.getindex(C, 1)), _6)
│││││││││││││┌ @ array.jl:963 Base.convert(_, x)
││││││││││││││ no matching method found for call signature (Tuple{typeof(convert), Type{MathOptInterface.Bridges.VariableNode}, MathOptInterface.Bridges.ObjectiveNode}): Base.convert(_::Type{MathOptInterface.Bridges.VariableNode}, x::MathOptInterface.Bridges.ObjectiveNode)
│││││││││││││└────────────────
││││││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/lazy_bridge_optimizer.jl:264 Core.typeassert(MathOptInterface.Bridges.edge(b, i, MathOptInterface.Bridges.Objective.concrete_bridge_type(BT, F)), MathOptInterface.Bridges.ObjectiveEdge)
│││││││││││││ invalid builtin function call: Core.typeassert(MathOptInterface.Bridges.edge(b::MathOptInterface.Bridges.LazyBridgeOptimizer, i::Int64, MathOptInterface.Bridges.Objective.concrete_bridge_type::typeof(MathOptInterface.Bridges.Objective.concrete_bridge_type)(BT::Any, F::Type{<:MathOptInterface.AbstractScalarFunction})::Type)::MathOptInterface.Bridges.Edge, MathOptInterface.Bridges.ObjectiveEdge)
││││││││││││└───────────────────────────────────────────────────────────────────────────────────────────────────
││││││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/lazy_bridge_optimizer.jl:264 Core.typeassert(MathOptInterface.Bridges.edge(b, i, MathOptInterface.Bridges.Objective.concrete_bridge_type(BT, F)), MathOptInterface.Bridges.ObjectiveEdge)
│││││││││││││ invalid builtin function call: Core.typeassert(MathOptInterface.Bridges.edge(b::MathOptInterface.Bridges.LazyBridgeOptimizer, i::Int64, MathOptInterface.Bridges.Objective.concrete_bridge_type::typeof(MathOptInterface.Bridges.Objective.concrete_bridge_type)(BT::Type{<:MathOptInterface.Bridges.Objective.FunctionizeBridge}, F::Type{MathOptInterface.VariableIndex})::Type)::MathOptInterface.Bridges.Edge, MathOptInterface.Bridges.ObjectiveEdge)
││││││││││││└───────────────────────────────────────────────────────────────────────────────────────────────────
││││││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/lazy_bridge_optimizer.jl:264 Core.typeassert(MathOptInterface.Bridges.edge(b, i, MathOptInterface.Bridges.Objective.concrete_bridge_type(BT, F)), MathOptInterface.Bridges.ObjectiveEdge)
│││││││││││││ invalid builtin function call: Core.typeassert(MathOptInterface.Bridges.edge(b::MathOptInterface.Bridges.LazyBridgeOptimizer, i::Int64, MathOptInterface.Bridges.Objective.concrete_bridge_type::typeof(MathOptInterface.Bridges.Objective.concrete_bridge_type)(BT::Any, F::Type)::Type)::MathOptInterface.Bridges.Edge, MathOptInterface.Bridges.ObjectiveEdge)
││││││││││││└───────────────────────────────────────────────────────────────────────────────────────────────────
││││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/lazy_bridge_optimizer.jl:209 MathOptInterface.Bridges.node(b, F, S)
│││││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/lazy_bridge_optimizer.jl:240 MathOptInterface.Bridges.edge(b, i, MathOptInterface.Bridges.Constraint.concrete_bridge_type(BT, F, S))
││││││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/lazy_bridge_optimizer.jl:264 Core.typeassert(MathOptInterface.Bridges.edge(b, i, MathOptInterface.Bridges.Objective.concrete_bridge_type(BT, F)), MathOptInterface.Bridges.ObjectiveEdge)
│││││││││││││ invalid builtin function call: Core.typeassert(MathOptInterface.Bridges.edge(b::MathOptInterface.Bridges.LazyBridgeOptimizer, i::Int64, MathOptInterface.Bridges.Objective.concrete_bridge_type::typeof(MathOptInterface.Bridges.Objective.concrete_bridge_type)(BT::Type{<:MathOptInterface.Bridges.Objective.SlackBridge}, F::Type{MathOptInterface.ScalarAffineFunction{_A}} where _A)::Type)::MathOptInterface.Bridges.Edge, MathOptInterface.Bridges.ObjectiveEdge)
││││││││││││└───────────────────────────────────────────────────────────────────────────────────────────────────
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/solution.jl:167 MathOptInterface.set(model, Core.apply_type(MathOptInterface.ObjectiveFunction, Convex.SV_OR_VI)(), Convex.SV_OR_IDENTITY(objective_index))
││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/bridge_optimizer.jl:1007 MathOptInterface.Bridges._delete_objective_bridges(b)
│││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/bridge_optimizer.jl:895 MathOptInterface.delete(b, Base.getproperty(MathOptInterface.Bridges.Objective, :root_bridge)(Base.getproperty(MathOptInterface.Bridges.Objective, :bridges)(b)))
││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/Objective/slack.jl:106 MathOptInterface.delete(model, Base.getproperty(bridge, :slack))
│││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/bridge_optimizer.jl:541 MathOptInterface.Bridges._delete_variables_in_variables_constraints(b, Base.vect(vi))
││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/bridge_optimizer.jl:491 MathOptInterface.Bridges._delete_variables_in_vector_of_variables_constraint(b, vis, ci)
│││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/bridge_optimizer.jl:462 func = MathOptInterface.get(b, MathOptInterface.ConstraintFunction(), ci)
││││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/bridge_optimizer.jl:1155 MathOptInterface.Bridges.unbridged_constraint_function(b, func)
│││││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/bridge_optimizer.jl:1953 MathOptInterface.Bridges.unbridged_function(b, func)
││││││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/bridge_optimizer.jl:1873 MathOptInterface.Utilities.substitute_variables(#56, value)
│││││││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Utilities/functions.jl:339 sub = MathOptInterface.Utilities.substitute_variables(variable_map, Base.getproperty(term, :scalar_term))
││││││││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/bridge_optimizer.jl:1848 func = Base.getproperty(MathOptInterface.Bridges.Variable, :unbridged_function)(Base.getproperty(MathOptInterface.Bridges.Variable, :bridges)(b), vi)
│││││││││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/Variable/map.jl:429 context_func = MathOptInterface.Bridges.Variable.get(Base.getproperty(map, :unbridged_function), vi, MathOptInterface.Bridges.Variable.nothing)
││││││││││││││││ for 1 of union split cases, no matching method found for call signatures (Tuple{typeof(get), Nothing, MathOptInterface.VariableIndex, Nothing})): context_func = MathOptInterface.Bridges.Variable.get(Base.getproperty(map::MathOptInterface.Bridges.Variable.Map, :unbridged_function::Symbol)::Union{Nothing, Dict{MathOptInterface.VariableIndex, Tuple{Int64, MathOptInterface.AbstractScalarFunction}}}, vi::MathOptInterface.VariableIndex, MathOptInterface.Bridges.Variable.nothing)
│││││││││││││││└──────────────────────────────────────────────────────────────────────────────────────────
│││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/bridge_optimizer.jl:555 ci = Base.getproperty(MathOptInterface.Bridges.Variable, :constraint)(Base.getproperty(MathOptInterface.Bridges.Variable, :bridges)(b), vi)
││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/Variable/map.jl:198 F = MathOptInterface.Utilities.variable_function_type(S)
│││││││││ for 1 of union split cases, no matching method found for call signatures (Tuple{typeof(MathOptInterface.Utilities.variable_function_type), Nothing})): F = MathOptInterface.Utilities.variable_function_type::typeof(MathOptInterface.Utilities.variable_function_type)(S::Union{Nothing, Type})
││││││││└──────────────────────────────────────────────────────────────────────────────────────────
││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/bridge_optimizer.jl:1019 MathOptInterface.Bridges._bridge_objective(b, BridgeType, func)
│││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/bridge_optimizer.jl:990 bridge = Base.getproperty(MathOptInterface.Bridges.Objective, :bridge_objective)(BridgeType, MathOptInterface.Bridges.recursive_model(b), func)
││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/Objective/functionize.jl:15 MathOptInterface.set(model, Core.apply_type(MathOptInterface.ObjectiveFunction, F)(), MathOptInterface.Bridges.Objective.convert(F, func))
│││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/bridge_optimizer.jl:1023 MathOptInterface.Bridges.bridged_function(b, func)
││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/bridge_optimizer.jl:1809 MathOptInterface.Utilities.substitute_variables(#54, value)
│││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Utilities/functions.jl:324 new_term = MathOptInterface.Utilities.substitute_variables(variable_map, term)
││││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Utilities/functions.jl:314 variable_map(Base.getproperty(term, :variable))
│││││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/bridge_optimizer.jl:1810 MathOptInterface.Bridges.bridged_variable_function(Core.getfield(#self#, :bridge), vi)
││││││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/bridge_optimizer.jl:1785 MathOptInterface.Bridges.bridge(b, vi)
│││││││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/bridge_optimizer.jl:228 Base.getindex(Base.getproperty(MathOptInterface.Bridges.Variable, :bridges)(b), vi)
││││││││││││││┌ @ abstractdict.jl:531 v = Base.get(t, key, Base.secret_table_token)
│││││││││││││││ no matching method found for call signature (Tuple{typeof(get), MathOptInterface.Bridges.Variable.EmptyMap, MathOptInterface.VariableIndex, Symbol}): v = Base.get(t::MathOptInterface.Bridges.Variable.EmptyMap, key::MathOptInterface.VariableIndex, Base.secret_table_token)
││││││││││││││└───────────────────────
││┌ @ /Users/aviatesk/julia/packages/Convex/src/solution.jl:260 Convex.moi_populate_solution!(model, problem, id_to_variables, conic_constr_to_constr, conic_constraints, var_to_indices, constraint_indices)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/solution.jl:299 vectorized_value = MathOptInterface.get(model, MathOptInterface.VariablePrimal(), var_indices)
││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Bridges/bridge_optimizer.jl:1081 MathOptInterface.get(Base.getproperty(b, :model), attr, indices)
│││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Utilities/cachingoptimizer.jl:871 MathOptInterface.get(Base.getproperty(model, :optimizer), attr, MathOptInterface.Utilities.map(#232, indices))
││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Utilities/cachingoptimizer.jl:871 MathOptInterface.Utilities.map_indices(Base.getproperty(model, :optimizer_to_model_map), attr, Core.typeassert(MathOptInterface.get(Base.getproperty(model, :optimizer), attr, MathOptInterface.Utilities.map(#232, indices)), Core.UnionAll(_6, Core.apply_type(MathOptInterface.Utilities.Vector, _6))))
│││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Utilities/functions.jl:92 MathOptInterface.Utilities.map_indices(f, x)
││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Utilities/functions.jl:109 MathOptInterface.Utilities.map_indices(#1, x)
│││││││││┌ @ /Users/aviatesk/.julia/packages/MathOptInterface/eoIu0/src/Utilities/functions.jl:148 MathOptInterface.Utilities.map(index_map, array)
││││││││││┌ @ abstractarray.jl:2859 Base.collect_similar(A, Base.Generator(f, A))
│││││││││││┌ @ array.jl:713 Base._collect(cont, itr, Base.IteratorEltype(itr), Base.IteratorSize(itr))
││││││││││││┌ @ array.jl:814 Base.collect_to_with_first!(dest, v1, itr, st)
│││││││││││││┌ @ array.jl:825 Base.grow_to!(dest, itr, st)
││││││││││││││┌ @ dict.jl:153 Base.indexed_iterate(Core.getfield(Base.indexed_iterate(y, 1), 1), 1)
│││││││││││││││┌ @ tuple.jl:91 x = Base.iterate(I)
││││││││││││││││ no matching method found for call signature (Tuple{typeof(iterate), MathOptInterface.VariableIndex}): x = Base.iterate(I::MathOptInterface.VariableIndex)
│││││││││││││││└───────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/add_subtract.jl:84 Convex.sum(Base._array_for(Convex.Sign, Base.getproperty(x, :children), Base.IteratorSize(Base.getproperty(x, :children))))
│┌ @ reducedim.jl:889 Base.#sum#747(Base.:, Base.pairs(Core.NamedTuple()), #self#, a)
││┌ @ reducedim.jl:889 Base._sum(a, dims)
│││┌ @ reducedim.jl:893 Base.#_sum#749(Base.pairs(Core.NamedTuple()), #self#, a, _3)
││││┌ @ reducedim.jl:893 Base._sum(Base.identity, a, Base.:)
│││││┌ @ reducedim.jl:894 Base.#_sum#750(Base.pairs(Core.NamedTuple()), #self#, f, a, _4)
││││││┌ @ reducedim.jl:894 Base.mapreduce(f, Base.add_sum, a)
│││││││┌ @ reducedim.jl:322 Base.#mapreduce#740(Base.:, Base._InitialValue(), #self#, f, op, A)
││││││││┌ @ reducedim.jl:322 Base._mapreduce_dim(f, op, init, A, dims)
│││││││││┌ @ reducedim.jl:330 Base._mapreduce(f, op, Base.IndexStyle(A), A)
││││││││││┌ @ reduce.jl:419 Base.mapreduce_empty_iter(f, op, A, Base.IteratorEltype(A))
│││││││││││┌ @ reduce.jl:367 Base.reduce_empty_iter(Base.MappingRF(f, op), itr, ItrEltype)
││││││││││││┌ @ reduce.jl:371 Base.reduce_empty(op, Base.eltype(itr))
│││││││││││││┌ @ reduce.jl:348 Base.mapreduce_empty(Base.getproperty(op, :f), Base.getproperty(op, :rf), _)
││││││││││││││┌ @ reduce.jl:359 Base.reduce_empty(op, T)
│││││││││││││││┌ @ reduce.jl:339 Base.reduce_empty(Base.+, _)
││││││││││││││││┌ @ reduce.jl:330 Base.zero(_)
│││││││││││││││││ no matching method found for call signature (Tuple{typeof(zero), Type{Convex.Sign}}): Base.zero(_::Type{Convex.Sign})
││││││││││││││││└─────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/multiply_divide.jl:45 goto %15 if not Convex.!=(Convex.vexity(Base.getindex(Base.getproperty(x, :children), 1)), Convex.ConstVexity())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %15 if not Convex.!=(Convex.vexity(Base.getindex(Base.getproperty(x::Convex.MultiplyAtom, :children::Symbol)::Tuple{Convex.AbstractExpr, Convex.AbstractExpr}, 1)::Convex.AbstractExpr)::Any, Convex.ConstVexity()::Convex.ConstVexity)::Union{Missing, Bool}
└────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/multiply_divide.jl:45 goto %15 if not Convex.!=(Convex.vexity(Base.getindex(Base.getproperty(x, :children), 2)), Convex.ConstVexity())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %15 if not Convex.!=(Convex.vexity(Base.getindex(Base.getproperty(x::Convex.MultiplyAtom, :children::Symbol)::Tuple{Convex.AbstractExpr, Convex.AbstractExpr}, 2)::Convex.AbstractExpr)::Any, Convex.ConstVexity()::Convex.ConstVexity)::Union{Missing, Bool}
└────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/multiply_divide.jl:60 goto %32 if not Convex.==(Convex.vexity(Base.getindex(Base.getproperty(x, :children), 1)), Convex.ConstVexity())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %32 if not Convex.==(Convex.vexity(Base.getindex(Base.getproperty(x::Convex.MultiplyAtom, :children::Symbol)::Tuple{Convex.AbstractExpr, Convex.AbstractExpr}, 1)::Convex.AbstractExpr)::Any, Convex.ConstVexity()::Convex.ConstVexity)::Union{Missing, Bool}
└────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/multiply_divide.jl:63 goto %43 if not Convex.==(Convex.vexity(Base.getindex(Base.getproperty(x, :children), 2)), Convex.ConstVexity())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %43 if not Convex.==(Convex.vexity(Base.getindex(Base.getproperty(x::Convex.MultiplyAtom, :children::Symbol)::Tuple{Convex.AbstractExpr, Convex.AbstractExpr}, 2)::Convex.AbstractExpr)::Any, Convex.ConstVexity()::Convex.ConstVexity)::Union{Missing, Bool}
└────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/multiply_divide.jl:82 goto %78 if not Convex.==(Convex.vexity(Base.getindex(Base.getproperty(x, :children), 1)), Convex.ConstVexity())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %78 if not Convex.==(Convex.vexity(Base.getindex(Base.getproperty(x::Convex.MultiplyAtom, :children::Symbol)::Tuple{Convex.AbstractExpr, Convex.AbstractExpr}, 1)::Convex.AbstractExpr)::Any, Convex.ConstVexity()::Convex.ConstVexity)::Union{Missing, Bool}
└────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/multiply_divide.jl:136 goto %9 if not Convex.==(Convex.vexity(Base.getindex(Base.getproperty(x, :children), 1)), Convex.ConstVexity())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %9 if not Convex.==(Convex.vexity(Base.getindex(Base.getproperty(x::Convex.DotMultiplyAtom, :children::Symbol)::Tuple{Convex.AbstractExpr, Convex.AbstractExpr}, 1)::Convex.AbstractExpr)::Any, Convex.ConstVexity()::Convex.ConstVexity)::Union{Missing, Bool}
└─────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/multiply_divide.jl:149 goto %30 if not Convex.!=(Convex.vexity(Base.getindex(Base.getproperty(x, :children), 1)), Convex.ConstVexity())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %30 if not Convex.!=(Convex.vexity(Base.getindex(Base.getproperty(x::Convex.DotMultiplyAtom, :children::Symbol)::Tuple{Convex.AbstractExpr, Convex.AbstractExpr}, 1)::Convex.AbstractExpr)::Any, Convex.ConstVexity()::Convex.ConstVexity)::Union{Missing, Bool}
└─────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/multiply_divide.jl:150 goto %22 if not Convex.!=(Convex.vexity(Base.getindex(Base.getproperty(x, :children), 2)), Convex.ConstVexity())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %22 if not Convex.!=(Convex.vexity(Base.getindex(Base.getproperty(x::Convex.DotMultiplyAtom, :children::Symbol)::Tuple{Convex.AbstractExpr, Convex.AbstractExpr}, 2)::Convex.AbstractExpr)::Any, Convex.ConstVexity()::Convex.ConstVexity)::Union{Missing, Bool}
└─────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/multiply_divide.jl:154 Base.setindex!(Base.getproperty(x, :children), Base.getindex(Base.getproperty(x, :children), 2), 1)
│ no matching method found for call signature (Tuple{typeof(setindex!), Tuple{Convex.AbstractExpr, Convex.AbstractExpr}, Convex.AbstractExpr, Int64}): Base.setindex!(Base.getproperty(x::Convex.DotMultiplyAtom, :children::Symbol)::Tuple{Convex.AbstractExpr, Convex.AbstractExpr}, Base.getindex(Base.getproperty(x::Convex.DotMultiplyAtom, :children::Symbol)::Tuple{Convex.AbstractExpr, Convex.AbstractExpr}, 2)::Convex.AbstractExpr, 1)
└─────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/stack.jl:27 Base.collect(Base.Generator(#29, Base.getproperty(x, :children)))
│┌ @ array.jl:794 Base.collect_to_with_first!(dest, v1, itr, st)
││┌ @ array.jl:825 Base.grow_to!(dest, itr, st)
│││┌ @ dict.jl:153 Base.indexed_iterate(Core.getfield(Base.indexed_iterate(y, 1), 1), 1)
││││┌ @ tuple.jl:91 x = Base.iterate(I)
│││││ no matching method found for call signature (Tuple{typeof(iterate), Convex.Nondecreasing}): x = Base.iterate(I::Convex.Nondecreasing)
││││└───────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/partialtranspose.jl:39 Convex.partialtranspose(Convex.evaluate(Base.getindex(Base.getproperty(x, :children), 1)))
│ no matching method found for call signature (Tuple{typeof(Convex.partialtranspose), Any}): Convex.partialtranspose(Convex.evaluate(Base.getindex(Base.getproperty(x::Convex.PartialTransposeAtom, :children::Symbol)::Tuple{Convex.AbstractExpr}, 1)::Convex.AbstractExpr)::Any)
└─────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/partialtranspose.jl:80 Convex.reshape(Convex.Matrix(Convex.I, d, d), Core.tuple(dims, dims...))
│┌ @ reshapedarray.jl:48 Base.==(dims, Base.size(a))
││┌ @ tuple.jl:398 Base._eq(t1, t2)
│││┌ @ tuple.jl:408 Base._eq(Base.tail(t1), Base.tail(t2))
││││┌ @ tuple.jl:408 Base._eq(Base.tail(t1), Base.tail(t2))
│││││┌ @ tuple.jl:402 Base.getindex(t2, 1)
││││││┌ @ tuple.jl:29 Base.getfield(t, i, $(Expr(:boundscheck)))
│││││││ invalid builtin function call: Base.getfield(t::Tuple{}, i::Int64, $(Expr(:boundscheck)))
││││││└───────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/partialtranspose.jl:80 Convex.reshape(Convex.PermutedDimsArray(Convex.reshape(Convex.Matrix(Convex.I, d, d), Core.tuple(dims, dims...)), Core.tuple(p, Convex.:(Convex.+(n, 1), Convex.*(2, n))...)), Core.tuple(d, d))
│┌ @ reshapedarray.jl:119 Base._reshape_uncolon(parent, dims)
││┌ @ reshapedarray.jl:125 pre = Base._before_colon(dims...)
│││┌ @ reshapedarray.jl:135 Base._before_colon(tail...)
││││┌ @ reshapedarray.jl:135 Base._before_colon(tail...)
│││││ no matching method found for call signature (Tuple{typeof(Base._before_colon)}): Base._before_colon(tail::Tuple{}...)
││││└────────────────────────
││┌ @ reshapedarray.jl:126 post = Base._after_colon(dims...)
│││┌ @ reshapedarray.jl:137 Base._after_colon(tail...)
││││┌ @ reshapedarray.jl:137 Base._after_colon(tail...)
│││││ no matching method found for call signature (Tuple{typeof(Base._after_colon)}): Base._after_colon(tail::Tuple{}...)
││││└────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/real_imag.jl:23 goto %9 if not Convex.==(Convex.sign(Base.getindex(Base.getproperty(x, :children), 1)), Convex.ComplexSign())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %9 if not Convex.==(Convex.sign(Base.getindex(Base.getproperty(x::Convex.RealAtom, :children::Symbol)::Tuple{Convex.AbstractExpr}, 1)::Convex.AbstractExpr)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
└──────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/inner_product.jl:3 Convex.*(Convex.'(x), y)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/multiply_divide.jl:97 Convex.square(x)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/second_order_cone/qol_elementwise.jl:58 goto %7 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
│││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %7 if not Convex.==(Convex.sign(x::Convex.AdjointAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
││└───────────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/abs.jl:44 goto %44 if not Convex.==(Convex.sign(Base.getindex(Base.getproperty(x, :children), 1)), Convex.ComplexSign())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %44 if not Convex.==(Convex.sign(Base.getindex(Base.getproperty(x::Convex.AbsAtom, :children::Symbol)::Tuple{Convex.AbstractExpr}, 1)::Convex.AbstractExpr)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
└─────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/max.jl:40 goto %12 if not Convex.==(sign_one, Convex.Positive())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %12 if not Convex.==(sign_one::Any, Convex.Positive()::Convex.Positive)::Union{Missing, Bool}
└─────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/max.jl:40 goto %18 if not Convex.==(sign_two, Convex.Positive())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %18 if not Convex.==(sign_two::Any, Convex.Positive()::Convex.Positive)::Union{Missing, Bool}
└─────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/max.jl:42 goto %28 if not Convex.==(sign_one, Convex.Negative())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %28 if not Convex.==(sign_one::Any, Convex.Negative()::Convex.Negative)::Union{Missing, Bool}
└─────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/max.jl:42 goto %28 if not Convex.==(sign_two, Convex.Negative())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %28 if not Convex.==(sign_two::Any, Convex.Negative()::Convex.Negative)::Union{Missing, Bool}
└─────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/max.jl:81 Convex.pos(Convex.-(1, x))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/max.jl:80 Convex.max(x, Convex.Constant(0, Convex.Positive()))
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/max.jl:77 Convex.MaxAtom(x, y)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/max.jl:18 goto %8 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
││││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %8 if not Convex.==(Convex.sign(x::Convex.AdditionAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
│││└─────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/min.jl:40 goto %12 if not Convex.==(sign_one, Convex.Negative())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %12 if not Convex.==(sign_one::Any, Convex.Negative()::Convex.Negative)::Union{Missing, Bool}
└─────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/min.jl:40 goto %18 if not Convex.==(sign_two, Convex.Negative())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %18 if not Convex.==(sign_two::Any, Convex.Negative()::Convex.Negative)::Union{Missing, Bool}
└─────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/min.jl:42 goto %28 if not Convex.==(sign_one, Convex.Positive())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %28 if not Convex.==(sign_one::Any, Convex.Positive()::Convex.Positive)::Union{Missing, Bool}
└─────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/min.jl:42 goto %28 if not Convex.==(sign_two, Convex.Positive())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %28 if not Convex.==(sign_two::Any, Convex.Positive()::Convex.Positive)::Union{Missing, Bool}
└─────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/min.jl:80 Convex.max(Convex.-(x), Convex.Constant(0, Convex.Positive()))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/max.jl:77 Convex.MaxAtom(x, y)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/max.jl:18 goto %8 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
│││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %8 if not Convex.==(Convex.sign(x::Convex.NegateAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
││└─────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/sumlargest.jl:64 Convex.SumLargestAtom(Convex.-(x), k)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/sumlargest.jl:16 goto %10 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %10 if not Convex.==(Convex.sign(x::Convex.NegateAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
│└────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/second_order_cone/norm.jl:6 Convex.norm2(Convex.vec(x))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/second_order_cone/norm2.jl:52 goto %10 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %10 if not Convex.==(Convex.sign(x::Convex.ReshapeAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
│└─────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/second_order_cone/quadform.jl:21 Convex.+(A, Convex.*(tol, Convex.I))
│┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/SparseArrays/src/sparsematrix.jl:3824 SparseArrays.+(A, SparseArrays.sparse(Core.tuple(J), SparseArrays.size(A)...))
││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/SparseArrays/src/sparsematrix.jl:1829 SparseArrays.map(SparseArrays.+, A, B)
│││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/SparseArrays/src/higherorderfns.jl:1162 SparseArrays.HigherOrderFns._noshapecheck_map(Core.tuple(f, SparseArrays.HigherOrderFns._sparsifystructured(A)), SparseArrays.HigherOrderFns.map(SparseArrays.HigherOrderFns._sparsifystructured, Bs)...)
││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/SparseArrays/src/higherorderfns.jl:165 SparseArrays.HigherOrderFns._zeros_eltypes(Core.tuple(A), Bs...)
│││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/SparseArrays/src/higherorderfns.jl:210 SparseArrays.HigherOrderFns.zero(SparseArrays.HigherOrderFns.eltype(A))
││││││┌ @ missing.jl:106 Base.throw(Base.MethodError(Base.zero, Core.tuple(Base.Any)))
│││││││ MethodError: no method matching zero(::Type{Any})
││││││└──────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/second_order_cone/quadform.jl:21 Convex.isposdef(Convex.+(A, Convex.*(tol, Convex.I)))
│┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/dense.jl:92 Core.kwfunc(LinearAlgebra.cholesky)(Core.apply_type(Core.NamedTuple, (:check,))(Core.tuple(false)), LinearAlgebra.cholesky, LinearAlgebra.Hermitian(A))
││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/cholesky.jl:397 #s866(_2, _3, A, LinearAlgebra.Val(false))
│││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/cholesky.jl:397 LinearAlgebra.#cholesky#159(check, _3, A, _5)
││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/cholesky.jl:397 LinearAlgebra.cholcopy(A)
│││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/cholesky.jl:180 LinearAlgebra.copy_oftype(A, LinearAlgebra.choltype(A))
││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/LinearAlgebra.jl:375 LinearAlgebra.copyto!(LinearAlgebra.similar(A, _), A)
│││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/symmetric.jl:299 LinearAlgebra.adjoint!(Base.getproperty(dest, :data), Base.getproperty(src, :data))
││││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/transpose.jl:76 LinearAlgebra.transpose_f!(LinearAlgebra.adjoint, B, A)
│││││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/transpose.jl:104 Base.getindex(A, i, j)
││││││││││┌ @ reinterpretarray.jl:321 Base.check_readable(a)
│││││││││││┌ @ reinterpretarray.jl:169 Base.array_subpadding(_, _)
││││││││││││┌ @ reinterpretarray.jl:653 Base.CyclePadding(S)
│││││││││││││┌ @ reinterpretarray.jl:644 pad = Base.padding(T)
││││││││││││││┌ @ reinterpretarray.jl:632 fT = Base.fieldtype(T, i)
│││││││││││││││ invalid builtin function call: fT = Base.fieldtype(T::Type{T} where T<:Float16, i::Int64)
││││││││││││││└───────────────────────────
││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/cholesky.jl:394 #s866(_2, _3, A, LinearAlgebra.Val(false))
│││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/cholesky.jl:394 LinearAlgebra.#cholesky#158(check, _3, A, _5)
││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/cholesky.jl:394 LinearAlgebra.cholcopy(A)
│││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/cholesky.jl:180 LinearAlgebra.choltype(A)
││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/cholesky.jl:179 LinearAlgebra.oneunit(LinearAlgebra.eltype(A))
│││││││┌ @ missing.jl:106 Base.throw(Base.MethodError(Base.oneunit, Core.tuple(Base.Any)))
││││││││ MethodError: no method matching oneunit(::Type{Any})
│││││││└──────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/second_order_cone/quadform.jl:24 A_ = Convex.Symmetric(Convex.+(Convex.sparse(Convex.UpperTriangular(A)), Convex.*(tol, Convex.I)))
│┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/symmetric.jl:179 LinearAlgebra.Symmetric(A, LinearAlgebra.sym_uplo(Base.getproperty(A, :uplo)))
││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/symmetric.jl:182 LinearAlgebra.diagind(Base.getproperty(A, :data))
│││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/dense.jl:224 #self#(A, 0)
││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/dense.jl:225 LinearAlgebra.diagind(LinearAlgebra.size(A, 1), LinearAlgebra.size(A, 2), k)
│││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/dense.jl:201 Core.kwfunc(LinearAlgebra.range)(Core.apply_type(Core.NamedTuple, (:step, :length))(Core.tuple(LinearAlgebra.+(m, 1), LinearAlgebra.min(LinearAlgebra.+(m, k), n))), LinearAlgebra.range, LinearAlgebra.-(1, k))
││││││┌ @ range.jl:138 Base.#range#62(stop, length, step, _3, start)
│││││││┌ @ range.jl:138 Base._range(start, step, stop, length)
││││││││┌ @ range.jl:159 Base.range_start_step_length(start, step, len)
│││││││││┌ @ range.jl:188 Base.range_start_step_length(Base.float(a), step, len)
││││││││││┌ @ twiceprecision.jl:468 Base.floatrange(_, start_n, step_n, len, den)
│││││││││││┌ @ twiceprecision.jl:388 Base.round(Base.typeof(len), Base.+(Base./(Base.-(start_n), step_n), 1))
││││││││││││┌ @ missing.jl:144 #self#(_2, x, Base.RoundNearest)
│││││││││││││┌ @ missing.jl:144 Base.round(Base.nonmissingtype_checked(_), x, r)
││││││││││││││┌ @ floatfuncs.jl:125 Base.trunc(_, x)
│││││││││││││││ no matching method found for call signature (Tuple{typeof(trunc), Type{Union{}}, Float64}): Base.trunc(_::Type{Union{}}, x::Float64)
││││││││││││││└─────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/second_order_cone/quadform.jl:56 P = Convex.sqrt(Convex.Hermitian(Convex.*(factor, A)))
│┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/symmetric.jl:841 LinearAlgebra.#sqrt#149(LinearAlgebra.*(LinearAlgebra.eps(LinearAlgebra.real(LinearAlgebra.float(LinearAlgebra.one(_)))), LinearAlgebra.size(A, 1)), #self#, A)
││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/symmetric.jl:842 F = LinearAlgebra.eigen(A)
│││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/symmetriceigen.jl:8 LinearAlgebra.#eigen#206(LinearAlgebra.nothing, #self#, A)
││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/symmetriceigen.jl:9 S = LinearAlgebra.eigtype(T)
│││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/eigen.jl:310 LinearAlgebra.zero(T)
││││││ no matching method found for call signature (Tuple{typeof(zero), Type{Union{}}}): LinearAlgebra.zero(T::Type{Union{}})
│││││└──────────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/second_order_cone/power_to_socp.jl:80 Convex.psocp.ReducePowers(init_inequality, Core.apply_type(Convex.psocp.Array, Convex.psocp.SimpleInequalityExpression)(Convex.psocp.undef, 0), var_list)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/second_order_cone/power_to_socp.jl:119 Convex.psocp.vcat(ineq_array, new_ineq)
││┌ @ abstractarray.jl:1778 Core.kwfunc(Base.cat)(Core.tuple(Core.apply_type(Core.NamedTuple, (:dims,))(Core.tuple(Base.Val(1))), Base.cat), X...)
│││┌ @ abstractarray.jl:1867 Base.#cat#147(Core.tuple(dims, _3), A...)
││││┌ @ abstractarray.jl:1867 Base._cat(Core.tuple(dims), A...)
│││││┌ @ abstractarray.jl:1709 Core.kwfunc(Base.cat_t)(Core.tuple(Core.apply_type(Core.NamedTuple, (:dims,))(Core.tuple(dims)), Base.cat_t, Base.promote_eltypeof(X...)), X...)
││││││┌ @ abstractarray.jl:1711 Base.#cat_t#142(Core.tuple(dims, _3, _4), X...)
│││││││┌ @ abstractarray.jl:1711 Base._cat_t(Core.tuple(dims, _), X...)
││││││││┌ @ abstractarray.jl:1717 Base.zero(_)
│││││││││ no matching method found for call signature (Tuple{typeof(zero), Type{Convex.psocp.SimpleInequalityExpression}}): Base.zero(_::Type{Convex.psocp.SimpleInequalityExpression})
││││││││└─────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/nuclearnorm.jl:63 Convex.cache_conic_form!(unique_conic_forms, x, p)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/problems.jl:106 Base.getproperty(p, :objective)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/problems.jl:33 MathOptInterface.get(Base.getproperty(p, :model), MathOptInterface.ObjectiveValue())
│││ no matching method found for call signature (Tuple{typeof(MathOptInterface.get), Nothing, MathOptInterface.ObjectiveValue}): MathOptInterface.get::typeof(MathOptInterface.get)(Base.getproperty(p::Convex.Problem{Float64}, :model::Symbol)::Nothing, MathOptInterface.ObjectiveValue::Type{MathOptInterface.ObjectiveValue}()::MathOptInterface.ObjectiveValue)
││└────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/operatornorm.jl:49 Convex.maximum(Core.kwfunc(Convex.sum)(Core.apply_type(Core.NamedTuple, (:dims,))(Core.tuple(1)), Convex.sum, Convex.abs(x)))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/maximum.jl:57 Convex.MaximumAtom(x)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/maximum.jl:17 goto %10 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
│││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %10 if not Convex.==(Convex.sign(x::Convex.MultiplyAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
││└─────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/eig_min_max.jl:58 Convex.⪰(Convex.-(Convex.*(t, Convex.Matrix(Convex.*(1.0, Convex.I), n, n)), A), 0)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/sdp_constraints.jl:116 goto %6 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %6 if not Convex.==(Convex.sign(x::Convex.AdditionAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
│└────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/geom_mean_hypocone.jl:96 goto %36 if not Convex.==(vex, Convex.ConcaveVexity())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %36 if not Convex.==(vex::Any, Convex.ConcaveVexity()::Convex.ConcaveVexity)::Union{Missing, Bool}
└─────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/geom_mean_hypocone.jl:110 goto %34 if not Convex.==(Convex.sign(A), Convex.ComplexSign())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %34 if not Convex.==(Convex.sign(A::Convex.AbstractExpr)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
└──────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/geom_mean_hypocone.jl:110 goto %40 if not Convex.==(Convex.sign(B), Convex.ComplexSign())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %40 if not Convex.==(Convex.sign(B::Convex.AbstractExpr)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
└──────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/geom_mean_hypocone.jl:111 goto %52 if not is_complex
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %52 if not is_complex::Union{Missing, Bool}
└──────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/geom_mean_epicone.jl:89 goto %36 if not Convex.==(vex, Convex.ConcaveVexity())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %36 if not Convex.==(vex::Any, Convex.ConcaveVexity()::Convex.ConcaveVexity)::Union{Missing, Bool}
└────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/geom_mean_epicone.jl:101 goto %26 if not Convex.==(Convex.sign(A), Convex.ComplexSign())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %26 if not Convex.==(Convex.sign(A::Convex.AbstractExpr)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
└─────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/geom_mean_epicone.jl:101 goto %32 if not Convex.==(Convex.sign(B), Convex.ComplexSign())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %32 if not Convex.==(Convex.sign(B::Convex.AbstractExpr)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
└─────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/geom_mean_epicone.jl:102 goto %44 if not is_complex
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %44 if not is_complex::Union{Missing, Bool}
└─────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/relative_entropy_epicone.jl:90 goto %36 if not Convex.==(vex, Convex.ConcaveVexity())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %36 if not Convex.==(vex::Any, Convex.ConcaveVexity()::Convex.ConcaveVexity)::Union{Missing, Bool}
└───────────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/relative_entropy_epicone.jl:103 Convex.eigen(T)
│┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/eigen.jl:235 LinearAlgebra.#eigen#97(true, true, LinearAlgebra.eigsortby, #self#, A)
││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/eigen.jl:237 Core.kwfunc(LinearAlgebra.eigen!)(Core.apply_type(Core.NamedTuple, (:permute, :scale, :sortby))(Core.tuple(permute, scale, sortby)), LinearAlgebra.eigen!, AA)
│││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/eigen.jl:172 LinearAlgebra.#eigen!#96(permute, scale, sortby, _3, A)
││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/eigen.jl:175 LinearAlgebra.LAPACK.geevx!(_11, 'N', 'V', 'N', A)
│││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/lapack.jl:2200 LinearAlgebra.LAPACK.chkfinite(A)
││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/lapack.jl:89  = Base.iterate(A, Core.getfield(_3, 2))
│││││││┌ @ abstractarray.jl:1148 y = Base.iterate(state...)
││││││││┌ @ multidimensional.jl:412 Base.getproperty(state, :I)
│││││││││┌ @ Base.jl:38 Base.getfield(x, f)
││││││││││ type Int64 has no field I
│││││││││└──────────────
││││││││┌ @ range.jl:882 Base.+(i, Base.step(r))
│││││││││ no matching method found for call signature (Tuple{typeof(+), CartesianIndex{2}, Int64}): Base.+(i::CartesianIndex{2}, Base.step(r::Base.OneTo{Int64})::Int64)
││││││││└────────────────
│││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/eigen.jl:149 LinearAlgebra.#eigen!#95(permute, scale, sortby, _3, A)
││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/eigen.jl:158 Base.setindex!(evec, LinearAlgebra.view(VR, LinearAlgebra.:, j), LinearAlgebra.:, j)
│││││┌ @ abstractarray.jl:1321 Base._setindex!(Core.tuple(Base.IndexStyle(A), A, v), Base.to_indices(A, I)...)
││││││┌ @ multidimensional.jl:918 Base._unsafe_setindex!(Core.tuple(l, Base._maybe_reshape(Core.tuple(l, A), I...), x), I...)
│││││││┌ @ multidimensional.jl:928 Xy = Base.iterate(x′)
││││││││┌ @ abstractarray.jl:1148 #self#(A, Core.tuple(Base.eachindex(A)))
│││││││││┌ @ multidimensional.jl:610 Base.indexed_iterate(_3, 2, _4)
││││││││││┌ @ tuple.jl:88 Base.getfield(t, i)
│││││││││││ invalid builtin function call: Base.getfield(t::Tuple{Any}, i::Int64)
││││││││││└───────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/relative_entropy_epicone.jl:124 goto %48 if not Convex.==(Convex.sign(X), Convex.ComplexSign())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %48 if not Convex.==(Convex.sign(X::Convex.AbstractExpr)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
└────────────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/relative_entropy_epicone.jl:124 goto %54 if not Convex.==(Convex.sign(Y), Convex.ComplexSign())
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %54 if not Convex.==(Convex.sign(Y::Convex.AbstractExpr)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
└────────────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/relative_entropy_epicone.jl:125 goto %71 if not is_complex
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %71 if not is_complex::Union{Missing, Bool}
└────────────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/exp_cone/logsumexp.jl:52 Convex.exp(Convex.-(Base.getindex(Base.getproperty(e, :children), 1), t))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/exp_cone/exp.jl:43 Convex.ExpAtom(x)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/exp_cone/exp.jl:18 goto %8 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
│││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %8 if not Convex.==(Convex.sign(x::Convex.AdditionAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
││└──────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/exp_cone/logsumexp.jl:64 Convex.logsumexp(Base.vcat(e, 0))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/exp_cone/logsumexp.jl:46 Convex.LogSumExpAtom(x)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/exp_cone/logsumexp.jl:19 goto %8 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
│││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %8 if not Convex.==(Convex.sign(x::Convex.TransposeAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
││└────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/exp_cone/relative_entropy.jl:41 goto %11 if not Convex.any(Convex.isnan, y)
│ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %11 if not Convex.any(Convex.isnan, y::Any)::Union{Missing, Bool}
└───────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/Test/src/Test.jl:479 Convex.ProblemDepot.evaluate(Convex.ProblemDepot.-(x))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/add_subtract.jl:36 Convex.evaluate(Base.getindex(Base.getproperty(x, :children), 1))
││┌ @ /Users/aviatesk/julia/packages/Convex/src/variable.jl:107 Convex.output(Convex._value(x))
│││ for 1 of union split cases, no matching method found for call signatures (Tuple{typeof(Convex.output), Nothing})): Convex.output(Convex._value(x::Convex.Variable)::Union{Nothing, Number, AbstractArray})
││└─────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/affine.jl:39 Convex.ProblemDepot.>=(Convex.ProblemDepot.*(A, x), Base.vcat(1.1, 1.1))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:158 Convex.>=(lhs, Convex.Constant(rhs))
││┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:157 Convex.GtConstraint(lhs, rhs)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:122 goto %8 if not Convex.==(Convex.sign(lhs), Convex.ComplexSign())
││││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %8 if not Convex.==(Convex.sign(lhs::Convex.MultiplyAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
│││└────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/affine.jl:55 Convex.ProblemDepot.<=(k, x)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:105 Convex.LtConstraint(lhs, rhs)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:70 goto %8 if not Convex.==(Convex.sign(lhs), Convex.ComplexSign())
│││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %8 if not Convex.==(Convex.sign(lhs::Convex.MultiplyAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
││└───────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/affine.jl:55 Convex.ProblemDepot.<=(x, z)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:105 Convex.LtConstraint(lhs, rhs)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:70 goto %17 if not Convex.==(Convex.sign(rhs), Convex.ComplexSign())
│││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %17 if not Convex.==(Convex.sign(rhs::Convex.MultiplyAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
││└───────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/affine.jl:77 p = Core.kwfunc(Convex.ProblemDepot.minimize)(Core.apply_type(Core.NamedTuple, (:numeric_type,))(Core.tuple(_)), Convex.ProblemDepot.minimize, Convex.ProblemDepot.real(Convex.ProblemDepot.*(Convex.ProblemDepot.'(Base.vect(Convex.ProblemDepot.*(1.0, Convex.ProblemDepot.im), 0.0)), x, Base.vect(Convex.ProblemDepot.*(1.0, Convex.ProblemDepot.im), 0.0))), Base.vect(Convex.ProblemDepot.==(x, Base.hvcat(Core.tuple(2, 2), 1.0, 0.0, 0.0, 1.0))))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/problems.jl:74 Convex.#minimize#6(numeric_type, _3, objective, constraints)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/problems.jl:74 Core.apply_type(Convex.Problem, numeric_type)(:minimize, objective, constraints)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/problems.jl:10 Convex.sign(objective)
││││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/real_imag.jl:23 goto %9 if not Convex.==(Convex.sign(Base.getindex(Base.getproperty(x, :children), 1)), Convex.ComplexSign())
│││││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %9 if not Convex.==(Convex.sign(Base.getindex(Base.getproperty(x::Convex.RealAtom, :children::Symbol)::Tuple{Convex.MultiplyAtom}, 1)::Convex.MultiplyAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
││││└──────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/affine.jl:87 Convex.ProblemDepot.dot(Base.vcat(2.0, 2.0), x)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/dot.jl:14 Convex._vecdot(x, y)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/dot.jl:11 Convex.broadcast(Convex.*, Convex.asvec(x), Convex.asvec(y))
│││┌ @ broadcast.jl:798 Base.Broadcast.broadcasted(Core.tuple(f), As...)
││││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/multiply_divide.jl:185 Convex.DotMultiplyAtom(x, Convex.*(y, Convex.ones(1, Convex.size(x, 1))))
│││││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/multiply_divide.jl:120 Base.string("cannot compute ", x, " .* ", y, ": sizes are not compatible")
││││││┌ @ strings/io.jl:185 Base.print_to_string(xs...)
│││││││┌ @ strings/io.jl:144 Base.print(s, x)
││││││││┌ @ strings/io.jl:35 Base.show(io, x)
│││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/show.jl:147 Convex.print_tree_rstrip(io, e)
││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/show.jl:114 str = Convex.sprint(Convex.TreePrint.print_tree, x, Base.getindex(Convex.MAXDEPTH), Base.getindex(Convex.MAXWIDTH))
│││││││││││┌ @ strings/io.jl:108 Base.#sprint#436(Core.tuple(Base.nothing, 0, #self#, f), args...)
││││││││││││┌ @ strings/io.jl:114 f(Core.tuple(s), args...)
│││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/show.jl:142 Convex.#print_tree#65(Core.tuple(Base.pairs(Core.NamedTuple()), #self#, io, e), args...)
││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/show.jl:142 Convex.TreePrint.print_tree(Core.tuple(io, Convex.ExprRoot(e)), args...)
│││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/tree_print.jl:112 Convex.TreePrint.#print_tree#5(Core.tuple(Base.pairs(Core.NamedTuple()), #self#, io, tree), args...)
││││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/tree_print.jl:112 Convex.TreePrint.print_tree(Core.tuple(Convex.TreePrint.printnode, io, tree), args...)
│││││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/tree_print.jl:111 Convex.TreePrint.#print_tree#4(Core.tuple(Base.pairs(Core.NamedTuple()), #self#, f, io, tree), args...)
││││││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/tree_print.jl:111 Convex.TreePrint._print_tree(Core.tuple(f, io, tree), args...)
│││││││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/tree_print.jl:66 Convex.TreePrint.#_print_tree#1(0, Base.getindex(Convex.TreePrint.Int), Convex.TreePrint.TreeCharSet(), false, Base.vect(), Convex.TreePrint.nothing, Convex.TreePrint.nothing, tree, #self#, printnode, io, tree, maxdepth, maxwidth)
││││││││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/tree_print.jl:71 printnode(nodebuf, tree)
│││││││││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/show.jl:144 AbstractTrees.printnode(io, Base.getproperty(e, :expr))
││││││││││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/tree_interface.jl:14 Convex.summary(io, node)
│││││││││││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/show.jl:74 Convex.vexity(e)
││││││││││││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/expressions.jl:57 vex = Convex.curvature(x)
│││││││││││││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/multiply_divide.jl:45 goto %15 if not Convex.!=(Convex.vexity(Base.getindex(Base.getproperty(x, :children), 1)), Convex.ConstVexity())
││││││││││││││││││││││││││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %15 if not Convex.!=(Convex.vexity(Base.getindex(Base.getproperty(x::Convex.MultiplyAtom, :children::Symbol)::Tuple{Convex.AbstractExpr, Convex.AbstractExpr}, 1)::Convex.AbstractExpr)::Any, Convex.ConstVexity()::Convex.ConstVexity)::Union{Missing, Bool}
│││││││││││││││││││││││││└────────────────────────────────────────────────────────────────────────────────
│││││││││││││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/multiply_divide.jl:45 goto %15 if not Convex.!=(Convex.vexity(Base.getindex(Base.getproperty(x, :children), 2)), Convex.ConstVexity())
││││││││││││││││││││││││││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %15 if not Convex.!=(Convex.vexity(Base.getindex(Base.getproperty(x::Convex.MultiplyAtom, :children::Symbol)::Tuple{Convex.AbstractExpr, Convex.AbstractExpr}, 2)::Convex.AbstractExpr)::Any, Convex.ConstVexity()::Convex.ConstVexity)::Union{Missing, Bool}
│││││││││││││││││││││││││└────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/affine.jl:116 p = Core.kwfunc(Convex.ProblemDepot.minimize)(Core.apply_type(Core.NamedTuple, (:numeric_type,))(Core.tuple(_)), Convex.ProblemDepot.minimize, Convex.ProblemDepot.+(x, y), Base.vect(Convex.ProblemDepot.>=(x, 3), Convex.ProblemDepot.>=(y, 2)))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/problems.jl:74 Convex.#minimize#6(numeric_type, _3, objective, constraints)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/problems.jl:74 Core.apply_type(Convex.Problem, numeric_type)(:minimize, objective, constraints)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/problems.jl:10 Convex.sign(objective)
││││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/add_subtract.jl:84 Convex.sum(Base._array_for(Convex.Sign, Base.getproperty(x, :children), Base.IteratorSize(Base.getproperty(x, :children))))
│││││┌ @ reducedim.jl:889 Base.#sum#747(Base.:, Base.pairs(Core.NamedTuple()), #self#, a)
││││││┌ @ reducedim.jl:889 Base._sum(a, dims)
│││││││┌ @ reducedim.jl:893 Base.#_sum#749(Base.pairs(Core.NamedTuple()), #self#, a, _3)
││││││││┌ @ reducedim.jl:893 Base._sum(Base.identity, a, Base.:)
│││││││││┌ @ reducedim.jl:894 Base.#_sum#750(Base.pairs(Core.NamedTuple()), #self#, f, a, _4)
││││││││││┌ @ reducedim.jl:894 Base.mapreduce(f, Base.add_sum, a)
│││││││││││┌ @ reducedim.jl:322 Base.#mapreduce#740(Base.:, Base._InitialValue(), #self#, f, op, A)
││││││││││││┌ @ reducedim.jl:322 Base._mapreduce_dim(f, op, init, A, dims)
│││││││││││││┌ @ reducedim.jl:330 Base._mapreduce(f, op, Base.IndexStyle(A), A)
││││││││││││││┌ @ reduce.jl:419 Base.mapreduce_empty_iter(f, op, A, Base.IteratorEltype(A))
│││││││││││││││┌ @ reduce.jl:367 Base.reduce_empty_iter(Base.MappingRF(f, op), itr, ItrEltype)
││││││││││││││││┌ @ reduce.jl:371 Base.reduce_empty(op, Base.eltype(itr))
│││││││││││││││││┌ @ reduce.jl:348 Base.mapreduce_empty(Base.getproperty(op, :f), Base.getproperty(op, :rf), _)
││││││││││││││││││┌ @ reduce.jl:359 Base.reduce_empty(op, T)
│││││││││││││││││││┌ @ reduce.jl:339 Base.reduce_empty(Base.+, _)
││││││││││││││││││││┌ @ reduce.jl:330 Base.zero(_)
│││││││││││││││││││││ no matching method found for call signature (Tuple{typeof(zero), Type{Convex.Sign}}): Base.zero(_::Type{Convex.Sign})
││││││││││││││││││││└─────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/affine.jl:128 Convex.ProblemDepot.>=(Convex.ProblemDepot.+(Convex.ProblemDepot.eye(2), x), Convex.ProblemDepot.eye(2))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:158 Convex.>=(lhs, Convex.Constant(rhs))
││┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:157 Convex.GtConstraint(lhs, rhs)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:122 goto %8 if not Convex.==(Convex.sign(lhs), Convex.ComplexSign())
││││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %8 if not Convex.==(Convex.sign(lhs::Convex.AdditionAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
│││└────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/affine.jl:214 Convex.ProblemDepot.sum(Base.getindex(x, I))
│┌ @ reducedim.jl:889 Base.#sum#747(Base.:, Base.pairs(Core.NamedTuple()), #self#, a)
││┌ @ reducedim.jl:889 Base._sum(a, dims)
│││┌ @ reducedim.jl:893 Base.#_sum#749(Base.pairs(Core.NamedTuple()), #self#, a, _3)
││││┌ @ reducedim.jl:893 Base._sum(Base.identity, a, Base.:)
│││││┌ @ reducedim.jl:894 Base.#_sum#750(Base.pairs(Core.NamedTuple()), #self#, f, a, _4)
││││││┌ @ reducedim.jl:894 Base.mapreduce(f, Base.add_sum, a)
│││││││┌ @ reducedim.jl:322 Base.#mapreduce#740(Base.:, Base._InitialValue(), #self#, f, op, A)
││││││││┌ @ reducedim.jl:322 Base._mapreduce_dim(f, op, init, A, dims)
│││││││││┌ @ reducedim.jl:330 Base._mapreduce(f, op, Base.IndexStyle(A), A)
││││││││││┌ @ reduce.jl:419 Base.mapreduce_empty_iter(f, op, A, Base.IteratorEltype(A))
│││││││││││┌ @ reduce.jl:367 Base.reduce_empty_iter(Base.MappingRF(f, op), itr, ItrEltype)
││││││││││││┌ @ reduce.jl:371 Base.reduce_empty(op, Base.eltype(itr))
│││││││││││││┌ @ reduce.jl:348 Base.mapreduce_empty(Base.getproperty(op, :f), Base.getproperty(op, :rf), _)
││││││││││││││┌ @ reduce.jl:359 Base.reduce_empty(op, T)
│││││││││││││││┌ @ reduce.jl:339 Base.reduce_empty(Base.+, _)
││││││││││││││││┌ @ reduce.jl:330 Base.zero(_)
│││││││││││││││││ no matching method found for call signature (Tuple{typeof(zero), Type{Convex.IndexAtom}}): Base.zero(_::Type{Convex.IndexAtom})
││││││││││││││││└─────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/affine.jl:349 Convex.ProblemDepot.>=(Convex.ProblemDepot.dot(Convex.ProblemDepot.*)(3, x), 3)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:158 Convex.>=(lhs, Convex.Constant(rhs))
││┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:157 Convex.GtConstraint(lhs, rhs)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:122 goto %8 if not Convex.==(Convex.sign(lhs), Convex.ComplexSign())
││││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %8 if not Convex.==(Convex.sign(lhs::Convex.DotMultiplyAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
│││└────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/affine.jl:398 Base.broadcasted(Convex.ProblemDepot.*, Base.broadcasted(Convex.ProblemDepot.*, 2.0, x), Convex.ProblemDepot.ones(Convex.ProblemDepot.Int, 5))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/multiply_divide.jl:205 Convex.DotMultiplyAtom(Convex.Constant(y), x)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/multiply_divide.jl:120 Base.string("cannot compute ", x, " .* ", y, ": sizes are not compatible")
│││┌ @ strings/io.jl:185 Base.print_to_string(xs...)
││││┌ @ strings/io.jl:144 Base.print(s, x)
│││││┌ @ strings/io.jl:35 Base.show(io, x)
││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/show.jl:147 Convex.print_tree_rstrip(io, e)
│││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/show.jl:114 str = Convex.sprint(Convex.TreePrint.print_tree, x, Base.getindex(Convex.MAXDEPTH), Base.getindex(Convex.MAXWIDTH))
││││││││┌ @ strings/io.jl:108 Base.#sprint#436(Core.tuple(Base.nothing, 0, #self#, f), args...)
│││││││││┌ @ strings/io.jl:114 f(Core.tuple(s), args...)
││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/show.jl:142 Convex.#print_tree#65(Core.tuple(Base.pairs(Core.NamedTuple()), #self#, io, e), args...)
│││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/show.jl:142 Convex.TreePrint.print_tree(Core.tuple(io, Convex.ExprRoot(e)), args...)
││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/tree_print.jl:112 Convex.TreePrint.#print_tree#5(Core.tuple(Base.pairs(Core.NamedTuple()), #self#, io, tree), args...)
│││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/tree_print.jl:112 Convex.TreePrint.print_tree(Core.tuple(Convex.TreePrint.printnode, io, tree), args...)
││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/tree_print.jl:111 Convex.TreePrint.#print_tree#4(Core.tuple(Base.pairs(Core.NamedTuple()), #self#, f, io, tree), args...)
│││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/tree_print.jl:111 Convex.TreePrint._print_tree(Core.tuple(f, io, tree), args...)
││││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/tree_print.jl:66 Convex.TreePrint.#_print_tree#1(0, Base.getindex(Convex.TreePrint.Int), Convex.TreePrint.TreeCharSet(), false, Base.vect(), Convex.TreePrint.nothing, Convex.TreePrint.nothing, tree, #self#, printnode, io, tree, maxdepth, maxwidth)
│││││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/tree_print.jl:71 printnode(nodebuf, tree)
││││││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/show.jl:144 AbstractTrees.printnode(io, Base.getproperty(e, :expr))
│││││││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/tree_interface.jl:14 Convex.summary(io, node)
││││││││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/show.jl:74 Convex.vexity(e)
│││││││││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/expressions.jl:57 vex = Convex.curvature(x)
││││││││││││││││││││││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/multiply_divide.jl:136 goto %9 if not Convex.==(Convex.vexity(Base.getindex(Base.getproperty(x, :children), 1)), Convex.ConstVexity())
│││││││││││││││││││││││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %9 if not Convex.==(Convex.vexity(Base.getindex(Base.getproperty(x::Convex.DotMultiplyAtom, :children::Symbol)::Tuple{Convex.AbstractExpr, Convex.AbstractExpr}, 1)::Convex.AbstractExpr)::Any, Convex.ConstVexity()::Convex.ConstVexity)::Union{Missing, Bool}
││││││││││││││││││││││└─────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/affine.jl:451 Convex.ProblemDepot.<=(Base.hcat(x, y, Convex.ProblemDepot.fill(2.0, Core.tuple(4, 2))), 2)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:106 Convex.<=(lhs, Convex.Constant(rhs))
││┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:105 Convex.LtConstraint(lhs, rhs)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:70 goto %8 if not Convex.==(Convex.sign(lhs), Convex.ComplexSign())
││││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %8 if not Convex.==(Convex.sign(lhs::Convex.HcatAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
│││└───────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/affine.jl:469 Convex.ProblemDepot.<=(Base.vcat(x, Convex.ProblemDepot.'(y)), 2)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:106 Convex.<=(lhs, Convex.Constant(rhs))
││┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:105 Convex.LtConstraint(lhs, rhs)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:70 goto %8 if not Convex.==(Convex.sign(lhs), Convex.ComplexSign())
││││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %8 if not Convex.==(Convex.sign(lhs::Convex.TransposeAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
│││└───────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/Test/src/Test.jl:479 Base.hvcat(Core.tuple(2, 2), y, Convex.ProblemDepot.*(4, Convex.ProblemDepot.eye(4)), x, Convex.ProblemDepot.-(Convex.ProblemDepot.ones(4, 6)))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/stack.jl:131 Base.getindex(args, Convex.:(a, Convex.+(Convex.-(a, 1), Base.getindex(rows, i))))
││┌ @ range.jl:410 Base.ntuple(#65, Base.length(r))
│││┌ @ ntuple.jl:19  = Base._ntuple(f, n)
││││┌ @ ntuple.jl:37 Base.collect(Base.Generator(#186, Base.:(1, n)))
│││││┌ @ array.jl:794 Base.collect_to_with_first!(dest, v1, itr, st)
││││││┌ @ array.jl:819 Base.setindex!(dest, v1, i1)
│││││││┌ @ array.jl:963 Base.convert(_, x)
││││││││ no matching method found for call signature (Tuple{typeof(convert), Type{Matrix{Float64}}, Convex.Variable}): Base.convert(_::Type{Matrix{Float64}}, x::Convex.Variable)
│││││││└────────────────
││││││┌ @ array.jl:819 Base.setindex!(dest, v1, i1)
│││││││┌ @ array.jl:963 Base.convert(_, x)
││││││││ no matching method found for call signature (Tuple{typeof(convert), Type{Convex.Variable}, Matrix{Float64}}): Base.convert(_::Type{Convex.Variable}, x::Matrix{Float64})
│││││││└────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/affine.jl:506 Test.do_test_throws(_23, $(QuoteNode(:(Diagonal(x)))), Convex.ProblemDepot.ArgumentError)
│┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/Test/src/Test.jl:755 goto %39 if not from_macroexpand
││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %39 if not from_macroexpand::Union{Missing, Bool}
│└────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/affine.jl:665 Convex.ProblemDepot.partialtranspose(Rt3, 3, dims)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/partialtranspose.jl:107 Convex.PartialTransposeAtom(x, sys, dim)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/partialtranspose.jl:16 Convex.ArgumentError("Invalid system, should between 1 and ", Convex.length(dims), "; got ", sys)
│││ no matching method found for call signature (Tuple{Type{ArgumentError}, String, Int64, String, Int64}): Convex.ArgumentError("Invalid system, should between 1 and ", Convex.length(dims::Vector{Int64})::Int64, "; got ", sys::Int64)
││└─────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/Test/src/Test.jl:479 Convex.ProblemDepot.*(c, β)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/multiply_divide.jl:97 Convex.square(x)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/second_order_cone/qol_elementwise.jl:58 goto %7 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
│││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %7 if not Convex.==(Convex.sign(x::Convex.MultiplyAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
││└───────────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/constant.jl:83 prob = Core.kwfunc(Convex.ProblemDepot.minimize)(Core.apply_type(Core.NamedTuple, (:numeric_type,))(Core.tuple(_)), Convex.ProblemDepot.minimize, Convex.ProblemDepot.real(Convex.ProblemDepot.*(x, y)), Base.vect(Convex.ProblemDepot.>=(y, 0.5), Convex.ProblemDepot.>=(Convex.ProblemDepot.real(x), 0.5), Convex.ProblemDepot.>=(Convex.ProblemDepot.imag(x), 0)))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/problems.jl:74 Convex.#minimize#6(numeric_type, _3, objective, constraints)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/problems.jl:74 Core.apply_type(Convex.Problem, numeric_type)(:minimize, objective, constraints)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/problems.jl:10 Convex.sign(objective)
││││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/real_imag.jl:23 goto %9 if not Convex.==(Convex.sign(Base.getindex(Base.getproperty(x, :children), 1)), Convex.ComplexSign())
│││││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %9 if not Convex.==(Convex.sign(Base.getindex(Base.getproperty(x::Convex.RealAtom, :children::Symbol)::Union{Tuple{Convex.MultiplyAtom}, Tuple{Convex.QolElemAtom}}, 1)::Union{Convex.MultiplyAtom, Convex.QolElemAtom})::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
││││└──────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/exp.jl:100 Convex.ProblemDepot.logisticloss(y)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/exp_cone/logsumexp.jl:66 Convex.logsumexp(Base.vcat(Base.getindex(e, i), 0))
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/exp_cone/logsumexp.jl:46 Convex.LogSumExpAtom(x)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/exp_cone/logsumexp.jl:19 goto %8 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
││││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %8 if not Convex.==(Convex.sign(x::Convex.TransposeAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
│││└────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/Test/src/Test.jl:479 Convex.ProblemDepot.maximum(Convex.ProblemDepot.max(x, y))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/maximum.jl:57 Convex.MaximumAtom(x)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/maximum.jl:17 goto %10 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
│││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %10 if not Convex.==(Convex.sign(x::Convex.MaxAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
││└─────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/Test/src/Test.jl:479 Convex.ProblemDepot.minimum(Convex.ProblemDepot.min(x, y))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/minimum.jl:57 Convex.MinimumAtom(x)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/minimum.jl:17 goto %10 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
│││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %10 if not Convex.==(Convex.sign(x::Convex.MinAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
││└─────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/lp.jl:139 Convex.ProblemDepot.neg(x)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/min.jl:80 Convex.max(Convex.-(x), Convex.Constant(0, Convex.Positive()))
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/max.jl:77 Convex.MaxAtom(x, y)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/max.jl:18 goto %8 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
││││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %8 if not Convex.==(Convex.sign(x::Convex.NegateAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
│││└─────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/lp.jl:139 Convex.ProblemDepot.<=(Convex.ProblemDepot.neg(x), 3)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:106 Convex.<=(lhs, Convex.Constant(rhs))
││┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:105 Convex.LtConstraint(lhs, rhs)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:70 Convex.sign(lhs)
││││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/max.jl:40 goto %12 if not Convex.==(sign_one, Convex.Positive())
│││││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %12 if not Convex.==(sign_one::Any, Convex.Positive()::Convex.Positive)::Union{Missing, Bool}
││││└─────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/lp.jl:179 Convex.ProblemDepot.>=(Convex.ProblemDepot.sumsmallest(x, 4), 1)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:158 Convex.>=(lhs, Convex.Constant(rhs))
││┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:157 Convex.GtConstraint(lhs, rhs)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/constraints.jl:122 goto %8 if not Convex.==(Convex.sign(lhs), Convex.ComplexSign())
││││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %8 if not Convex.==(Convex.sign(lhs::Convex.NegateAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
│││└────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/Test/src/Test.jl:479 Convex.ProblemDepot.sumsmallest(x, 3)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/sumlargest.jl:64 Convex.SumLargestAtom(Convex.-(x), k)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/sumlargest.jl:16 goto %10 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
│││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %10 if not Convex.==(Convex.sign(x::Convex.NegateAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
││└────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/sdp.jl:408 objective = Convex.ProblemDepot.norm2(Convex.ProblemDepot.-(a, x))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/second_order_cone/norm2.jl:52 goto %10 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %10 if not Convex.==(Convex.sign(x::Convex.AdditionAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
│└─────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/Test/src/Test.jl:479 Convex.ProblemDepot.^(A, Convex.ProblemDepot.//(-5, 3))
│┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/dense.jl:463 LinearAlgebra.sqrt(A)
││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/dense.jl:858 goto %58 if not is_sqrt_real
│││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %58 if not is_sqrt_real::Union{Missing, Bool}
││└──────────────────────────────────────────────────────────────────────────────────────────
││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/dense.jl:862 LinearAlgebra.sqrt(LinearAlgebra.UpperTriangular(Base.getproperty(SchurS, :T)))
│││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/triangular.jl:2301 LinearAlgebra.sqrt_quasitriu(A)
││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/triangular.jl:2327 LinearAlgebra.#sqrt_quasitriu#65(_3, #self#, A0)
│││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/triangular.jl:2353 Core.kwfunc(LinearAlgebra._sqrt_quasitriu!)(Core.apply_type(Core.NamedTuple, (:blockwidth, :n))(Core.tuple(blockwidth, n)), LinearAlgebra._sqrt_quasitriu!, R, A)
││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/triangular.jl:2369 LinearAlgebra.#_sqrt_quasitriu!#66(blockwidth, n, _3, R, A)
│││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/triangular.jl:2370 LinearAlgebra._sqrt_quasitriu_block!(R, A)
││││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/triangular.jl:2390 LinearAlgebra._sqrt_quasitriu_diag_block!(R, A)
│││││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/triangular.jl:2405 LinearAlgebra._sqrt_real_2x2!(maybeview(R, LinearAlgebra.:(i, LinearAlgebra.+(i, 1)), LinearAlgebra.:(i, LinearAlgebra.+(i, 1))), maybeview(A, LinearAlgebra.:(i, LinearAlgebra.+(i, 1)), LinearAlgebra.:(i, LinearAlgebra.+(i, 1))))
││││││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/triangular.jl:2453 α = LinearAlgebra._real_sqrt(θ, μ)
│││││││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/triangular.jl:2465 LinearAlgebra.≥(θ, 0)
││││││││││││┌ @ operators.jl:425 Base.<=(y, x)
│││││││││││││┌ @ operators.jl:401 Base.<(x, y)
││││││││││││││┌ @ operators.jl:352 Base.isless(x, y)
│││││││││││││││ no matching method found for call signature (Tuple{typeof(isless), Int64, ComplexF64}): Base.isless(x::Int64, y::ComplexF64)
││││││││││││││└────────────────────
│┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/dense.jl:470 R = LinearAlgebra.^(S, LinearAlgebra.floor(p))
││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/dense.jl:509 LinearAlgebra.^(LinearAlgebra.Hermitian(A), p)
│││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/symmetric.jl:708 LinearAlgebra.integerpow(A, p)
││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/dense.jl:454 LinearAlgebra.^(_5, LinearAlgebra.Integer(p))
│││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/symmetric.jl:698 LinearAlgebra.inv(A)
││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/generic.jl:1038 LinearAlgebra.factorize(LinearAlgebra.convert(Core.apply_type(LinearAlgebra.AbstractMatrix, S), A))
│││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/SparseArrays/src/linalg.jl:1627 F = Core.kwfunc(SparseArrays.cholesky)(Core.apply_type(Core.NamedTuple, (:check,))(Core.tuple(false)), SparseArrays.cholesky, A)
││││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/cholesky.jl:394 #s866(_2, _3, A, LinearAlgebra.Val(false))
│││││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/cholesky.jl:394 LinearAlgebra.#cholesky#158(check, _3, A, _5)
││││││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/cholesky.jl:394 LinearAlgebra.cholcopy(A)
│││││││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/cholesky.jl:180 LinearAlgebra.copy_oftype(A, LinearAlgebra.choltype(A))
││││││││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/LinearAlgebra.jl:375 LinearAlgebra.similar(A, _)
│││││││││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/symmetric.jl:250 LinearAlgebra.parent(A)
││││││││││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/symmetric.jl:275 Base.getproperty(A, :data)
│││││││││││││││┌ @ Base.jl:38 Base.getfield(x, f)
││││││││││││││││ type LinearAlgebra.Hermitian{ComplexF64, Union{}} has no field data
│││││││││││││││└──────────────
││││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/cholesky.jl:394 #s866(_2, _3, A, LinearAlgebra.Val(false))
│││││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/cholesky.jl:394 LinearAlgebra.#cholesky#158(check, _3, A, _5)
││││││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/cholesky.jl:394 LinearAlgebra.cholcopy(A)
│││││││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/cholesky.jl:180 LinearAlgebra.copy_oftype(A, LinearAlgebra.choltype(A))
││││││││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/LinearAlgebra.jl:375 LinearAlgebra.similar(A, _)
│││││││││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/symmetric.jl:250 LinearAlgebra.parent(A)
││││││││││││││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/symmetric.jl:275 Base.getproperty(A, :data)
│││││││││││││││┌ @ Base.jl:38 Base.getfield(x, f)
││││││││││││││││ type LinearAlgebra.Hermitian{Float64, Union{}} has no field data
│││││││││││││││└──────────────
│┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/dense.jl:513 LinearAlgebra.schurpow(A, p)
│││┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/LinearAlgebra/src/dense.jl:463 LinearAlgebra.sqrt(A)
││││ no matching method found for call signature (Tuple{typeof(sqrt), LinearAlgebra.Symmetric{ComplexF64, Matrix{ComplexF64}}}): LinearAlgebra.sqrt(A::LinearAlgebra.Symmetric{ComplexF64, Matrix{ComplexF64}})
│││└──────────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/sdp.jl:867 Convex.ProblemDepot.quantum_relative_entropy(Convex.ProblemDepot.zeros(2, 3), Convex.ProblemDepot.zeros(2, 3))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:121 #self#(A, B, 0, 0, 1.0e-6)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:138 Convex.Hermitian(A)
│││ for 2 of union split cases, no matching method found for call signatures (Tuple{Type{LinearAlgebra.Hermitian}, Float64}, Tuple{Type{LinearAlgebra.Hermitian}, Vector{Float64}})): Convex.Hermitian(A::Union{Float64, VecOrMat{Float64}})
││└────────────────────────────────────────────────────────────────────────────────────────────
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:142 Convex.Hermitian(B)
│││ for 2 of union split cases, no matching method found for call signatures (Tuple{Type{LinearAlgebra.Hermitian}, Float64}, Tuple{Type{LinearAlgebra.Hermitian}, Vector{Float64}})): Convex.Hermitian(B::Union{Float64, VecOrMat{Float64}})
││└────────────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/sdp.jl:868 Convex.ProblemDepot.quantum_relative_entropy(Convex.ProblemDepot.zeros(2, 3), Convex.ProblemDepot.Variable(2, 3))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:115 #self#(A, B, 3, 3)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:116 Convex.quantum_entropy(A, m, k)
│││ for 2 of union split cases, no matching method found for call signatures (Tuple{typeof(Convex.quantum_entropy), Float64, Int64, Int64}, Tuple{typeof(Convex.quantum_entropy), Vector{Float64}, Int64, Int64})): Convex.quantum_entropy(A::Union{Float64, VecOrMat{Float64}}, m::Int64, k::Int64)
││└────────────────────────────────────────────────────────────────────────────────────────────
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:116 Convex.trace_logm(B, A, m, k)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/trace_logm.jl:75 Convex.TraceLogm(X, Convex.evaluate(C), m, k)
││││ for 2 of union split cases, no matching method found for call signatures (Tuple{Type{Convex.TraceLogm}, Convex.Variable, Float64, Int64, Int64}, Tuple{Type{Convex.TraceLogm}, Convex.Variable, Vector{Float64}, Int64, Int64})): Convex.TraceLogm(X::Convex.Variable, Convex.evaluate(C::Matrix{Float64})::Union{Float64, VecOrMat{Float64}}, m::Int64, k::Int64)
│││└─────────────────────────────────────────────────────────────────────────────
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:116 Convex.trace_logm(B, A, m, k)
│││ for 2 of union split cases, no matching method found for call signatures (Tuple{typeof(Convex.trace_logm), Convex.Variable, Float64, Int64, Int64}, Tuple{typeof(Convex.trace_logm), Convex.Variable, Vector{Float64}, Int64, Int64})): Convex.trace_logm(B::Convex.Variable, A::Union{Float64, VecOrMat{Float64}}, m::Int64, k::Int64)
││└────────────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/sdp.jl:869 Convex.ProblemDepot.quantum_relative_entropy(Convex.ProblemDepot.Variable(2, 3), Convex.ProblemDepot.zeros(2, 3))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:110 #self#(A, B, 3, 3, 1.0e-6)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:110 Convex.QuantumRelativeEntropy2(A, Convex.evaluate(B), m, k, nullspace_tol)
│││ for 2 of union split cases, no matching method found for call signatures (Tuple{Type{Convex.QuantumRelativeEntropy2}, Convex.Variable, Float64, Int64, Int64, Float64}, Tuple{Type{Convex.QuantumRelativeEntropy2}, Convex.Variable, Vector{Float64}, Int64, Int64, Float64})): Convex.QuantumRelativeEntropy2(A::Convex.Variable, Convex.evaluate(B::Matrix{Float64})::Union{Float64, VecOrMat{Float64}}, m::Int64, k::Int64, nullspace_tol::Float64)
││└────────────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/sdp.jl:881 Convex.ProblemDepot.quantum_relative_entropy(z, nh)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:121 #self#(A, B, 0, 0, 1.0e-6)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:142 Convex.Hermitian(B)
│││ for 2 of union split cases, no matching method found for call signatures (Tuple{Type{LinearAlgebra.Hermitian}, Int64}, Tuple{Type{LinearAlgebra.Hermitian}, Vector{Int64}})): Convex.Hermitian(B::Union{Int64, VecOrMat{Int64}})
││└────────────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/sdp.jl:883 Convex.ProblemDepot.quantum_relative_entropy(nh, z)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:121 #self#(A, B, 0, 0, 1.0e-6)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:138 Convex.Hermitian(A)
│││ for 2 of union split cases, no matching method found for call signatures (Tuple{Type{LinearAlgebra.Hermitian}, Int64}, Tuple{Type{LinearAlgebra.Hermitian}, Vector{Int64}})): Convex.Hermitian(A::Union{Int64, VecOrMat{Int64}})
││└────────────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/sdp.jl:885 Convex.ProblemDepot.quantum_relative_entropy(v, nh)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:110 #self#(A, B, 3, 3, 1.0e-6)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:110 Convex.QuantumRelativeEntropy2(A, Convex.evaluate(B), m, k, nullspace_tol)
│││ for 2 of union split cases, no matching method found for call signatures (Tuple{Type{Convex.QuantumRelativeEntropy2}, Convex.Variable, Int64, Int64, Int64, Float64}, Tuple{Type{Convex.QuantumRelativeEntropy2}, Convex.Variable, Vector{Int64}, Int64, Int64, Float64})): Convex.QuantumRelativeEntropy2(A::Convex.Variable, Convex.evaluate(B::Matrix{Int64})::Union{Int64, VecOrMat{Int64}}, m::Int64, k::Int64, nullspace_tol::Float64)
││└────────────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/sdp.jl:887 Convex.ProblemDepot.quantum_relative_entropy(nh, v)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:115 #self#(A, B, 3, 3)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:116 Convex.quantum_entropy(A, m, k)
│││ for 2 of union split cases, no matching method found for call signatures (Tuple{typeof(Convex.quantum_entropy), Int64, Int64, Int64}, Tuple{typeof(Convex.quantum_entropy), Vector{Int64}, Int64, Int64})): Convex.quantum_entropy(A::Union{Int64, VecOrMat{Int64}}, m::Int64, k::Int64)
││└────────────────────────────────────────────────────────────────────────────────────────────
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:116 Convex.trace_logm(B, A, m, k)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/trace_logm.jl:75 Convex.TraceLogm(X, Convex.evaluate(C), m, k)
││││ for 2 of union split cases, no matching method found for call signatures (Tuple{Type{Convex.TraceLogm}, Convex.Variable, Int64, Int64, Int64}, Tuple{Type{Convex.TraceLogm}, Convex.Variable, Vector{Int64}, Int64, Int64})): Convex.TraceLogm(X::Convex.Variable, Convex.evaluate(C::Matrix{Int64})::Union{Int64, VecOrMat{Int64}}, m::Int64, k::Int64)
│││└─────────────────────────────────────────────────────────────────────────────
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:116 Convex.trace_logm(B, A, m, k)
│││ for 2 of union split cases, no matching method found for call signatures (Tuple{typeof(Convex.trace_logm), Convex.Variable, Int64, Int64, Int64}, Tuple{typeof(Convex.trace_logm), Convex.Variable, Vector{Int64}, Int64, Int64})): Convex.trace_logm(B::Convex.Variable, A::Union{Int64, VecOrMat{Int64}}, m::Int64, k::Int64)
││└────────────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/sdp.jl:914 objective = Convex.ProblemDepot.quantum_relative_entropy(X, B)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:115 #self#(A, B, 3, 3)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:116 Convex.quantum_entropy(A, m, k)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_entropy.jl:70 Convex.quantum_relative_entropy(X, Convex.Matrix(Convex.*(1.0, Convex.I), Convex.size(X)))
││││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:121 #self#(A, B, 0, 0, 1.0e-6)
│││││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:138 Convex.Hermitian(A)
││││││ for 2 of union split cases, no matching method found for call signatures (Tuple{Type{LinearAlgebra.Hermitian}, ComplexF64}, Tuple{Type{LinearAlgebra.Hermitian}, Vector{ComplexF64}})): Convex.Hermitian(A::Union{VecOrMat{ComplexF64}, ComplexF64})
│││││└────────────────────────────────────────────────────────────────────────────────────────────
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:116 Convex.quantum_entropy(A, m, k)
│││ for 2 of union split cases, no matching method found for call signatures (Tuple{typeof(Convex.quantum_entropy), ComplexF64, Int64, Int64}, Tuple{typeof(Convex.quantum_entropy), Vector{ComplexF64}, Int64, Int64})): Convex.quantum_entropy(A::Union{VecOrMat{ComplexF64}, ComplexF64}, m::Int64, k::Int64)
││└────────────────────────────────────────────────────────────────────────────────────────────
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:116 Convex.trace_logm(B, A, m, k)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/trace_logm.jl:75 Convex.TraceLogm(X, Convex.evaluate(C), m, k)
││││ for 2 of union split cases, no matching method found for call signatures (Tuple{Type{Convex.TraceLogm}, Convex.Variable, ComplexF64, Int64, Int64}, Tuple{Type{Convex.TraceLogm}, Convex.Variable, Vector{ComplexF64}, Int64, Int64})): Convex.TraceLogm(X::Convex.Variable, Convex.evaluate(C::Matrix{ComplexF64})::Union{VecOrMat{ComplexF64}, ComplexF64}, m::Int64, k::Int64)
│││└─────────────────────────────────────────────────────────────────────────────
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:116 Convex.trace_logm(B, A, m, k)
│││ for 2 of union split cases, no matching method found for call signatures (Tuple{typeof(Convex.trace_logm), Convex.Variable, ComplexF64, Int64, Int64}, Tuple{typeof(Convex.trace_logm), Convex.Variable, Vector{ComplexF64}, Int64, Int64})): Convex.trace_logm(B::Convex.Variable, A::Union{VecOrMat{ComplexF64}, ComplexF64}, m::Int64, k::Int64)
││└────────────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/sdp.jl:918 objective = Convex.ProblemDepot.quantum_relative_entropy(B, X)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:110 #self#(A, B, 3, 3, 1.0e-6)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:110 Convex.QuantumRelativeEntropy2(A, Convex.evaluate(B), m, k, nullspace_tol)
│││ for 2 of union split cases, no matching method found for call signatures (Tuple{Type{Convex.QuantumRelativeEntropy2}, Convex.Variable, ComplexF64, Int64, Int64, Float64}, Tuple{Type{Convex.QuantumRelativeEntropy2}, Convex.Variable, Vector{ComplexF64}, Int64, Int64, Float64})): Convex.QuantumRelativeEntropy2(A::Convex.Variable, Convex.evaluate(B::Matrix{ComplexF64})::Union{VecOrMat{ComplexF64}, ComplexF64}, m::Int64, k::Int64, nullspace_tol::Float64)
││└────────────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/sdp.jl:920 objective = Convex.ProblemDepot.quantum_relative_entropy(X, X)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:121 #self#(A, B, 0, 0, 1.0e-6)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/quantum_relative_entropy.jl:142 Convex.Hermitian(B)
│││ for 2 of union split cases, no matching method found for call signatures (Tuple{Type{LinearAlgebra.Hermitian}, ComplexF64}, Tuple{Type{LinearAlgebra.Hermitian}, Vector{ComplexF64}})): Convex.Hermitian(B::Union{VecOrMat{ComplexF64}, ComplexF64})
││└────────────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/sdp.jl:1045 Convex.ProblemDepot.trace_mpower(Convex.ProblemDepot.Variable(3, 3), Convex.ProblemDepot.//(5, 2), Convex.ProblemDepot.zeros(3, 3))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/trace_mpower.jl:73 Convex.TraceMpower(A, t, Convex.evaluate(C))
││ for 2 of union split cases, no matching method found for call signatures (Tuple{Type{Convex.TraceMpower}, Convex.Variable, Rational{Int64}, Float64}, Tuple{Type{Convex.TraceMpower}, Convex.Variable, Rational{Int64}, Vector{Float64}})): Convex.TraceMpower(A::Convex.Variable, t::Rational{Int64}, Convex.evaluate(C::Matrix{Float64})::Union{Float64, VecOrMat{Float64}})
│└───────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/sdp.jl:1050 Convex.ProblemDepot.trace_mpower(Convex.ProblemDepot.Variable(2, 2), Convex.ProblemDepot.//(1, 2), np)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/trace_mpower.jl:73 Convex.TraceMpower(A, t, Convex.evaluate(C))
││ for 2 of union split cases, no matching method found for call signatures (Tuple{Type{Convex.TraceMpower}, Convex.Variable, Rational{Int64}, Int64}, Tuple{Type{Convex.TraceMpower}, Convex.Variable, Rational{Int64}, Vector{Int64}})): Convex.TraceMpower(A::Convex.Variable, t::Rational{Int64}, Convex.evaluate(C::Matrix{Int64})::Union{Int64, VecOrMat{Int64}})
│└───────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/Test/src/Test.jl:479 Convex.ProblemDepot.trace_mpower(B, t, C)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/trace_mpower.jl:73 Convex.TraceMpower(A, t, Convex.evaluate(C))
││ for 2 of union split cases, no matching method found for call signatures (Tuple{Type{Convex.TraceMpower}, Convex.Variable, Rational{Int64}, ComplexF64}, Tuple{Type{Convex.TraceMpower}, Convex.Variable, Rational{Int64}, Vector{ComplexF64}})): Convex.TraceMpower(A::Convex.Variable, t::Rational{Int64}, Convex.evaluate(C::Matrix{ComplexF64})::Union{VecOrMat{ComplexF64}, ComplexF64})
│└───────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/sdp.jl:1352 p = Core.kwfunc(Convex.ProblemDepot.maximize)(Core.apply_type(Core.NamedTuple, (:numeric_type,))(Core.tuple(_)), Convex.ProblemDepot.maximize, objective, Base.vect(Convex.ProblemDepot.==(X, A), Convex.ProblemDepot.==(Y, B)))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/problems.jl:84 Convex.#maximize#10(numeric_type, _3, objective, constraints)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/problems.jl:84 Core.apply_type(Convex.Problem, numeric_type)(:maximize, objective, constraints)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/problems.jl:10 Convex.sign(objective)
││││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/real_imag.jl:23 goto %9 if not Convex.==(Convex.sign(Base.getindex(Base.getproperty(x, :children), 1)), Convex.ComplexSign())
│││││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %9 if not Convex.==(Convex.sign(Base.getindex(Base.getproperty(x::Convex.RealAtom, :children::Symbol)::Tuple{Convex.SumAtom}, 1)::Convex.SumAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
││││└──────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/sdp.jl:1386 Convex.ProblemDepot.⪯(A, Convex.ProblemDepot.*(λ, Convex.ProblemDepot.eye(2)))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/sdp_constraints.jl:108 goto %6 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %6 if not Convex.==(Convex.sign(x::Convex.AdditionAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
│└────────────────────────────────────────────────────────────────────────────────
│┌ @ /Users/aviatesk/julia/packages/Convex/src/constraints/sdp_constraints.jl:108 goto %23 if not Convex.==(Convex.sign(y), Convex.ComplexSign())
││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %23 if not Convex.==(Convex.sign(y::Convex.MultiplyAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
│└────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/socp.jl:34 Convex.ProblemDepot.norm2(Base.vcat(Convex.ProblemDepot.+(Base.getindex(x, 1), Convex.ProblemDepot.*(2, Base.getindex(x, 2)), 2), Convex.ProblemDepot.+(Convex.ProblemDepot.*(2, Base.getindex(x, 1)), Base.getindex(x, 2), 3), Convex.ProblemDepot.+(Convex.ProblemDepot.*(3, Base.getindex(x, 1)), Convex.ProblemDepot.*(4, Base.getindex(x, 2)), 4)))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/second_order_cone/norm2.jl:52 goto %10 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %10 if not Convex.==(Convex.sign(x::Convex.TransposeAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
│└─────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/Test/src/Test.jl:479 Convex.ProblemDepot.square(Convex.ProblemDepot.+(Convex.ProblemDepot.*(A, x), b))
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/second_order_cone/qol_elementwise.jl:58 goto %7 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %7 if not Convex.==(Convex.sign(x::Convex.AdditionAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
│└───────────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/Test/src/Test.jl:479 Convex.ProblemDepot.dot(Convex.ProblemDepot.*)(expr, expr)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/utilities/broadcast.jl:8 Convex.broadcast(Convex.*, x, y)
││┌ @ broadcast.jl:798 Base.Broadcast.broadcasted(Core.tuple(f), As...)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/affine/multiply_divide.jl:196 goto %18 if not Convex.==(Convex.vexity(x), Convex.ConstVexity())
││││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %18 if not Convex.==(Convex.vexity(x::Convex.AdditionAtom)::Any, Convex.ConstVexity()::Convex.ConstVexity)::Union{Missing, Bool}
│││└─────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/socp.jl:225 Convex.ProblemDepot.quadform(x, A)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/second_order_cone/quadform.jl:38 Convex.#quadform#42(false, #self#, x, A)
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/second_order_cone/quadform.jl:57 Convex.norm2(Convex.*(P, x))
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/second_order_cone/norm2.jl:52 goto %10 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
││││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %10 if not Convex.==(Convex.sign(x::Convex.MultiplyAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
│││└─────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/socp.jl:332 Convex.ProblemDepot.<=(Convex.ProblemDepot.norm(x, q), 1)
│┌ @ operators.jl:401 Base.<(x, y)
││┌ @ operators.jl:352 Base.isless(x, y)
│││ no matching method found for call signature (Tuple{typeof(isless), Nothing, Int64}): Base.isless(x::Nothing, y::Int64)
││└────────────────────
┌ @ /Users/aviatesk/julia/packages/Convex/src/problem_depot/problems/socp.jl:352 Convex.ProblemDepot.norm(Convex.ProblemDepot.-(Convex.ProblemDepot.*(A, xvar), b), q)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/second_order_cone/norm.jl:37 Convex.rationalnorm(x, Convex.rationalize(Convex.Int, Convex.float(p)))
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/second_order_cone/rationalnorm.jl:120 goto %23 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
│││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %23 if not Convex.==(Convex.sign(x::Convex.AdditionAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
││└─────────────────────────────────────────────────────────────────────────────────────────
┌ @ /Users/aviatesk/julia/julia/usr/share/julia/stdlib/v1.8/Test/src/Test.jl:479 Convex.ProblemDepot.opnorm(x, Convex.ProblemDepot.Inf)
│┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/sdp_cone/operatornorm.jl:53 Convex.maximum(Core.kwfunc(Convex.sum)(Core.apply_type(Core.NamedTuple, (:dims,))(Core.tuple(2)), Convex.sum, Convex.abs(x)))
││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/maximum.jl:57 Convex.MaximumAtom(x)
│││┌ @ /Users/aviatesk/julia/packages/Convex/src/atoms/lp_cone/maximum.jl:17 goto %10 if not Convex.==(Convex.sign(x), Convex.ComplexSign())
││││ for 1 of union split cases, non-boolean (Missing) used in boolean context: goto %10 if not Convex.==(Convex.sign(x::Convex.MultiplyAtom)::Any, Convex.ComplexSign()::Convex.ComplexSign)::Union{Missing, Bool}
│││└─────────────────────────────────────────────────────────────────────────

This was referenced Dec 3, 2021

concretization of :foreigncall #277

Closed

WIP: fix for https://github.com/aviatesk/JET.jl/issues/277 #278

Merged

goerch added a commit to goerch/JET.jl that referenced this issue Dec 4, 2021

Work on supporting foreign calls

618b814

Use optimized JuliaInterpreter frames to support foreign calls. Fixes aviatesk#277 and aviatesk#224, but breaks `eval` tests.

goerch mentioned this issue Dec 4, 2021

Work on supporting foreign calls #280

Merged

aviatesk added a commit that referenced this issue Dec 5, 2021

concretize all top-level code when analyzing a package

0f60d38

fix #224 fix #281

aviatesk mentioned this issue Dec 5, 2021

concretize all top-level code when analyzing a package #283

Merged

aviatesk added a commit that referenced this issue Dec 5, 2021

concretize all top-level code when analyzing a package

1bda32b

fix #224 fix #281

aviatesk closed this as completed in #283 Dec 5, 2021

aviatesk added a commit that referenced this issue Dec 5, 2021

concretize all top-level code when analyzing a package (#283)

974abcb

fix #224 fix #281

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Access to undefined reference at let keyword #224

Access to undefined reference at let keyword #224

jakobnissen commented Jul 24, 2021

ericphanson commented Jul 24, 2021

aviatesk commented Aug 2, 2021

goerch commented Dec 2, 2021

aviatesk commented Dec 3, 2021

goerch commented Dec 3, 2021 •

edited

aviatesk commented Dec 3, 2021

aviatesk commented Dec 3, 2021 •

edited

goerch commented Dec 3, 2021 •

edited

aviatesk commented Dec 3, 2021

aviatesk commented Dec 5, 2021

Access to undefined reference at let keyword #224

Access to undefined reference at let keyword #224

Comments

jakobnissen commented Jul 24, 2021

ericphanson commented Jul 24, 2021

aviatesk commented Aug 2, 2021

goerch commented Dec 2, 2021

aviatesk commented Dec 3, 2021

goerch commented Dec 3, 2021 • edited

aviatesk commented Dec 3, 2021

aviatesk commented Dec 3, 2021 • edited

goerch commented Dec 3, 2021 • edited

aviatesk commented Dec 3, 2021

aviatesk commented Dec 5, 2021

goerch commented Dec 3, 2021 •

edited

aviatesk commented Dec 3, 2021 •

edited

goerch commented Dec 3, 2021 •

edited