Designing linear algebra into Julia

Designing linear algebra
into Julia
Jiahao Chen
MIT CSAIL ⟶ Capital One New York
PASC 2017, 06-26
Alan Edelman
MIT
Andreas Noack
MIT/J.C.
Jake Bolewski
TileDB
Sacha Verweij
Stanford
Jeff Bezanson
Julia Computing
...and many others!
Viral B Shah
Julia Computing
Simon Byrne
Julia Computing

Claim 1.
Julia's generic function system (multimethods/
multiple dispatch) is ergonomically designed to
capture mathematical abstraction.
Claim 2.
We're only just learning how to explain abstractions
clearly to a computer.
Claim 3.
The future of high performance lies in composable
abstraction.

New mathematical ideas extend existing
abstractions, e.g. by overloading *
What does it mean to multiply A*B?
It depends on what A and B are.
Many people learn to multiply in
this order:
1. Int * Int
2. Rational * Int
3. Real * Real
4. Matrix * Matrix, Matrix *
Vector, 
Complex * Complex,...

julia> methods(*)
# 181 methods for generic function "*":
*(x::Bool, z::Complex{Bool}) in Base at complex.jl:236...*(x::Bool, y::Bool) in Base at bool.jl:91
*(x::Bool, y::T) where T<:Unsigned in Base at bool.jl:104
*(x::Bool, z::Complex) in Base at complex.jl:243
*(x::Bool, y::Irrational) in Base at irrationals.jl:111
*(x::Bool, y::T) where T<:Number in Base at bool.jl:101
*(a::Float16, b::Float16) in Base at float.jl:372
*(x::Float32, y::Float32) in Base at float.jl:378
*(x::Float64, y::Float64) in Base at float.jl:379
*(z::Complex{Bool}, x::Bool) in Base at complex.jl:237
*(z::Complex{Bool}, x::Real) in Base at complex.jl:255
*(this::Base.Grisu.Float, other::Base.Grisu.Float) in Base.Grisu at grisu/float.jl:138
*(c::BigInt, x::BigFloat) in Base.MPFR at mpfr.jl:312
*(a::BigInt, b::BigInt, c::BigInt, d::BigInt, e::BigInt) in Base.GMP at gmp.jl:334
*(a::BigInt, b::BigInt, c::BigInt, d::BigInt) in Base.GMP at gmp.jl:327
*(a::BigInt, b::BigInt, c::BigInt) in Base.GMP at gmp.jl:321
*(x::BigInt, y::BigInt) in Base.GMP at gmp.jl:289
*(x::BigInt, c::Union{UInt16, UInt32, UInt64, UInt8}) in Base.GMP at gmp.jl:368
*(x::BigInt, c::Union{Int16, Int32, Int64, Int8}) in Base.GMP at gmp.jl:374
*(a::BigFloat, b::BigFloat, c::BigFloat, d::BigFloat, e::BigFloat) in Base.MPFR at mpfr.jl:460
*(a::BigFloat, b::BigFloat, c::BigFloat, d::BigFloat) in Base.MPFR at mpfr.jl:453
*(a::BigFloat, b::BigFloat, c::BigFloat) in Base.MPFR at mpfr.jl:447
*(x::BigFloat, c::BigInt) in Base.MPFR at mpfr.jl:308
*(x::BigFloat, y::BigFloat) in Base.MPFR at mpfr.jl:277
*(x::BigFloat, c::Union{UInt16, UInt32, UInt64, UInt8}) in Base.MPFR at mpfr.jl:284
*(x::BigFloat, c::Union{Int16, Int32, Int64, Int8}) in Base.MPFR at mpfr.jl:292
*(x::BigFloat, c::Union{Float16, Float32, Float64}) in Base.MPFR at mpfr.jl:300
*(B::BitArray{2}, J::UniformScaling) in Base.LinAlg at linalg/uniformscaling.jl:149
*(z::Complex, w::Complex) in Base at complex.jl:223
*(z::Complex, x::Bool) in Base at complex.jl:244
*(x::Real, z::Complex{Bool}) in Base at complex.jl:254
*(x::Real, z::Complex) in Base at complex.jl:266
*(z::Complex, x::Real) in Base at complex.jl:267
*(x::Rational, y::Rational) in Base at rational.jl:252
*(a::Integer, index::CartesianIndex{N}) where N in Base.IteratorsMD at multidimensional.jl:83
*(c::Union{UInt16, UInt32, UInt64, UInt8}, x::BigInt) in Base.GMP at gmp.jl:372
*(c::Union{Int16, Int32, Int64, Int8}, x::BigInt) in Base.GMP at gmp.jl:378
*(c::Union{UInt16, UInt32, UInt64, UInt8}, x::BigFloat) in Base.MPFR at mpfr.jl:288
*(c::Union{Int16, Int32, Int64, Int8}, x::BigFloat) in Base.MPFR at mpfr.jl:296
*(c::Union{Float16, Float32, Float64}, x::BigFloat) in Base.MPFR at mpfr.jl:304
*(x::Irrational, y::Irrational) in Base at irrationals.jl:109
*(y::Real, x::Base.Dates.Period) in Base.Dates at dates/periods.jl:88
*(x::Real, r::Base.Use_StepRangeLen_Instead) in Base at deprecated.jl:1226
*(x::Number) in Base at operators.jl:400
*(y::Number, x::Bool) in Base at bool.jl:106
*(x::T, y::T) where T<:Union{Int128, UInt128} in Base at int.jl:567
*(x::T, y::T) where T<:Union{Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8} in Base at int.jl:33
*(x::T, y::T) where T<:Number in Base at promotion.jl:336
*(x::Number, y::Number) in Base at promotion.jl:250
*(x::Real, r::StepRangeLen{#s45,#s44,S} where S where #s44<:Base.TwicePrecision where #s45<:Real) in Base at twiceprecision.jl:226
*(x::Number, r::StepRangeLen) in Base at range.jl:743
*(x::Number, r::LinSpace) in Base at range.jl:744
*(x::Number, r::Range) in Base at range.jl:742
*(r::StepRangeLen{#s45,#s44,S} where S where #s44<:Base.TwicePrecision where #s45<:Real, x::Real) in Base at twiceprecision.jl:228
*(r::StepRangeLen, x::Number) in Base at range.jl:747
*(r::LinSpace, x::Number) in Base at range.jl:748
*(r::Base.Use_StepRangeLen_Instead, x::Real) in Base at deprecated.jl:1227
*(r::Range, x::Number) in Base at range.jl:746
*(x::Base.TwicePrecision, v::Integer) in Base at twiceprecision.jl:469
*(x::Base.TwicePrecision{R}, v::S) where {S<:Number, R} in Base at twiceprecision.jl:487
*(v::Number, x::Base.TwicePrecision) in Base at twiceprecision.jl:491
*(rowvec::RowVector{T,CV} where CV<:(ConjArray{T,1,V} where V<:(AbstractArray{T,1} where T) where T), vec::AbstractArray{T,1}) where T<:Real in Base.LinAlg at linalg/rowvector.jl:171
*(rowvec::RowVector{T,V} where V<:(AbstractArray{T,1} where T), vec::AbstractArray{T,1}) where T<:Real in Base.LinAlg at linalg/rowvector.jl:170
*(rowvec::RowVector{T,CV} where CV<:(ConjArray{T,1,V} where V<:(AbstractArray{T,1} where T) where T) where T, vec::AbstractArray{T,1} where T) in Base.LinAlg at linalg/rowvector.jl:172
*(::RowVector, ::RowVector) in Base.LinAlg at linalg/rowvector.jl:182
*(rowvec::RowVector, A::Base.LinAlg.AbstractTriangular) in Base.LinAlg at linalg/triangular.jl:1639
*(rowvec::RowVector, D::Diagonal) in Base.LinAlg at linalg/diagonal.jl:270
*(rowvec::RowVector, vec::AbstractArray{T,1} where T) in Base.LinAlg at linalg/rowvector.jl:176
*(rowvec::RowVector, mat::AbstractArray{T,2} where T) in Base.LinAlg at linalg/rowvector.jl:181
*(A::Union{Base.ReshapedArray{T,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{T,2}, SubArray{T,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray}, x::Union{Base.ReshapedArray{S,1,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{S,1}, SubArray{S,1,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where
MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray}) where {T<:Union{Complex{Float32}, Complex{Float64}, Float32, Float64}, S} in Base.LinAlg at linalg/matmul.jl:74
*(A::SymTridiagonal, B::Number) in Base.LinAlg at linalg/tridiag.jl:130
*(A::Tridiagonal, B::Number) in Base.LinAlg at linalg/tridiag.jl:626
*(A::UpperTriangular, x::Number) in Base.LinAlg at linalg/triangular.jl:531
*(A::Base.LinAlg.UnitUpperTriangular, x::Number) in Base.LinAlg at linalg/triangular.jl:534
*(A::LowerTriangular, x::Number) in Base.LinAlg at linalg/triangular.jl:531
*(A::Base.LinAlg.UnitLowerTriangular, x::Number) in Base.LinAlg at linalg/triangular.jl:534
*(A::Tridiagonal, B::UpperTriangular) in Base.LinAlg at linalg/triangular.jl:1385
*(A::Tridiagonal, B::Base.LinAlg.UnitUpperTriangular) in Base.LinAlg at linalg/triangular.jl:1385
*(A::Tridiagonal, B::LowerTriangular) in Base.LinAlg at linalg/triangular.jl:1385
*(A::Tridiagonal, B::Base.LinAlg.UnitLowerTriangular) in Base.LinAlg at linalg/triangular.jl:1385
*(A::LowerTriangular, B::LowerTriangular) in Base.LinAlg at linalg/triangular.jl:1392
*(A::Base.LinAlg.UnitLowerTriangular, B::LowerTriangular) in Base.LinAlg at linalg/triangular.jl:1400
*(A::UpperTriangular, B::UpperTriangular) in Base.LinAlg at linalg/triangular.jl:1408
*(A::Base.LinAlg.UnitUpperTriangular, B::UpperTriangular) in Base.LinAlg at linalg/triangular.jl:1416
*(A::Base.LinAlg.AbstractTriangular, B::Base.LinAlg.AbstractTriangular) in Base.LinAlg at linalg/triangular.jl:1533
*(A::Base.LinAlg.AbstractTriangular, D::Diagonal) in Base.LinAlg at linalg/diagonal.jl:149
*(A::Base.LinAlg.AbstractTriangular, B::Union{Bidiagonal, SymTridiagonal, Tridiagonal}) in Base.LinAlg at linalg/bidiag.jl:498
*(A::Base.LinAlg.AbstractTriangular, B::AbstractArray{T,1} where T) in Base.LinAlg at linalg/triangular.jl:1557
*(A::Union{Base.LinAlg.QRCompactWYQ, Base.LinAlg.QRPackedQ}, b::Union{Base.ReshapedArray{T,1,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{T,1}, SubArray{T,1,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray} where T) in Base.LinAlg at linalg/qr.jl:527
*(A::Union{Base.LinAlg.QRCompactWYQ, Base.LinAlg.QRPackedQ}, B::Union{Base.ReshapedArray{T,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{T,2}, SubArray{T,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray} where T) in Base.LinAlg at linalg/qr.jl:539
*(A::Union{Base.ReshapedArray{T,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{T,2}, SubArray{T,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray} where T, Q::Union{Base.LinAlg.QRCompactWYQ, Base.LinAlg.QRPackedQ}) in Base.LinAlg at linalg/qr.jl:627
*(Q::Base.LinAlg.HessenbergQ{T,S} where S<:(AbstractArray{T,2} where T), X::Union{Union{Base.ReshapedArray{S,1,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{S,1}, SubArray{S,1,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray}, Union{Base.ReshapedArray{S,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{S,2}, SubArray{S,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64,
Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray}}) where {T, S} in Base.LinAlg at linalg/hessenberg.jl:101
*(X::Union{Union{Base.ReshapedArray{S,1,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{S,1}, SubArray{S,1,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray}, Union{Base.ReshapedArray{S,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{S,2}, SubArray{S,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where
MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray}}, Q::Base.LinAlg.HessenbergQ{T,S} where S<:(AbstractArray{T,2} where T)) where {T, S} in Base.LinAlg at linalg/hessenberg.jl:105
*(A::Base.LinAlg.LQPackedQ, B::Union{Union{Base.ReshapedArray{T,1,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{T,1}, SubArray{T,1,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray}, Union{Base.ReshapedArray{T,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{T,2}, SubArray{T,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where
A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray}} where T) in Base.LinAlg at linalg/lq.jl:142
*(A::Union{Base.ReshapedArray{TA,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{TA,2}, SubArray{TA,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray}, B::Base.LinAlg.LQPackedQ{TB,S} where S<:(AbstractArray{T,2} where T)) where {TA, TB} in Base.LinAlg at linalg/lq.jl:176
*(A::Union{Hermitian{T,S}, Symmetric{T,S}} where S where T, B::Union{Hermitian{T,S}, Symmetric{T,S}} where S where T) in Base.LinAlg at linalg/symmetric.jl:267
*(A::Union{Base.ReshapedArray{T,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{T,2}, SubArray{T,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray} where T, B::Union{Hermitian{T,S}, Symmetric{T,S}} where S where T) in Base.LinAlg at linalg/symmetric.jl:268
*(A::Symmetric, x::Bool) in Base.LinAlg at linalg/symmetric.jl:272
*(A::Symmetric, x::Number) in Base.LinAlg at linalg/symmetric.jl:274
*(A::Hermitian, x::Bool) in Base.LinAlg at linalg/symmetric.jl:272
*(A::Hermitian, x::Real) in Base.LinAlg at linalg/symmetric.jl:274
*(D::Diagonal, x::Number) in Base.LinAlg at linalg/diagonal.jl:144
*(Da::Diagonal, Db::Diagonal) in Base.LinAlg at linalg/diagonal.jl:146
*(D::Diagonal, B::Base.LinAlg.AbstractTriangular) in Base.LinAlg at linalg/diagonal.jl:150
*(D::Diagonal, A::SparseMatrixCSC) in Base.SparseArrays at sparse/linalg.jl:114
*(D::Diagonal, V::AbstractArray{T,1} where T) in Base.LinAlg at linalg/diagonal.jl:147
*(D::Diagonal, A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/diagonal.jl:154
*(A::Bidiagonal, B::Number) in Base.LinAlg at linalg/bidiag.jl:346
*(A::Union{Bidiagonal, SymTridiagonal, Tridiagonal}, B::Union{Bidiagonal, SymTridiagonal, Tridiagonal}) in Base.LinAlg at linalg/bidiag.jl:499
*(A::Bidiagonal{T}, B::AbstractArray{T,1}) where T in Base.LinAlg at linalg/bidiag.jl:503
*(X::Union{Base.ReshapedArray{P,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{P,N}, SubArray{P,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray} where N, y::Real) where P<:Base.Dates.Period in Base.Dates at dates/periods.jl:93
*(x::AbstractSparseArray{Tv,Ti,1} where Ti where Tv, a::Number) in Base.SparseArrays at sparse/sparsevector.jl:1429
*(X::Union{Base.ReshapedArray{TX,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{TX,2}, SubArray{TX,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray}, A::SparseMatrixCSC{TvA,TiA}) where {TX, TvA, TiA} in Base.SparseArrays at sparse/linalg.jl:102
*(A::Union{Base.ReshapedArray{Ta,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{Ta,2}, SubArray{Ta,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray}, x::AbstractSparseArray{Tx,Ti,1} where Ti) where {Ta, Tx} in Base.SparseArrays at sparse/sparsevector.jl:1504
*(A::SparseMatrixCSC, x::AbstractSparseArray{Tv,Ti,1} where Ti where Tv) in Base.SparseArrays at sparse/sparsevector.jl:1682
*(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti}) where {Tv, Ti} in Base.SparseArrays at sparse/linalg.jl:125
*(A::SparseMatrixCSC{TvA,TiA}, B::SparseMatrixCSC{TvB,TiB}) where {TvA, TiA, TvB, TiB} in Base.SparseArrays at sparse/linalg.jl:24
*(A::SparseMatrixCSC, D::Diagonal) in Base.SparseArrays at sparse/linalg.jl:118
*(A::Base.SparseArrays.CHOLMOD.Sparse, B::Base.SparseArrays.CHOLMOD.Sparse) in Base.SparseArrays.CHOLMOD at sparse/cholmod.jl:1286
*(A::Base.SparseArrays.CHOLMOD.Sparse, B::Base.SparseArrays.CHOLMOD.Dense) in Base.SparseArrays.CHOLMOD at sparse/cholmod.jl:1287
*(A::Base.SparseArrays.CHOLMOD.Sparse, B::Union{Array{T,1}, Array{T,2}} where T) in Base.SparseArrays.CHOLMOD at sparse/cholmod.jl:1288
*(A::Symmetric{Float64,SparseMatrixCSC{Float64,Ti}}, B::Union{SparseMatrixCSC{Float64,Ti}, SparseVector{Float64,Ti}}) where Ti in Base.SparseArrays.CHOLMOD at sparse/cholmod.jl:1711
*(A::Hermitian{Complex{Float64},SparseMatrixCSC{Complex{Float64},Ti}}, B::Union{SparseMatrixCSC{Complex{Float64},Ti}, SparseVector{Complex{Float64},Ti}}) where Ti in Base.SparseArrays.CHOLMOD at sparse/cholmod.jl:1713
*(A::Hermitian{Float64,SparseMatrixCSC{Float64,Ti}}, B::Union{SparseMatrixCSC{Float64,Ti}, SparseVector{Float64,Ti}}) where Ti in Base.SparseArrays.CHOLMOD at sparse/cholmod.jl:1715
*(A::Union{SparseMatrixCSC{Float64,Ti}, SparseVector{Float64,Ti}}, B::Symmetric{Float64,SparseMatrixCSC{Float64,Ti}}) where Ti in Base.SparseArrays.CHOLMOD at sparse/cholmod.jl:1718
*(A::Union{SparseMatrixCSC{Complex{Float64},Ti}, SparseVector{Complex{Float64},Ti}}, B::Hermitian{Complex{Float64},SparseMatrixCSC{Complex{Float64},Ti}}) where Ti in Base.SparseArrays.CHOLMOD at sparse/cholmod.jl:1720
*(A::Union{SparseMatrixCSC{Float64,Ti}, SparseVector{Float64,Ti}}, B::Hermitian{Float64,SparseMatrixCSC{Float64,Ti}}) where Ti in Base.SparseArrays.CHOLMOD at sparse/cholmod.jl:1722
*(x::AbstractArray{#s45,2} where #s45<:Number) in Base at abstractarraymath.jl:94
*(B::Number, A::SymTridiagonal) in Base.LinAlg at linalg/tridiag.jl:131
*(B::Number, A::Tridiagonal) in Base.LinAlg at linalg/tridiag.jl:627
*(x::Number, A::UpperTriangular) in Base.LinAlg at linalg/triangular.jl:541
*(x::Number, A::Base.LinAlg.UnitUpperTriangular) in Base.LinAlg at linalg/triangular.jl:544
*(x::Number, A::LowerTriangular) in Base.LinAlg at linalg/triangular.jl:541
*(x::Number, A::Base.LinAlg.UnitLowerTriangular) in Base.LinAlg at linalg/triangular.jl:544
*(x::Number, D::Diagonal) in Base.LinAlg at linalg/diagonal.jl:143
*(B::Number, A::Bidiagonal) in Base.LinAlg at linalg/bidiag.jl:347
*(a::Number, x::AbstractSparseArray{Tv,Ti,1} where Ti where Tv) in Base.SparseArrays at sparse/sparsevector.jl:1430
*(A::Number, B::AbstractArray) in Base at arraymath.jl:44
*(A::AbstractArray, B::Number) in Base at arraymath.jl:47
*(s1::AbstractString, ss::AbstractString...) in Base at strings/basic.jl:70
*(index::CartesianIndex, a::Integer) in Base.IteratorsMD at multidimensional.jl:84
*(vec::AbstractArray{T,1} where T, rowvec::RowVector) in Base.LinAlg at linalg/rowvector.jl:183
*(vec::AbstractArray{T,1} where T, rowvec::AbstractArray{T,1} where T) in Base.LinAlg at linalg/rowvector.jl:184
*(A::AbstractArray{T,2} where T, B::Base.LinAlg.AbstractTriangular) in Base.LinAlg at linalg/triangular.jl:1590
*(A::AbstractArray{T,2} where T, D::Diagonal) in Base.LinAlg at linalg/diagonal.jl:152
*(A::AbstractArray{T,2}, x::AbstractArray{S,1}) where {T, S} in Base.LinAlg at linalg/matmul.jl:78
*(a::AbstractArray{T,1} where T, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/matmul.jl:87
*(A::AbstractArray{T,2}, B::AbstractArray{S,2}) where {T, S} in Base.LinAlg at linalg/matmul.jl:145
*(A::Base.LinAlg.LQ{TA,S} where S<:(AbstractArray{T,2} where T), B::Union{Union{Base.ReshapedArray{TB,1,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{TB,1}, SubArray{TB,1,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray}, Union{Base.ReshapedArray{TB,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{TB,2}, SubArray{TB,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int
where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray}}) where {TA, TB} in Base.LinAlg at linalg/lq.jl:126
*(A::Base.LinAlg.LQ{TA,S} where S<:(AbstractArray{T,2} where T), B::Base.LinAlg.QR{TB,S} where S<:(AbstractArray{T,2} where T)) where {TA, TB} in Base.LinAlg at linalg/lq.jl:130
*(A::Base.LinAlg.QR{TA,S} where S<:(AbstractArray{T,2} where T), B::Base.LinAlg.LQ{TB,S} where S<:(AbstractArray{T,2} where T)) where {TA, TB} in Base.LinAlg at linalg/lq.jl:134
*(J1::UniformScaling, J2::UniformScaling) in Base.LinAlg at linalg/uniformscaling.jl:148
*(J::UniformScaling, B::BitArray{2}) in Base.LinAlg at linalg/uniformscaling.jl:150
*(A::AbstractArray{T,2} where T, J::UniformScaling) in Base.LinAlg at linalg/uniformscaling.jl:151
*(J::UniformScaling, A::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/uniformscaling.jl:152
*(x::Number, J::UniformScaling) in Base.LinAlg at linalg/uniformscaling.jl:153
*(J::UniformScaling, x::Number) in Base.LinAlg at linalg/uniformscaling.jl:154
*(R::Base.LinAlg.AbstractRotation{T}, A::Union{AbstractArray{S,1}, AbstractArray{S,2}}) where {T, S} in Base.LinAlg at linalg/givens.jl:9
*(G1::Base.LinAlg.Givens{T}, G2::Base.LinAlg.Givens{T}) where T in Base.LinAlg at linalg/givens.jl:363
*(p::Base.DFT.ScaledPlan, x::AbstractArray) in Base.DFT at dft.jl:255
*(p::Base.DFT.FFTW.cFFTWPlan{T,K,false,N} where N, x::Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{T,N}, SubArray{T,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray}) where {T, K, N} in Base.DFT.FFTW at fft/FFTW.jl:627
*(p::Base.DFT.FFTW.cFFTWPlan{T,K,true,N} where N, x::Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{T,N}, SubArray{T,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray} where N) where {T, K} in Base.DFT.FFTW at fft/FFTW.jl:634
*(p::Base.DFT.FFTW.rFFTWPlan{Float32,-1,false,N} where N, x::Union{Base.ReshapedArray{Float32,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{Float32,N}, SubArray{Float32,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray}) where N in Base.DFT.FFTW at fft/FFTW.jl:704
*(p::Base.DFT.FFTW.rFFTWPlan{Complex{Float32},1,false,N} where N, x::Union{Base.ReshapedArray{Complex{Float32},N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{Complex{Float32},N}, SubArray{Complex{Float32},N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray}) where N in Base.DFT.FFTW at fft/FFTW.jl:711
*(p::Base.DFT.FFTW.rFFTWPlan{Float64,-1,false,N} where N, x::Union{Base.ReshapedArray{Float64,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{Float64,N}, SubArray{Float64,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray}) where N in Base.DFT.FFTW at fft/FFTW.jl:704
*(p::Base.DFT.FFTW.rFFTWPlan{Complex{Float64},1,false,N} where N, x::Union{Base.ReshapedArray{Complex{Float64},N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{Complex{Float64},N}, SubArray{Complex{Float64},N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray}) where N in Base.DFT.FFTW at fft/FFTW.jl:711
*(p::Base.DFT.FFTW.r2rFFTWPlan{T,K,false,N} where N, x::Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{T,N}, SubArray{T,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray}) where {T, K, N} in Base.DFT.FFTW at fft/FFTW.jl:790
*(p::Base.DFT.FFTW.r2rFFTWPlan{T,K,true,N} where N, x::Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{T,N}, SubArray{T,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray} where N) where {T, K} in Base.DFT.FFTW at fft/FFTW.jl:797
*(p::Base.DFT.FFTW.DCTPlan{T,5,false}, x::Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{T,N}, SubArray{T,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray} where N) where T in Base.DFT.FFTW at fft/dct.jl:97
*(p::Base.DFT.FFTW.DCTPlan{T,4,false}, x::Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{T,N}, SubArray{T,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray} where N) where T in Base.DFT.FFTW at fft/dct.jl:100
*(p::Base.DFT.FFTW.DCTPlan{T,K,true}, x::Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{T,N}, SubArray{T,N,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray} where N) where {T, K} in Base.DFT.FFTW at fft/dct.jl:103
*(p::Base.DFT.Plan{T}, x::AbstractArray) where T in Base.DFT at dft.jl:214
*(α::Number, p::Base.DFT.Plan) in Base.DFT at dft.jl:257
*(p::Base.DFT.Plan, α::Number) in Base.DFT at dft.jl:258
*(I::UniformScaling, p::Base.DFT.ScaledPlan) in Base.DFT at dft.jl:259
*(p::Base.DFT.ScaledPlan, I::UniformScaling) in Base.DFT at dft.jl:260
*(I::UniformScaling, p::Base.DFT.Plan) in Base.DFT at dft.jl:261
*(p::Base.DFT.Plan, I::UniformScaling) in Base.DFT at dft.jl:262
*(x::P, y::Real) where P<:Base.Dates.Period in Base.Dates at dates/periods.jl:87
*(a, b, c, xs...) in Base at operators.jl:424
* is highly polymorphic

Type hierarchy in Julia
Any
AbstractArray{T,N}
Array{T,N}
Matrix{T}
Symmetric{T,S}
Matrix{Float64}
NumberString
Complex{T} Real
FloatingPoint Rational{T}
(a tiny part thereof)
Float64 Float16

Types deﬁne storage and behavior
julia> dump(Symmetric(rand(4,4)))
Symmetric{Float64,Array{Float64,2}
}
data: Array{Float64}((4, 4))
[0.118973 0.0147591 0.632845 0.667772; 0.825323 0.928748 0.750073
0.577964; 0.0200403 0.817259 0.141327 0.149125; 0.586003 0.647191
0.635897 0.316552]
uplo: Char U
julia> methodswith(Symmetric, true)
651-element Array{Method,1}:
rem(A::Number, B::AbstractArray) in Base at deprecated.jl:56rem(A::AbstractArray, B::Number) in Base at deprecated.jl:56
&(a::Number, B::AbstractArray) in Base at deprecated.jl:56
&(A::AbstractArray, b::Number) in Base at deprecated.jl:56
&(A::AbstractArray, B::AbstractArray) in Base at deprecated.jl:56
*(rowvec::RowVector, mat::AbstractArray{T,2} where T) in Base.LinAlg at linalg/rowvector.jl:181
*(A::Union{Hermitian{T,S}, Symmetric{T,S}} where S where T, B::Union{Hermitian{T,S}, Symmetric{T,S}} where S where T) in Base.LinAlg at linalg/symmetric.jl:267
*(A::Union{Base.ReshapedArray{T,2,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray, DenseArray{T,2}, SubArray{T,2,A,I,L} where L} where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex, Int64, Range{Int64}},N} where N} where A<:Union{Base.ReshapedArray{T,N,A,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where A<:DenseArray where N where T, DenseArray} where T, B::Union{Hermitian{T,S}, Symmetric{T,S}} where S where T) in Base.LinAlg at linalg/symmetric.jl:268
*(A::Symmetric, x::Bool) in Base.LinAlg at linalg/symmetric.jl:272
*(A::Symmetric, x::Number) in Base.LinAlg at linalg/symmetric.jl:274
*(D::Diagonal, A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/diagonal.jl:154
*(A::Number, B::AbstractArray) in Base at arraymath.jl:44
*(A::AbstractArray, B::Number) in Base at arraymath.jl:47
*(A::AbstractArray{T,2} where T, B::Base.LinAlg.AbstractTriangular) in Base.LinAlg at linalg/triangular.jl:1590
*(A::AbstractArray{T,2} where T, D::Diagonal) in Base.LinAlg at linalg/diagonal.jl:152
*(A::AbstractArray{T,2}, x::AbstractArray{S,1}) where {T, S} in Base.LinAlg at linalg/matmul.jl:78
*(a::AbstractArray{T,1} where T, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/matmul.jl:87
*(A::AbstractArray{T,2}, B::AbstractArray{S,2}) where {T, S} in Base.LinAlg at linalg/matmul.jl:145
*(A::AbstractArray{T,2} where T, J::UniformScaling) in Base.LinAlg at linalg/uniformscaling.jl:151
*(J::UniformScaling, A::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/uniformscaling.jl:152
*(R::Base.LinAlg.AbstractRotation{T}, A::Union{AbstractArray{S,1}, AbstractArray{S,2}}) where {T, S} in Base.LinAlg at linalg/givens.jl:9
*(p::Base.DFT.ScaledPlan, x::AbstractArray) in Base.DFT at dft.jl:255
*(p::Base.DFT.Plan{T}, x::AbstractArray) where T in Base.DFT at dft.jl:214
+(A::Symmetric, x::Bool) in Base.LinAlg at linalg/symmetric.jl:272
+(A::Symmetric, x::Number) in Base.LinAlg at linalg/symmetric.jl:274
+(A::AbstractArray{TA,2}, J::UniformScaling{TJ}) where {TA, TJ} in Base.LinAlg at linalg/uniformscaling.jl:119
+(A::AbstractArray, B::AbstractArray) in Base at arraymath.jl:37
+(A::Number, B::AbstractArray) in Base at arraymath.jl:44
+(A::AbstractArray, B::Number) in Base at arraymath.jl:47
+(J::UniformScaling, A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/uniformscaling.jl:61
-(A::Symmetric{Tv,S}) where {Tv, S<:(AbstractArray{T,2} where T)} in Base.LinAlg at linalg/symmetric.jl:250
-(A::Symmetric, x::Bool) in Base.LinAlg at linalg/symmetric.jl:272
-(A::Symmetric, x::Number) in Base.LinAlg at linalg/symmetric.jl:274
-(A::AbstractArray{TA,2}, J::UniformScaling{TJ}) where {TA, TJ<:Number} in Base.LinAlg at linalg/uniformscaling.jl:129
-(A::AbstractArray) in Base at arraymath.jl:29
-(A::AbstractArray, B::AbstractArray) in Base at arraymath.jl:37
-(A::Number, B::AbstractArray) in Base at arraymath.jl:44
-(A::AbstractArray, B::Number) in Base at arraymath.jl:47
-(J::UniformScaling{TJ}, A::AbstractArray{TA,2}) where {TA, TJ<:Number} in Base.LinAlg at linalg/uniformscaling.jl:138
/(A::Symmetric, x::Bool) in Base.LinAlg at linalg/symmetric.jl:272
/(A::Symmetric, x::Number) in Base.LinAlg at linalg/symmetric.jl:274
/(A::AbstractArray, B::Number) in Base at arraymath.jl:47
/(rowvec::RowVector, mat::AbstractArray{T,2} where T) in Base.LinAlg at linalg/rowvector.jl:240
/(A::AbstractArray{T,2} where T, B::Union{Base.LinAlg.UnitLowerTriangular, Base.LinAlg.UnitUpperTriangular}) in Base.LinAlg at linalg/triangular.jl:1601
/(A::AbstractArray{T,2} where T, B::Union{LowerTriangular, UpperTriangular}) in Base.LinAlg at linalg/triangular.jl:1613
/(A::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/generic.jl:823
/(B::AbstractArray{T,2} where T, A::Base.LinAlg.LU) in Base.LinAlg at linalg/lu.jl:512
/(J::UniformScaling, A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/uniformscaling.jl:157
/(A::AbstractArray{T,2} where T, J::UniformScaling) in Base.LinAlg at linalg/uniformscaling.jl:158
//(X::AbstractArray, y::Number) in Base at rational.jl:60
==(A::AbstractArray, B::AbstractArray) in Base at abstractarray.jl:1520
A_ldiv_B!(Y::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, A::Factorization, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/factorization.jl:55
A_ldiv_B!(A::Base.LinAlg.LU{T,Tridiagonal{T}}, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) where T in Base.LinAlg at linalg/lu.jl:413
A_ldiv_B!(D::Diagonal{T}, V::AbstractArray{T,2}) where T in Base.LinAlg at linalg/diagonal.jl:253
A_ldiv_B!(A::Union{Base.LinAlg.AbstractTriangular, Bidiagonal}, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/bidiag.jl:511
A_ldiv_B!(S::Base.LinAlg.LDLt{T,SymTridiagonal{T}}, B::Union{AbstractArray{T,1}, AbstractArray{T,2}}) where T in Base.LinAlg at linalg/ldlt.jl:50
A_ldiv_B!(y::AbstractArray, p::Base.DFT.Plan, x::AbstractArray) in Base.DFT at dft.jl:234
A_mul_B!(A::Base.LinAlg.QRPackedQ, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/qr.jl:502
A_mul_B!(y::AbstractArray{T,1} where T, A::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, x::AbstractArray{T,1} where T) in Base.LinAlg at linalg/matmul.jl:100
A_mul_B!(C::AbstractArray{T,2} where T, A::Base.LinAlg.AbstractTriangular, B::Tridiagonal) in Base.LinAlg at linalg/triangular.jl:399
A_mul_B!(C::AbstractArray{T,2} where T, A::Tridiagonal, B::Base.LinAlg.AbstractTriangular) in Base.LinAlg at linalg/triangular.jl:400
A_mul_B!(C::AbstractArray{T,2} where T, A::Base.LinAlg.AbstractTriangular, B::Union{Bidiagonal, SymTridiagonal, Tridiagonal}) in Base.LinAlg at linalg/bidiag.jl:356
A_mul_B!(C::AbstractArray{T,2} where T, A::Base.LinAlg.AbstractTriangular, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/triangular.jl:402
A_mul_B!(A::AbstractArray{T,2} where T, B::Diagonal) in Base.LinAlg at linalg/diagonal.jl:224
A_mul_B!(out::AbstractArray{T,2} where T, A::Diagonal, in::AbstractArray{T,2} where T) in Base.LinAlg at linalg/diagonal.jl:233
A_mul_B!(C::AbstractArray{T,2} where T, A::SymTridiagonal, B::Union{Bidiagonal, SymTridiagonal, Tridiagonal}) in Base.LinAlg at linalg/bidiag.jl:353
A_mul_B!(C::AbstractArray{T,2} where T, A::Union{Bidiagonal, Tridiagonal}, B::Union{Bidiagonal, SymTridiagonal, Tridiagonal}) in Base.LinAlg at linalg/bidiag.jl:354
A_mul_B!(C::AbstractArray{T,2} where T, A::Union{Bidiagonal, SymTridiagonal, Tridiagonal}, B::Union{Bidiagonal, SymTridiagonal, Tridiagonal}) in Base.LinAlg at linalg/bidiag.jl:355
A_mul_B!(A::Diagonal, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/diagonal.jl:221
A_mul_B!(C::AbstractArray{T,2} where T, A::AbstractArray{T,2} where T, B::Union{Bidiagonal, SymTridiagonal, Tridiagonal}) in Base.LinAlg at linalg/bidiag.jl:357
A_mul_B!(C::AbstractArray{T,2} where T, A::Union{Bidiagonal, Tridiagonal}, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/bidiag.jl:359
A_mul_B!(C::AbstractArray{T,2} where T, A::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/matmul.jl:178
A_mul_B!(C::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, A::Base.LinAlg.AbstractTriangular, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/triangular.jl:403
A_mul_B!(C::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, A::Union{Bidiagonal, Tridiagonal}, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/bidiag.jl:360
A_mul_B!(G::Base.LinAlg.Givens, A::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/givens.jl:324
A_mul_B!(R::Base.LinAlg.Rotation, A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/givens.jl:352
A_mul_B!(y::AbstractArray, p::Base.DFT.ScaledPlan, x::AbstractArray) in Base.DFT at dft.jl:275
A_mul_Bc(rowvec::RowVector, mat::AbstractArray{T,2} where T) in Base.LinAlg at linalg/rowvector.jl:213
A_mul_Bc(mat::AbstractArray{T,2} where T, rowvec::RowVector) in Base.LinAlg at linalg/rowvector.jl:217
A_mul_Bc(A::Base.LinAlg.AbstractTriangular, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/triangular.jl:1629
A_mul_Bc(D::Diagonal, A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/diagonal.jl:205
A_mul_Bc(a::AbstractArray{T,1} where T, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/matmul.jl:85
A_mul_Bc(A::AbstractArray{T,2} where T, B::Base.LinAlg.AbstractTriangular) in Base.LinAlg at linalg/triangular.jl:1590
A_mul_Bc(A::AbstractArray{T,2} where T, B::Union{Base.LinAlg.QRCompactWYQ, Base.LinAlg.QRPackedQ}) in Base.LinAlg at linalg/qr.jl:661
A_mul_Bc(A::AbstractArray{T,2} where T, b::AbstractArray{T,1} where T) in Base.LinAlg at linalg/matmul.jl:86
A_mul_Bc(A::AbstractArray{T,2}, B::AbstractArray{S,2}) where {T, S} in Base.LinAlg at linalg/matmul.jl:223
A_mul_Bc(A::Union{AbstractArray{T,1}, AbstractArray{T,2}}, R::Base.LinAlg.AbstractRotation{S}) where {T, S} in Base.LinAlg at linalg/givens.jl:13
A_mul_Bc!(C::AbstractArray{T,2} where T, A::Base.LinAlg.AbstractTriangular, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/triangular.jl:405
A_mul_Bc!(A::AbstractArray{T,2} where T, Q::Base.LinAlg.QRPackedQ) in Base.LinAlg at linalg/qr.jl:637
A_mul_Bc!(A::AbstractArray{T,2} where T, B::Diagonal) in Base.LinAlg at linalg/diagonal.jl:226
A_mul_Bc!(C::AbstractArray{T,2} where T, A::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/matmul.jl:227
A_mul_Bc!(C::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, A::Base.LinAlg.AbstractTriangular, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/triangular.jl:406
A_mul_Bc!(A::AbstractArray{T,2} where T, G::Base.LinAlg.Givens) in Base.LinAlg at linalg/givens.jl:336
A_mul_Bc!(A::AbstractArray{T,2} where T, R::Base.LinAlg.Rotation) in Base.LinAlg at linalg/givens.jl:358
A_mul_Bt(rowvec::RowVector, mat::AbstractArray{T,2} where T) in Base.LinAlg at linalg/rowvector.jl:188
A_mul_Bt(mat::AbstractArray{T,2} where T, rowvec::RowVector) in Base.LinAlg at linalg/rowvector.jl:192
A_mul_Bt(A::Base.LinAlg.AbstractTriangular, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/triangular.jl:1630
A_mul_Bt(D::Diagonal, A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/diagonal.jl:212
A_mul_Bt(a::AbstractArray{T,1} where T, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/matmul.jl:83
A_mul_Bt(A::AbstractArray{T,2} where T, B::Base.LinAlg.AbstractTriangular) in Base.LinAlg at linalg/triangular.jl:1590
A_mul_Bt(A::AbstractArray{T,2} where T, b::AbstractArray{T,1} where T) in Base.LinAlg at linalg/matmul.jl:84
A_mul_Bt(A::AbstractArray{T,2}, B::AbstractArray{S,2}) where {T, S} in Base.LinAlg at linalg/matmul.jl:188
A_mul_Bt!(C::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, A::Base.LinAlg.AbstractTriangular, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/triangular.jl:404
A_mul_Bt!(C::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, A::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/matmul.jl:202
A_mul_Bt!(A::AbstractArray{T,2} where T, B::Diagonal) in Base.LinAlg at linalg/diagonal.jl:225
A_rdiv_Bc(rowvec::RowVector, mat::AbstractArray{T,2} where T) in Base.LinAlg at linalg/rowvector.jl:242
A_rdiv_Bc(A::AbstractArray{T,2} where T, B::Union{Base.LinAlg.UnitLowerTriangular, Base.LinAlg.UnitUpperTriangular}) in Base.LinAlg at linalg/triangular.jl:1601
A_rdiv_Bc(A::AbstractArray{T,2} where T, B::Union{LowerTriangular, UpperTriangular}) in Base.LinAlg at linalg/triangular.jl:1613
A_rdiv_Bt(rowvec::RowVector, mat::AbstractArray{T,2} where T) in Base.LinAlg at linalg/rowvector.jl:241
A_rdiv_Bt(A::AbstractArray{T,2} where T, B::Union{Base.LinAlg.UnitLowerTriangular, Base.LinAlg.UnitUpperTriangular}) in Base.LinAlg at linalg/triangular.jl:1601
A_rdiv_Bt(A::AbstractArray{T,2} where T, B::Union{LowerTriangular, UpperTriangular}) in Base.LinAlg at linalg/triangular.jl:1613
Ac_ldiv_B(mat::AbstractArray{T,2} where T, rowvec::RowVector) in Base.LinAlg at linalg/rowvector.jl:236
Ac_ldiv_B(A::Union{Base.LinAlg.UnitLowerTriangular, Base.LinAlg.UnitUpperTriangular}, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/triangular.jl:1568
Ac_ldiv_B(A::Union{LowerTriangular, UpperTriangular}, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/triangular.jl:1579
Ac_ldiv_B(F::Factorization, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/factorization.jl:45
Ac_ldiv_B(A::Bidiagonal, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/bidiag.jl:569
Ac_ldiv_B(A::SparseMatrixCSC, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.SparseArrays at sparse/linalg.jl:857
Ac_ldiv_B!(Y::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, A::Factorization, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/factorization.jl:55
Ac_ldiv_B!(A::Base.LinAlg.LU{T,Tridiagonal{T}}, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) where T in Base.LinAlg at linalg/lu.jl:479
Ac_ldiv_B!(A::Union{Base.LinAlg.AbstractTriangular, Bidiagonal}, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/bidiag.jl:526
Ac_mul_B(A::Base.LinAlg.AbstractTriangular, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/triangular.jl:1557
Ac_mul_B(vec::AbstractArray{T,1} where T, mat::AbstractArray{T,2} where T) in Base.LinAlg at linalg/rowvector.jl:227
Ac_mul_B(A::AbstractArray{T,2} where T, B::Base.LinAlg.AbstractTriangular) in Base.LinAlg at linalg/triangular.jl:1627
Ac_mul_B(A::AbstractArray{T,2} where T, D::Diagonal) in Base.LinAlg at linalg/diagonal.jl:190
Ac_mul_B(A::AbstractArray{T,2}, x::AbstractArray{S,1}) where {T, S} in Base.LinAlg at linalg/matmul.jl:118
Ac_mul_B(A::AbstractArray{T,2}, B::AbstractArray{S,2}) where {T, S} in Base.LinAlg at linalg/matmul.jl:214
Ac_mul_B!(A::Base.LinAlg.QRPackedQ, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/qr.jl:557
Ac_mul_B!(y::AbstractArray{T,1} where T, A::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, x::AbstractArray{T,1} where T) in Base.LinAlg at linalg/matmul.jl:124
Ac_mul_B!(out::AbstractArray{T,2} where T, A::Diagonal, in::AbstractArray{T,2} where T) in Base.LinAlg at linalg/diagonal.jl:234
Ac_mul_B!(C::AbstractArray{T,2} where T, A::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/matmul.jl:218
Ac_mul_B!(A::Diagonal, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/diagonal.jl:223
Ac_mul_Bc(A::Base.LinAlg.AbstractTriangular, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/triangular.jl:1632
Ac_mul_Bc(vec::AbstractArray{T,1} where T, mat::AbstractArray{T,2} where T) in Base.LinAlg at linalg/rowvector.jl:220
Ac_mul_Bc(mat::AbstractArray{T,2} where T, rowvec::RowVector) in Base.LinAlg at linalg/rowvector.jl:224
Ac_mul_Bc(A::AbstractArray{T,2} where T, B::Base.LinAlg.AbstractTriangular) in Base.LinAlg at linalg/triangular.jl:1633
Ac_mul_Bc(A::AbstractArray{T,2}, B::AbstractArray{S,2}) where {T, S} in Base.LinAlg at linalg/matmul.jl:229
Ac_mul_Bc!(C::AbstractArray{T,2} where T, A::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/matmul.jl:232
At_ldiv_B(mat::AbstractArray{T,2} where T, rowvec::RowVector) in Base.LinAlg at linalg/rowvector.jl:235
At_ldiv_B(A::Union{Base.LinAlg.UnitLowerTriangular, Base.LinAlg.UnitUpperTriangular}, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/triangular.jl:1568
At_ldiv_B(A::Union{LowerTriangular, UpperTriangular}, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/triangular.jl:1579
At_ldiv_B(F::Factorization{#s266} where #s266<:Real, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/factorization.jl:60
At_ldiv_B(A::Bidiagonal, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/bidiag.jl:569
At_ldiv_B(A::SparseMatrixCSC, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.SparseArrays at sparse/linalg.jl:857
At_ldiv_B!(Y::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, A::Factorization, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/factorization.jl:55
At_ldiv_B!(A::Base.LinAlg.LU{T,Tridiagonal{T}}, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) where T in Base.LinAlg at linalg/lu.jl:444
At_ldiv_B!(A::Union{Base.LinAlg.AbstractTriangular, Bidiagonal}, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/bidiag.jl:526
At_mul_B(A::Base.LinAlg.AbstractTriangular, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/triangular.jl:1557
At_mul_B(vec::AbstractArray{T,1} where T, mat::AbstractArray{T,2} where T) in Base.LinAlg at linalg/rowvector.jl:203
At_mul_B(A::AbstractArray{T,2} where T, B::Base.LinAlg.AbstractTriangular) in Base.LinAlg at linalg/triangular.jl:1628
At_mul_B(A::AbstractArray{T,2} where T, D::Diagonal) in Base.LinAlg at linalg/diagonal.jl:197
At_mul_B(A::AbstractArray{T,2}, x::AbstractArray{S,1}) where {T, S} in Base.LinAlg at linalg/matmul.jl:107
At_mul_B(A::AbstractArray{T,2}, B::AbstractArray{S,2}) where {T, S} in Base.LinAlg at linalg/matmul.jl:181
At_mul_B!(y::AbstractArray{T,1} where T, A::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, x::AbstractArray{T,1} where T) in Base.LinAlg at linalg/matmul.jl:111
At_mul_B!(out::AbstractArray{T,2} where T, A::Diagonal, in::AbstractArray{T,2} where T) in Base.LinAlg at linalg/diagonal.jl:235
At_mul_B!(C::AbstractArray{T,2} where T, A::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/matmul.jl:185
At_mul_B!(A::Diagonal, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/diagonal.jl:222
At_mul_Bt(A::Base.LinAlg.AbstractTriangular, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/triangular.jl:1635
At_mul_Bt(vec::AbstractArray{T,1} where T, mat::AbstractArray{T,2} where T) in Base.LinAlg at linalg/rowvector.jl:195
At_mul_Bt(mat::AbstractArray{T,2} where T, rowvec::RowVector) in Base.LinAlg at linalg/rowvector.jl:200
At_mul_Bt(A::AbstractArray{T,2} where T, B::Base.LinAlg.AbstractTriangular) in Base.LinAlg at linalg/triangular.jl:1636
At_mul_Bt(A::AbstractArray{T,2}, B::Union{AbstractArray{S,1}, AbstractArray{S,2}}) where {T, S} in Base.LinAlg at linalg/matmul.jl:205
At_mul_Bt!(C::AbstractArray{T,2} where T, A::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/matmul.jl:209
(A::Number, B::AbstractArray) in Base at arraymath.jl:44
(mat::AbstractArray{T,2} where T, rowvec::RowVector) in Base.LinAlg at linalg/rowvector.jl:234
(A::Union{Base.LinAlg.UnitLowerTriangular, Base.LinAlg.UnitUpperTriangular}, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/triangular.jl:1568
(A::Union{LowerTriangular, UpperTriangular}, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/triangular.jl:1579
(D::Diagonal, A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/diagonal.jl:317
(A::Bidiagonal, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/bidiag.jl:569
(A::SparseMatrixCSC, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.SparseArrays at sparse/linalg.jl:857
(A::AbstractArray{T,2} where T, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/generic.jl:805
(a::AbstractArray{T,1} where T, b::AbstractArray) in Base.LinAlg at linalg/generic.jl:822
(A::Union{Base.LinAlg.QRCompactWY{TA,M} where M<:(AbstractArray{T,2} where T), Base.LinAlg.QRPivoted{TA,S} where S<:(AbstractArray{T,2} where T), Base.LinAlg.QR{TA,S} where S<:(AbstractArray{T,2} where T)}, B::Union{AbstractArray{TB,1}, AbstractArray{TB,2}}) where {TA, TB} in Base.LinAlg at linalg/qr.jl:809
(F::Factorization, B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/factorization.jl:45
(J::UniformScaling, A::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T) in Base.LinAlg at linalg/uniformscaling.jl:164
(A::AbstractArray{T,2} where T, J::UniformScaling) in Base.LinAlg at linalg/uniformscaling.jl:165
(p::Base.DFT.Plan, x::AbstractArray) in Base.DFT at dft.jl:233
^(A::AbstractArray{T,2}, p::Integer) where T in Base.LinAlg at linalg/dense.jl:332
^(A::AbstractArray{T,2}, p::Real) where T in Base.LinAlg at linalg/dense.jl:335
^(A::AbstractArray{T,2} where T, p::Number) in Base.LinAlg at linalg/dense.jl:391
all(f::Function, A::AbstractArray, region) in Base at reducedim.jl:570
all(A::AbstractArray, region) in Base at reducedim.jl:572
all!(f::Function, r::AbstractArray, A::AbstractArray) in Base at reducedim.jl:566
all!(r::AbstractArray, A::AbstractArray) in Base at reducedim.jl:568
any(f::Function, A::AbstractArray, region) in Base at reducedim.jl:570
any(A::AbstractArray, region) in Base at reducedim.jl:572
any!(f::Function, r::AbstractArray, A::AbstractArray) in Base at reducedim.jl:566
any!(r::AbstractArray, A::AbstractArray) in Base at reducedim.jl:568
bfft(x::AbstractArray) in Base.DFT at dft.jl:56
bfft(x::AbstractArray, region) in Base.DFT at dft.jl:57
bfft!(x::AbstractArray) in Base.DFT at dft.jl:56
bfft!(x::AbstractArray, region) in Base.DFT at dft.jl:57
bkfact(A::Union{Hermitian{T,S}, Symmetric{T,S}} where S where T) in Base.LinAlg at linalg/symmetric.jl:277
brfft(x::AbstractArray, d::Integer) in Base.DFT at dft.jl:289
brfft(x::AbstractArray, d::Integer, region) in Base.DFT at dft.jl:290
broadcast!(::Base.#identity, X::AbstractArray, x::Number) in Base.Broadcast at broadcast.jl:22
broadcast!(f, X::AbstractArray) in Base at sysimg.jl:84
broadcast!(f, X::AbstractArray, x::Number...) in Base.Broadcast at broadcast.jl:23
broadcast!(f, C::AbstractArray, A, Bs::Vararg{Any,N}) where N in Base.Broadcast at broadcast.jl:204
broadcast_getindex(src::AbstractArray, I::AbstractArray...) in Base.Broadcast at broadcast.jl:475
broadcast_setindex!(A::AbstractArray, x, I::AbstractArray...) in Base.Broadcast at broadcast.jl:499
ceil(::Type{T}, x::AbstractArray) where T in Base at deprecated.jl:56
ceil(x::AbstractArray, digits::Integer) in Base at deprecated.jl:56
ceil(x::AbstractArray, digits::Integer, base::Integer) in Base at deprecated.jl:56
checkbounds(::Type{Bool}, A::AbstractArray, I::Base.LogicalIndex{#s266,#s265} where #s265<:AbstractArray{Bool,1} where #s266) in Base at multidimensional.jl:381
checkbounds(::Type{Bool}, A::AbstractArray, I::Base.LogicalIndex) in Base at multidimensional.jl:383
checkbounds(::Type{Bool}, A::AbstractArray{#s45,N} where #s45, I::AbstractArray{Bool,N}) where N in Base at abstractarray.jl:351
checkbounds(::Type{Bool}, A::AbstractArray, i::Union{AbstractArray{#s266,N} where N where #s266<:CartesianIndex, CartesianIndex}) in Base at multidimensional.jl:231
checkbounds(::Type{Bool}, A::AbstractArray, i) in Base at abstractarray.jl:346
checkbounds(::Type{Bool}, A::AbstractArray, I...) in Base at abstractarray.jl:341
checkbounds(A::AbstractArray) in Base at abstractarray.jl:365
checkbounds(A::AbstractArray, I...) in Base at abstractarray.jl:361
checkindex(::Type{Bool}, inds::AbstractUnitRange, I::AbstractArray) in Base at abstractarray.jl:464
chol(A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/cholesky.jl:185
circshift(a::AbstractArray, shiftamt::Real) in Base at abstractarraymath.jl:171
circshift(a::AbstractArray, shiftamt::Tuple{Vararg{Integer,N}} where N) in Base at abstractarraymath.jl:173
circshift(a::AbstractArray, shiftamt) in Base at abstractarraymath.jl:206
circshift!(dest::AbstractArray, src, ::Tuple{}) in Base at multidimensional.jl:843
circshift!(dest::AbstractArray{T,N}, src, shiftamt::Tuple{Vararg{Integer,N}} where N) where {T, N} in Base at multidimensional.jl:856
circshift!(dest::AbstractArray, src, shiftamt) in Base at multidimensional.jl:861
clamp(A::AbstractArray, lo, hi) in Base at deprecated.jl:56
clamp!(x::AbstractArray, lo, hi) in Base.Math at math.jl:69
collect(A::AbstractArray) in Base at array.jl:399
complex(A::AbstractArray{T,N} where N) where T in Base at complex.jl:906
complex(A::AbstractArray, b::Real) in Base at deprecated.jl:56
complex(a::Real, B::AbstractArray) in Base at deprecated.jl:56
complex(A::AbstractArray, B::AbstractArray) in Base at deprecated.jl:56
cond(A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/dense.jl:911
cond(A::AbstractArray{T,2} where T, p::Real) in Base.LinAlg at linalg/dense.jl:911
condskeel(A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/generic.jl:831
condskeel(A::AbstractArray{T,2} where T, p::Real) in Base.LinAlg at linalg/generic.jl:831
condskeel(A::AbstractArray{T,2} where T, x::AbstractArray{T,1} where T) in Base.LinAlg at linalg/generic.jl:848
condskeel(A::AbstractArray{T,2} where T, x::AbstractArray{T,1} where T, p::Real) in Base.LinAlg at linalg/generic.jl:848
conj(A::Union{Hermitian{T,S}, Symmetric{T,S}} where S where T) in Base.LinAlg at linalg/symmetric.jl:198
conj(A::AbstractArray) in Base at arraymath.jl:29
conj!(A::Union{Hermitian{T,S}, Symmetric{T,S}} where S where T) in Base.LinAlg at linalg/symmetric.jl:199
convert(::Type{Ref{T}}, x::AbstractArray{T,N} where N) where T in Base at refpointer.jl:76
convert(::Type{Array{T,2} where T}, A::Symmetric) in Base.LinAlg at linalg/symmetric.jl:146
convert(::Type{Array{T,2} where T}, x::AbstractArray{T,2}) where T in Base at array.jl:334
convert(::Type{Array{T,N} where N}, x::AbstractArray{S,n}) where {T, n, S} in Base at array.jl:339
convert(::Type{Array{T,n}}, x::AbstractArray{S,n}) where {T, n, S} in Base at array.jl:340
convert(::Type{AbstractArray{T,2}}, A::Symmetric) where T in Base.LinAlg at linalg/symmetric.jl:153
convert(::Type{AbstractArray{T,N}}, A::AbstractArray{T,N}) where {T, N} in Base at abstractarray.jl:834
convert(::Type{AbstractArray{T,N}}, A::AbstractArray{S,N}) where {T, S, N} in Base at abstractarray.jl:835
convert(::Type{AbstractArray{T,N} where N}, A::AbstractArray{S,N}) where {T, S, N} in Base at abstractarray.jl:836
convert(::Type{Array}, A::Union{Hermitian, Symmetric}) in Base.LinAlg at linalg/symmetric.jl:148
convert(::Type{Array}, A::AbstractArray{T,N}) where {T, N} in Base at abstractarray.jl:838
convert(::Type{BitArray}, A::AbstractArray{T,N}) where {T, N} in Base at bitarray.jl:503
convert(::Type{BitArray{N}}, A::AbstractArray{T,N}) where {T, N} in Base at bitarray.jl:505
convert(::Type{Symmetric{T,S}}, A::Symmetric{T,S}) where {T, S<:(AbstractArray{T,2} where T)} in Base.LinAlg at linalg/symmetric.jl:151
convert(::Type{Symmetric{T,S}}, A::Symmetric) where {T, S<:(AbstractArray{T,2} where T)} in Base.LinAlg at linalg/symmetric.jl:152
convert(::Type{SparseMatrixCSC}, M::AbstractArray{Tv,2}) where Tv in Base.SparseArrays at sparse/sparsematrix.jl:321
convert(::Type{SparseMatrixCSC{Tv,Ti} where Ti<:Integer}, M::AbstractArray{Tv,2}) where Tv in Base.SparseArrays at sparse/sparsematrix.jl:322
convert(::Type{SparseMatrixCSC{Tv,Ti}}, M::AbstractArray{T,2} where T) where {Tv, Ti} in Base.SparseArrays at sparse/sparsematrix.jl:324
copy(A::Symmetric{T,S}) where {T, S} in Base.LinAlg at linalg/symmetric.jl:158
copy(a::AbstractArray) in Base at abstractarray.jl:696
copy!(dest::AbstractArray, dstart::Integer, src::AbstractArray) in Base at abstractarray.jl:672
copy!(dest::AbstractArray, dstart::Integer, src::AbstractArray, sstart::Integer) in Base at abstractarray.jl:676
copy!(dest::AbstractArray, dstart::Integer, src::AbstractArray, sstart::Integer, n::Integer) in Base at abstractarray.jl:684
copy!(dest::AbstractArray, dstart::Integer, src) in Base at abstractarray.jl:580
copy!(dest::AbstractArray, dstart::Integer, src, sstart::Integer) in Base at abstractarray.jl:590
copy!(dest::AbstractArray, dstart::Integer, src, sstart::Integer, n::Integer) in Base at abstractarray.jl:618
copy!(B::Union{AbstractArray{R,1}, AbstractArray{R,2}}, ir_dest::Range{Int64}, jr_dest::Range{Int64}, A::Union{AbstractArray{S,1}, AbstractArray{S,2}}, ir_src::Range{Int64}, jr_src::Range{Int64}) where {R, S} in Base at abstractarray.jl:702
copy!(dest::PermutedDimsArray{T,N,perm,iperm,AA} where AA<:AbstractArray where iperm where perm, src::AbstractArray{T,N}) where {T, N} in Base.PermutedDimsArrays at permuteddimsarray.jl:136
copy!(dest::PermutedDimsArray, src::AbstractArray) in Base.PermutedDimsArrays at permuteddimsarray.jl:139
copy!(B::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, ir_dest::UnitRange{Int64}, jr_dest::UnitRange{Int64}, tM::Char, M::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, ir_src::UnitRange{Int64}, jr_src::UnitRange{Int64}) in Base.LinAlg at linalg/matmul.jl:378
copy!(dest::Symmetric, src::Symmetric) in Base.LinAlg at linalg/symmetric.jl:162
copy!(dest::AbstractArray, D::Base.SparseArrays.CHOLMOD.Dense) in Base.SparseArrays.CHOLMOD at sparse/cholmod.jl:1035
copy!(dest::AbstractArray{T,N}, src::AbstractArray{T,N}) where {T, N} in Base at multidimensional.jl:803
copy!(dest::AbstractArray, src::AbstractArray) in Base at abstractarray.jl:647
copy!(dest::AbstractArray{T1,N}, Rdest::CartesianRange{CartesianIndex{N}}, src::AbstractArray{T2,N}, Rsrc::CartesianRange{CartesianIndex{N}}) where {T1, T2, N} in Base at multidimensional.jl:814
copy!(A::AbstractArray{T,2} where T, J::UniformScaling) in Base.LinAlg at linalg/uniformscaling.jl:182
copy!(dest::AbstractArray, src) in Base at abstractarray.jl:570
copy!(::IndexStyle, dest::AbstractArray, ::IndexCartesian, src::AbstractArray) in Base at abstractarray.jl:661
copy!(::IndexStyle, dest::AbstractArray, ::IndexStyle, src::AbstractArray) in Base at abstractarray.jl:651
cor(X::AbstractArray{T,2} where T) in Base at statistics.jl:507
cor(X::AbstractArray{T,2} where T, vardim::Int64) in Base at statistics.jl:505
cor(x::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, y::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, vardim::Int64) in Base at statistics.jl:522
cor(x::AbstractArray{T,1} where T, Y::AbstractArray{T,2} where T) in Base at statistics.jl:525
cor(X::AbstractArray{T,2} where T, y::AbstractArray{T,1} where T) in Base at statistics.jl:526
cor(X::AbstractArray{T,2} where T, Y::AbstractArray{T,2} where T) in Base at statistics.jl:527
count(pred, a::AbstractArray) in Base at reduce.jl:697
cov(X::AbstractArray{T,2} where T) in Base at statistics.jl:360
cov(X::AbstractArray{T,2} where T, vardim::Int64) in Base at statistics.jl:357
cov(X::AbstractArray{T,2} where T, vardim::Int64, corrected::Bool) in Base at statistics.jl:357
cov(X::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, Y::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, vardim::Int64) in Base at statistics.jl:383
cov(X::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, Y::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, vardim::Int64, corrected::Bool) in Base at statistics.jl:383
cov(x::AbstractArray{T,1} where T, Y::AbstractArray{T,2} where T) in Base at statistics.jl:386
cov(X::AbstractArray{T,2} where T, y::AbstractArray{T,1} where T) in Base at statistics.jl:387
cov(X::AbstractArray{T,2} where T, Y::AbstractArray{T,2} where T) in Base at statistics.jl:388
ctranspose(A::Symmetric) in Base.LinAlg at linalg/symmetric.jl:188
ctranspose(A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/transpose.jl:124
ctranspose(a::AbstractArray) in Base.LinAlg at linalg/transpose.jl:3
ctranspose!(B::AbstractArray{T,2} where T, A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/transpose.jl:26
cumprod(A::AbstractArray) in Base at multidimensional.jl:647
cumprod(A::AbstractArray, axis::Integer) in Base at multidimensional.jl:647
cumsum(A::AbstractArray{T,N} where N) where T in Base at multidimensional.jl:611
cumsum(A::AbstractArray{T,N} where N, axis::Integer) where T in Base at multidimensional.jl:611
det(A::Symmetric) in Base.LinAlg at linalg/symmetric.jl:282
det(A::AbstractArray{T,2}) where T in Base.LinAlg at linalg/generic.jl:1205
diag(A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/dense.jl:250
diag(A::AbstractArray{T,2} where T, k::Integer) in Base.LinAlg at linalg/dense.jl:250
diagind(A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/dense.jl:227
diagind(A::AbstractArray{T,2} where T, k::Integer) in Base.LinAlg at linalg/dense.jl:227
diff(A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/generic.jl:272
diff(A::AbstractArray{T,2} where T, dim::Integer) in Base.LinAlg at linalg/generic.jl:272
div(A::Number, B::AbstractArray) in Base at deprecated.jl:56
div(A::AbstractArray, B::Number) in Base at deprecated.jl:56
div(A::AbstractArray, B::AbstractArray) in Base at deprecated.jl:56
done(A::AbstractArray, i) in Base at abstractarray.jl:760
eachindex(A::AbstractArray) in Base at abstractarray.jl:809
eachindex(A::AbstractArray, B::AbstractArray) in Base at abstractarray.jl:812
eachindex(A::AbstractArray, B::AbstractArray...) in Base at abstractarray.jl:816
eachindex(::IndexLinear, A::AbstractArray) in Base at abstractarray.jl:819
eachindex(::IndexLinear, A::AbstractArray, B::AbstractArray...) in Base at abstractarray.jl:821
eachindex(::IndexCartesian, A::AbstractArray) in Base.IteratorsMD at multidimensional.jl:138
eachindex(::IndexCartesian, A::AbstractArray, B::AbstractArray...) in Base.IteratorsMD at multidimensional.jl:140
eig(A::AbstractArray{T,2} where T, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/eigen.jl:359
eig(A::AbstractArray{T,2} where T, args...) in Base.LinAlg at linalg/eigen.jl:136
eigfact(A::AbstractArray{TA,2}, B::AbstractArray{TB,2}) where {TA, TB} in Base.LinAlg at linalg/eigen.jl:327
eigs(A::AbstractArray{T,2}, ::UniformScaling) where T in Base.LinAlg at linalg/arnoldi.jl:97
eigs(A::AbstractArray{T,2} where T, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/arnoldi.jl:101
eigvals(A::AbstractArray{TA,2}, B::AbstractArray{TB,2}) where {TA, TB} in Base.LinAlg at linalg/eigen.jl:408
eigvecs(A::Union{AbstractArray{T,2} where T, Number}) in Base.LinAlg at linalg/eigen.jl:157
eigvecs(A::AbstractArray{T,2} where T, B::AbstractArray{T,2} where T) in Base.LinAlg at linalg/eigen.jl:437
endof(a::AbstractArray) in Base at abstractarray.jl:134
enumerate(::IndexLinear, A::AbstractArray) in Base.Iterators at iterators.jl:124
enumerate(::IndexCartesian, A::AbstractArray) in Base.Iterators at iterators.jl:125
expm(A::Symmetric) in Base.LinAlg at linalg/symmetric.jl:508
extrema(A::AbstractArray, dims) in Base at multidimensional.jl:1437
eye(x::AbstractArray{T,2}) where T in Base at array.jl:320
factorize(A::Union{Hermitian{T,S}, Symmetric{T,S}} where S where T) in Base.LinAlg at linalg/symmetric.jl:278
falses(A::AbstractArray) in Base at bitarray.jl:391
fft(x::AbstractArray) in Base.DFT at dft.jl:56
fft(x::AbstractArray, region) in Base.DFT at dft.jl:57
fft!(x::AbstractArray) in Base.DFT at dft.jl:56
fft!(x::AbstractArray, region) in Base.DFT at dft.jl:57
fill!(A::AbstractArray{T,N} where N, x) where T in Base at multidimensional.jl:788
filt(b::Union{AbstractArray{T,1} where T, Number}, a::Union{AbstractArray{T,1} where T, Number}, x::AbstractArray{T,N} where N) where T in Base.DSP at dsp.jl:19
filt(b::Union{AbstractArray{T,1} where T, Number}, a::Union{AbstractArray{T,1} where T, Number}, x::AbstractArray{T,N} where N, si::AbstractArray{S,N} where N) where {T, S} in Base.DSP at dsp.jl:19
filt!(out::AbstractArray, b::Union{AbstractArray{T,1} where T, Number}, a::Union{AbstractArray{T,1} where T, Number}, x::AbstractArray{T,N} where N) where T in Base.DSP at dsp.jl:33
filt!(out::AbstractArray, b::Union{AbstractArray{T,1} where T, Number}, a::Union{AbstractArray{T,1} where T, Number}, x::AbstractArray{T,N} where N, si::AbstractArray{S,N}) where {T, S, N} in Base.DSP at dsp.jl:33
filter(f, As::AbstractArray) in Base at array.jl:1819
findmax(A::AbstractArray{T,N} where N, region) where T in Base at reducedim.jl:692
findmax!(rval::AbstractArray, rind::AbstractArray, A::AbstractArray) in Base at reducedim.jl:670
findmin(A::AbstractArray{T,N} where N, region) where T in Base at reducedim.jl:654
findmin!(rval::AbstractArray, rind::AbstractArray, A::AbstractArray) in Base at reducedim.jl:632
findn(A::AbstractArray{T,2} where T) in Base at array.jl:1535
findn(A::AbstractArray{T,N}) where {T, N} in Base at multidimensional.jl:514
findnz(A::AbstractArray{T,2}) where T in Base at array.jl:1567
first(a::AbstractArray) in Base at abstractarray.jl:135
flipdim(A::AbstractArray, d::Integer) in Base at abstractarraymath.jl:141
float(A::AbstractArray{T,N} where N) where T in Base at float.jl:847
floor(::Type{T}, A::AbstractArray) where T in Base at deprecated.jl:56
floor(A::AbstractArray, digits::Integer) in Base at deprecated.jl:56
floor(A::AbstractArray, digits::Integer, base::Integer) in Base at deprecated.jl:56
full(A::Union{Hermitian, Symmetric}) in Base.LinAlg at linalg/symmetric.jl:149
full(x::AbstractArray) in Base at abstractarray.jl:847
get(A::AbstractArray, i::Integer, default) in Base at abstractarray.jl:1009
get(A::AbstractArray, I::Tuple{}, default) in Base at abstractarray.jl:1010
get(A::AbstractArray, I::Tuple{Vararg{Int64,N}} where N, default) in Base at abstractarray.jl:1011
get(A::AbstractArray, I::Range, default) in Base at abstractarray.jl:1031
get(A::AbstractArray, I::Union{AbstractArray{A,1}, AbstractArray{Range{Int64},1}, AbstractArray{UnitRange{Int64},1}, Tuple{Vararg{Union{AbstractArray{Int64,1}, Range},N} where N}} where A<:AbstractArray{Int64,1}, default) in Base at abstractarray.jl:1041
get!(X::AbstractArray{T,N} where N, A::AbstractArray, I::Union{AbstractArray{Int64,1}, Range}, default::T) where T in Base at abstractarray.jl:1024
get!(X::AbstractArray{T,N} where N, A::AbstractArray, I::Union{AbstractArray{A,1}, AbstractArray{Range{Int64},1}, AbstractArray{UnitRange{Int64},1}, Tuple{Vararg{Union{AbstractArray{Int64,1}, Range},N} where N}} where A<:AbstractArray{Int64,1}, default::T) where T in Base at abstractarray.jl:1035
getindex(v::SimpleVector, I::AbstractArray) in Base at essentials.jl:276
getindex(A::Symmetric, i::Integer, j::Integer) in Base.LinAlg at linalg/symmetric.jl:109
getindex(A::SparseMatrixCSC{Tv,Ti} where Ti<:Integer, I::AbstractArray) where Tv in Base.SparseArrays at sparse/sparsematrix.jl:2166
getindex(x::AbstractSparseArray{Tv,Ti,1} where Ti where Tv, I::AbstractArray) in Base.SparseArrays at sparse/sparsevector.jl:729
getindex(A::AbstractArray, I...) in Base at abstractarray.jl:880
getindex(t::Tuple, r::AbstractArray) in Base at deprecated.jl:56
givens(A::AbstractArray{T,2} where T, i1::Integer, i2::Integer, j::Integer) in Base.LinAlg at linalg/givens.jl:281
hash(a::AbstractArray, h::UInt64) in Base at abstractarray.jl:1945
hcat(A::AbstractArray) in Base at abstractarray.jl:1312
hcat(A::AbstractArray, B::AbstractArray) in Base at abstractarray.jl:1313
ifelse(c::AbstractArray{Bool,N} where N, x::AbstractArray, y::AbstractArray) in Base at deprecated.jl:56
ifelse(c::AbstractArray{Bool,N} where N, x, y::AbstractArray) in Base at deprecated.jl:56
ifelse(c::AbstractArray{Bool,N} where N, x::AbstractArray, y) in Base at deprecated.jl:56
ifft(x::AbstractArray) in Base.DFT at dft.jl:56
ifft(x::AbstractArray, region) in Base.DFT at dft.jl:57
ifft!(x::AbstractArray) in Base.DFT at dft.jl:56
ifft!(x::AbstractArray, region) in Base.DFT at dft.jl:57
imag(A::AbstractArray) in Base at arraymath.jl:29
ind2sub(A::AbstractArray, ind) in Base at abstractarray.jl:1557
indexin(a::AbstractArray, b::AbstractArray) in Base at array.jl:1736
indices(A::AbstractArray{T,N}, d) where {T, N} in Base at abstractarray.jl:46
inv(A::AbstractArray{T,2}) where T in Base.LinAlg at linalg/generic.jl:769
ipermutedims(A::AbstractArray, p) in Base at deprecated.jl:56
irfft(x::AbstractArray, d::Integer) in Base.DFT at dft.jl:289
irfft(x::AbstractArray, d::Integer, region) in Base.DFT at dft.jl:290
isapprox(x::AbstractArray, y::AbstractArray) in Base.LinAlg at linalg/generic.jl:1280
isassigned(a::AbstractArray, i::Int64...) in Base at abstractarray.jl:221
isdiag(A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/generic.jl:1025
isempty(a::AbstractArray) in Base at abstractarray.jl:830
isequal(A::AbstractArray, B::AbstractArray) in Base at abstractarray.jl:1496
ishermitian(A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/generic.jl:916
isinteger(A::AbstractArray) in Base at deprecated.jl:56
isposdef(A::AbstractArray{T,2}) where T in Base.LinAlg at linalg/dense.jl:78
isposdef(A::AbstractArray{T,2}, UL::Symbol) where T in Base.LinAlg at linalg/dense.jl:57
isreal(x::AbstractArray) in Base at abstractarraymath.jl:5
issparse(A::AbstractArray) in Base.SparseArrays at sparse/abstractsparse.jl:13
issymmetric(A::Symmetric) in Base.LinAlg at linalg/symmetric.jl:184
issymmetric(A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/generic.jl:876
istril(A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/generic.jl:991
istriu(A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/generic.jl:956
iszero(x::AbstractArray) in Base at abstractarraymath.jl:6
kron(a::AbstractArray{T,2}, b::AbstractArray{S,2}) where {T, S} in Base.LinAlg at linalg/dense.jl:313
kron(a::Number, b::Union{Number, Union{AbstractArray{T,1}, AbstractArray{T,2}} where T}) in Base.LinAlg at linalg/dense.jl:325
kron(a::Union{AbstractArray{T,1}, AbstractArray{T,2}} where T, b::Number) in Base.LinAlg at linalg/dense.jl:326
kron(a::AbstractArray{T,2} where T, b::AbstractArray{T,1} where T) in Base.LinAlg at linalg/dense.jl:328
kron(a::AbstractArray{T,1} where T, b::AbstractArray{T,2} where T) in Base.LinAlg at linalg/dense.jl:329
length(t::AbstractArray) in Base at abstractarray.jl:131
lexcmp(A::AbstractArray, B::AbstractArray) in Base at abstractarray.jl:1512
logabsdet(A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/generic.jl:1219
logdet(A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/generic.jl:1243
lq(A::Union{AbstractArray{T,2} where T, Number}) in Base.LinAlg at linalg/lq.jl:44
lu(A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/lu.jl:190
lu(A::AbstractArray{T,2} where T, pivot::Union{Type{Val{false}}, Type{Val{true}}}) in Base.LinAlg at linalg/lu.jl:190
lufact(A::AbstractArray{T,2}) where T in Base.LinAlg at linalg/lu.jl:147
lufact(A::AbstractArray{T,2}, pivot::Union{Type{Val{false}}, Type{Val{true}}}) where T in Base.LinAlg at linalg/lu.jl:140
map(f, A::Union{AbstractArray, AbstractSet, Associative}) in Base at abstractarray.jl:1865
map!(f::F, A::AbstractArray) where F in Base at deprecated.jl:56
map!(f::F, dest::AbstractArray, A::AbstractArray) where F in Base at abstractarray.jl:1858
map!(f::F, dest::AbstractArray, A::AbstractArray, B::AbstractArray) where F in Base at abstractarray.jl:1892
map!(f::F, dest::AbstractArray, As::AbstractArray...) where F in Base at abstractarray.jl:1928
mapreduce(f, op, A::AbstractArray) in Base at reduce.jl:286
mapreducedim(f, op, A::AbstractArray, region) in Base at reducedim.jl:241
mapreducedim(f, op, A::AbstractArray, region, v0) in Base at reducedim.jl:239
mapslices(f, A::AbstractArray, dims::AbstractArray{T,1} where T) in Base at abstractarray.jl:1784
mapslices(f, A::AbstractArray, dims) in Base at abstractarray.jl:1782
maximum(f::Function, A::AbstractArray, region) in Base at reducedim.jl:570
maximum(A::AbstractArray, region) in Base at reducedim.jl:572
maximum!(f::Function, r::AbstractArray, A::AbstractArray) in Base at reducedim.jl:566
maximum!(r::AbstractArray, A::AbstractArray) in Base at reducedim.jl:568
mean(f::Union{Function, Type}, A::AbstractArray) in Base at statistics.jl:35
mean(A::AbstractArray) in Base at statistics.jl:36
mean(A::AbstractArray{T,N} where N, region) where T in Base at statistics.jl:57
mean!(R::AbstractArray, A::AbstractArray) in Base at statistics.jl:39
median(v::AbstractArray{T,N} where N) where T in Base at statistics.jl:605
median(v::AbstractArray, region) in Base at statistics.jl:619
median!(v::AbstractArray) in Base at statistics.jl:604
middle(a::AbstractArray) in Base at statistics.jl:580
minimum(f::Function, A::AbstractArray, region) in Base at reducedim.jl:570
minimum(A::AbstractArray, region) in Base at reducedim.jl:572
minimum!(f::Function, r::AbstractArray, A::AbstractArray) in Base at reducedim.jl:566
minimum!(r::AbstractArray, A::AbstractArray) in Base at reducedim.jl:568
mod(A::AbstractArray, B::AbstractArray) in Base at deprecated.jl:56
mod(x::Number, A::AbstractArray) in Base at deprecated.jl:56
mod(A::AbstractArray, x::Number) in Base at deprecated.jl:56
ndims(::AbstractArray{T,N}) where {T, N} in Base at abstractarray.jl:115
next(A::AbstractArray, i) in Base at abstractarray.jl:759
nextind(s::AbstractArray, i::Integer) in Base at strings/basic.jl:174
norm(A::AbstractArray{T,2} where T) in Base.LinAlg at linalg/generic.jl:576
norm(A::AbstractArray{T,2} where T, p::Real) in Base.LinAlg at linalg/generic.jl:576
one(x::AbstractArray{T,2}) where T in Base at array.jl:328
ones(a::AbstractArray) in Base at array.jl:261
ones(a::AbstractArray, T::Type) in Base at array.jl:261
ones(a::AbstractArray, T::Type, dims::Tuple) in Base at array.jl:259
ones(a::AbstractArray, T::Type, dims...) in Base at array.jl:260
oneunit(x::AbstractArray{T,2}) where T in Base at array.jl:329
parent(A::Union{Hermitian{T,S}, Symmetric{T,S}} where S where T) in Base.LinAlg at linalg/symmetric.jl:150
parent(a::AbstractArray) in Base at subarray.jl:63
parentindexes(a::AbstractArray) in Base at subarray.jl:69
permutedims(A::AbstractArray, perm) in Base.PermutedDimsArrays at permuteddimsarray.jl:115
permutedims!(dest, src::AbstractArray, perm) in Base.PermutedDimsArrays at permuteddimsarray.jl:129
plan_bfft(x::AbstractArray) in Base.DFT at dft.jl:58
plan_bfft!(x::AbstractArray) in Base.DFT at dft.jl:58
plan_brfft(x::AbstractArray, d::Integer) in Base.DFT at dft.jl:291
plan_dct(x::AbstractArray) in Base.DFT.FFTW at fft/dct.jl:55
plan_dct!(x::AbstractArray) in Base.DFT.FFTW at fft/dct.jl:55
plan_fft(x::AbstractArray) in Base.DFT at dft.jl:58
plan_fft!(x::AbstractArray) in Base.DFT at dft.jl:58
plan_idct(x::AbstractArray) in Base.DFT.FFTW at fft/dct.jl:55
plan_idct!(x::AbstractArray) in Base.DFT.FFTW at fft/dct.jl:55

Multimethods
Any
AbstractArray{T,N}
Array{T,N}
Matrix{T}
Symmetric{T,S}
Matrix{Float64}
NumberString
Complex{T} Real
Float64 Float16
double(x) = 2*x
double(x::Rational{T}) = Rational{T}(2*x.num, x.den)
double(x::Int) = x << 1
Integer
Int BigInt

Multimethods
Any
AbstractArray{T,N}
Array{T,N}
Matrix{T}
Symmetric{T,S}
Matrix{Float64}
NumberString
Complex{T} Real
Float64 Float16
double(x) = 2*x
double(x::Rational{T}) = Rational{T}(2*x.num, x.den)
double(x::Integer) = x << 1
Integer
Int BigInt
Most generic deﬁnition gets you more features for free

Matrix types in Julia
• Dense matrix: Matrix{T} = AbstractArray{T, 2}
• Sparse matrix: SparseMatrixCSC{T}
• Special matrix types: Symmetric{T},
SymTridiagonal{T}, ...
• Types with the algebra of matrices but not the indexing
behavior of 2D arrays
• Matrix factorizations: LU{T,S}, QRCompactWY{T, S}
• "Algebraic matrices": QRCompactWYQ{T,S}

Multi-methods for linear algebra
What can I do with/to a thing?
compute spectral factorization
compute singular values
compute singular values and vectors
compute eigenvalues
generic
function
objectsmethods
Methods can take advantage of special matrix structures
eigvals
eigfact
svdvals
svdfact
Matrix
SymTridiagonal
Bidiagonal

The secret to Julia’s speed and composability
You can deﬁne new types with new algebra at
run time.
If the compiler can ﬁgure out exactly which
method you need to use when you invoke a
function, then it generates optimized code.
Composability at run time is strictly more
powerful than at compile time, c.f. C++
expression templates, Haskell typeclasses,...

easy to call external C
functions, e.g. CLAPACK
sstev, dstev…

textbook algorithm
Run time composition enables matrix algebra
over user-deﬁned rings

Run time composition enables matrix algebra
over user-deﬁned rings

Implementing Householder notation is serious business
• Recently presented at JuliaCon 2017
• Punchline: there are two incompatible abstractions
behind vectors that are impossible to implement
perfectly in any programming language

The surface problem (pre-0.6)
I can't compute inner products with Julia!
julia> u = [1, 2, 3];
julia> u'*u
1-element Array{Int64,1}:
14
I am an unhappy mathematician!
Don't you Julia people know any mathematics??
julia> u*u'/u'*u
ERROR: DimensionMismatch("second dimension of A, 1,
does not match length of x, 3")
in gemv!
(::Array{Float64,1}, ::Char, ::Array{Float64,2}, ::Arra
y{Float64,1}) at ./linalg/matmul.jl:219
in *(::Array{Float64,2}, ::Array{Int64,1}) at ./
linalg/matmul.jl:80
julia> :'(

Definition 1. A vector is a
column of a matrix.
Definition 2. A vector is that
which has the algebra of a
vector space.
naturally isomorphic but not identical
AType 2 vector is "flat": no intrinsic orientation as column or row

Why these two deﬁnitions? 
A brief history of matrices and vectors
matrix universe
antiquity - 1937
vector universe
1844 - 1930
hypercomplex numbers
coordinate geometry
simultaneous equations
determinants
linear maps Householder notation
matrix+vector universe 
1924 - present
linear algebra
tuples
vector spaces
eigenvalues
operators

matrix universe
antiquity - 1937
vector universe
1844 - 1930
scalar/vector products
determinants
1924 - present
linear algebra
tuples
vector spaces
eigenvalues
operators
Deﬁnition 1. A vector is a
column of a matrix, i.e. a column
matrix.
Stewart (1966), ...
Deﬁnition 2. A vector is that which has
the algebra of a vector space.
Peano (1888), van der Waerden (1931)Weyl (1928) ? 
"column matrix" coined
Cullis (1913) 
A = [Amn] and b = [bm] notations
Weyl (1928), van der Waerden (1931) , Turnbull & Aitken (1932)...
column matrices form a vector space
Schrier & Sperner (1931) ?
"n-tuple" (n-Tupel) coined

matrix universe
antiquity - 1937
vector universe
1844 - 1930
scalar/vector products
determinants
1924 - present
linear algebra
tuples
vector spaces
eigenvalues
operators
1924
|
1961
Unification era: Matrix-vector
relationship needed explanation &'
Post-unification: "It's so obvious" lel
😹
1967
|
now
Pre-unification era 🦊🐺🐳🐉🦀
now told with 100% more emoji!

Van der Waerden, ModerneAlgebra (1931)
1931: (Noether, Artin and) van der Waerden, Moderne Algebra
1966: van der Waerden, Algebra 6/e
1970: English translation: https://archive.org/details/algebra01waer
The ﬁrst comprehensive treatise on abstract algebra

coefﬁcientvector
tuple
column
matrix

vector
tuple
column
matrix
coefficient (ring element)
satisfies the
algebra
of a vector
space an indexable
collection of
coefficients;
no algebra
satisfies the
linear algebra
of matrices

1931: (Noether, Artin and) van der Waerden, ModerneAlgebra
vector
tuple
column
matrix
coefficient (ring element)
satisfies the
algebra
of a vector
space
satisfies the
linear algebra
of matrices
most of these words are
horribly overloaded
an indexable
collection of
coefficients;
no algebra

1935: Thurstone, The Vectors Of Mind: Multiple FactorAnalysis For The Isolation Of Primary Traits
https://archive.org/details/vectorsofmindmul010122mbp
A quote from the transitional era

fast forward to 1953...
Alston S. Householder invents the ﬁeld of
numerical analysis

All numerical analysts today use
Householder notation
• Three types: scalars α,β,…; vectors, a, b, …; and
matrices A,B,…
• Inner product u'*v 
vector, vector ⟶ scalar
• Outer product u*v' 
vector, vector ⟶ matrix
• Quadratic/bilinear forms u'*A*v 
vector, matrix, vector ⟶ scalar
only transpose (') and
multiplication (*) are
needed to write these
expressions
A. S. Householder, Introduction to NumericalAnalysis (1953)

Householder notation only needs
matrix operations
u 
vector
v 
vector
U 
column matrix
V 
column matrix
' 
matrix transpose
U' 
row matrix
U'V 
1×1 matrix* 
matrix multiply
u'*v 
"true" 
scalar
+ isomorphisms
vector
to
matrix
vector
to
matrix
matrix
to
"true"
scalar

Householder notation only needs
matrix operations
u 
vector
v 
vector
U 
column matrix
V 
column matrix
' 
matrix transpose
U' 
row matrix
U'V 
1×1 matrix* 
matrix multiply
u'*v 
"true" 
scalar
+ isomorphisms
vector
to
matrix
vector
to
matrix
matrix
to
"true"
scalar
Julia's deﬁnition of vector transpose
(≤v0.5)

Why Julia ≤v0.5 was broken
u 
vector
v 
vector
U 
column matrix
' 
matrix transpose
U' 
row matrix
U'v 
1-vector* 
matrix-vector product
u'*v 
"true" 
scalar
not enough isomorphisms
vector
to
matrix
vector
to
"true"
scalar
Julia's deﬁnition of vector transpose
(≤v0.5)
X
Result: unhappy Einstein

MATLAB ⟵ The Matrix Laboratory
An anomaly in modern languages because it still uses Type 1
(column) vectors
"Matrices with one dimension equal to one and the other
greater than one are called vectors"
- MATLAB R2016a manual
"For MATLAB, the matrix is the only data type (although
scalars, vectors and text are special cases)"
- C. Moler, UNM Technical Report (1980)
MATLAB® is a trademark of The MathWorks, Inc.

MATLAB has no true scalars or
vectors
• Trailing singleton dimension rule allows on-demand conversion
between 1×1 matrix and scalar, vector and column matrix.
u 
vector
v 
vector
U 
column matrix
V 
column matrix
' 
matrix transpose
U' 
row matrix
U'V 
1×1 matrix* 
matrix multiply
u'*v 
"true" 
scalar
add [,1]
add [,1]
drop [1,1]
in future 
expressions 
if needed

MATLAB's * must implement
(array) shape-based dispatch

Language design considerations
for Householder notation
• Can we rely on just transpose (') and multiplication (*)
to write these expressions?
• If not, need special parsing rules to make Householder
work. Make _'*_ its own special operator 
 
=> u'*v != (u')*v 
 
Special parsing rules add complexity to a language.

Let A be a m×n matrix and b be a n-vector.
Then we observe the following design matrix:
Impossible to express Householder notation with only
scalar, vector and matrix types!!
A*b is a m-vector A*b is a m×1 matrix
b' == b
u*v' == u'*v
outer product wrong
u'*A*v is a 1x1 matrix
quadratic product wrong
b' is a
1×n
matrix
u'*v is a 1-vector
inner product wrong

b' == b
u*v' == u'*v
outer product wrong
|
|
|
u'*A*v is a 1x1 matrix
quadratic product wrong
|
|
|
b' is a
1×n
matrix
u'*v is a 1-vector
inner product wrong
b' is a
row
vector
✅
Householder works
Thus was introduced the RowVector...
Can express Householder notation with scalar, vector,
row vector, and matrix types!

b' is an error Lua/Torch
b' == b
Mathematica 
Python
Ruby (numo)
b' is a 1×n matrix Julia (≤ v0.5)
R
(MATLAB)
b' is a row n-vector
Julia (v0.6)
PARI/GP
What do other languages do?

How row vectors work
New deﬁnitions of ' and * needed, but syntax tree is simpler
u 
vector
v 
vector
' 
vector transpose
u' 
row vector
u'v 
scalar* 
row-column product

High Performance Julia (2017)
• Statistical computations for genomics 
BioJulia, OpenMendel, MIT/Intel, ...
• Numerical optimization and automatic diﬀerentiation 
JuMP (MIT), LowRankModels, ...
• Variational Bayesian inference 
Celeste (LBNL), ...
• Quantitative economics 
QuantEcon, FRBNY models, ...
• Other industry uses

(non-restarted) GKL with partial reorthogonalization
ω-recurrence threshold
triggered
20 singular values resnorm
threshold = 1e-8

(non-restarted) GKL with partial reorthogonalization
20 singular values resnorm
threshold = 1e-8
ω-recurrence threshold
triggered

thick-restart GKL with adaptive one-sided full
reorthogonalization
restart threshold
20 singular values
resnorm threshold = 1e-8

thick-restart GKL with adaptive one-sided full
reorthogonalization
restart threshold 20 singular values
resnorm threshold = 1e-8

βﬁnal ||Δθ||1 ||Δθ||∞
FlashPCA 2280 2616.1 s 6.4 4E+04 4E+04
Thick restart GKL
svdl in IterativeSolvers
280
matvecs
397.8 s 6.4 2E-03 2E-03
(non-restarted) GKL with partial
reorthogonalization
321 302.4 s 15072 6E-04 6E-04
PROPACK called from Julia
(partial reorthogonalization)
298 264.6 s - 4E-08 4E-08
Implicitly restarted Arnoldi
(ARPACK called from Julia)
355 858.5 s 7.8 6E-03 1E-03
80000 x 40000 model problem (density = 0.34)
20 singular values, no vectors, thres. = 1E-8, 16-thread OpenBLAS

@inline function getindex(M::PLINK1Matrix, i, j)
offset = (i-1)*M.n+(j-1) #Assume row major
byteoffset = (offset >> 2) + 4
crumboffset = offset & 0b00000011
@inbounds rawbyte = M.data[byteoffset]
rawcrumb = (rawbyte >> 6-2crumboffset) & 0b11
ifelse(rawcrumb==0, rawcrumb, rawcrumb-0x01)
end
function A_mul_B!{T}(y::AbstractVector{T},
M::PLINK1Matrix, b::AbstractVector{T})
y[:] = zero(T)
@fastmath @inbounds for i=1:M.m
δy = zero(T)
@simd for j=1:4:M.n
x = M[i,j]; z = b[j]
x2 = M[i,j+1]; z2 = b[j+1]
x3 = M[i,j+2]; z3 = b[j+2]
x4 = M[i,j+3]; z4 = b[j+3]
δy += x*z + x2*z2 + x3*z3 + x4*z4
end
y[i] += δy
end
y
end
the same code developed for ﬂoating point matrices
also accepts custom genotype data formats
8000x4000 matvec:
Matrix{Float64}
(OpenBLAS)
115 ms
PLINK1Matrix
115 ms

2
4
8
16
32
64
128
256
512
1024
2048
4096
8192
16384
32768
65536
131072
2621440
1000
2000
3000
4000
5000
6000
7000
8000
9000
10000
11000
12000
13000
14000
speed(mflops)
intel-mkl-dfti in-place
intel-mkl-dfti out-of-place
fftw3 out-of-place
fftw3 in-place
fftw3-no-simd out-of-place
fftw3-no-simd in-place
dfftpack
emayer
julia
bloodworth
cross
cwplib
esrfft
double-precision complex, 1d transforms
powers of two
FFT in pure Julia code
already comparable to FFTPACK
[ actually was even a bit better;
some recent inlining
regressions in Julia snapshots
Steven Johnson, 2014-06
Presented at NAIS Codegen workshop

High Performance Julia (2017)
• Celeste: high performance astronomical imaging project
at LBNL
• Pure Julia code for variational Bayesian inference,
implemented on a GPAS model written in Julia/MPI-3
• Recent keynote at JuliaCon 2017: 
~1.5 Tﬂops/s on 8,192 Xeon cores 
largest computation in Julia to date

Summary
• High level language design for numerical computations =
teaching computers how to do algebra
• Generic functions like * and ' are heavily overloaded in Julia
and can be extended by users
• But ﬁrst we have to be absolutely clear about what data
structures and algebra we want
• Computers are very poor at reasoning implicitly about
isomorphisms we take for granted today, e.g. 1×1 matrix ↔
scalar, vector ↔ column

But what about Eigen/C++?
• Lazy evaluation with many internal templates 
 
ProductReturnType<MatrixXd, VectorXd>,  
Transpose<GeneralProduct<MatrixXd, VectorXd>>, 
CwiseUnaryOp<internal::scalar_quotient1_op<typename internal::traits<Matrix<double,
-1, -1, 0, -1, -1> >::Scalar>, const Eigen::Matrix<double, -1, -1, 0, -1, -1> > 
...
A*b is a m-vector A*b is a m×1
matrix
b' is a 1×n matrix Eigen Eigen
b' is a row n-
vector
Eigen Eigen
• Result type determined by variable assignment 
 
VectorXd y = x.transpose(); // OK!
MatrixXd Y = x.transpose(); // OK!

But what about arrays?
matrix universe
antiquity - 1937
vector universe
1844 - 1930
coordinate geometry
determinants
1924 - present
linear algebra
tuples
vector spaces
eigenvalues
operators
array universe 
1948 - present
1948: Manchester "Baby" - B line
1967: Strachey: Array{T,N} deﬁnition
1957-61: Arrays in FORTRAN, ALGOL

But what about indexing?
• Type 1 (column) vectors: Indexing is multiplication and
transposition
b[1] == e1'*b
b[1:2] == *b
A[1,2] == e1'*A*e2
• Type 2 ("ﬂat") vectors: No such identities exist
0
B
B
B
B
@
1 0 . . .
0 1 0 . . .
... 0 0 . . .
...
1
C
C
C
C
A

How to index a row vector?
• Choice 1: derive rules from Type 1 (column) vectors by
transposition
b'[1] == (e1'*b)' = (b'*e1)
b'[1:2] == b'*
• Choice 2: Consciously break these identities. Treat ', * as
separate from indexing
0
B
B
B
B
@
1 0 . . .
0 1 0 . . .
... 0 0 . . .
...
1
C
C
C
C
A

But what about tensors?
• At least 3 generalizations of Type 1 and Type 2 vectors!
• Type 1 tensors: to distinguish between columnness and rowness, have indexing
apparatus that disambiguates A12, A
1
2, A1
2
, A
12
.
• Problem: only one of these (A1
2
) is a matrix
• Problem: matrix transpose != permuting dimensions 1↔2
• Problem: matrix transpose is no longer unique: 
A
1
2 ⟶ A
2
1 or A2
1
?
• Type 1' tensors: A
1
2, A1
2
are the same; diﬀerent from A12, A
12
• Type 2 tensors: A12, A
1
2, A1
2
, A
12
are all the same

Designing linear algebra into Julia

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Designing linear algebra into Julia

Similar a Designing linear algebra into Julia (20)

Último

Último (20)

Designing linear algebra into Julia