fix(matrices): remove implied properties and sort remaining alphabetically

Author: mfasi

src/matrices/cauchy.jl

@@ -39,7 +39,7 @@ Cauchy{T}(x::AbstractVector) where {T<:Number} = Cauchy{T}(x, x)
 Cauchy{T}(x::AbstractVector{S}, y::AbstractVector{N}) where {T<:Integer,S<:Number,N<:Number} = Cauchy{Rational{T}}(x, y)
 
 # metadata
-@properties Cauchy [:symmetric, :inverse, :illcond, :posdef, :totpos, :infdiv]
+@properties Cauchy [:illcond, :infdiv, :inverse, :posdef, :totpos]
 
 # properties
 size(A::Cauchy) = (length(A.x), length(A.y))

src/matrices/chow.jl

@@ -32,7 +32,7 @@ Chow(n::Integer, alpha::S, delta::T) where {S,T<:Number} = Chow{typejoin(S,T)}(n
 Chow{T}(n::Integer) where {T<:Number} = Chow{T}(n, 1, 0)
 
 # metadata
-@properties Chow [:hessenberg, :toeplitz, :eigen, :inverse]
+@properties Chow [:eigen, :hessenberg, :inverse, :toeplitz]
 
 # properties
 size(A::Chow) = (A.n, A.n)

src/matrices/circulant.jl

@@ -26,7 +26,7 @@ Circulant(n::Integer) = Circulant{Int}(n)
 Circulant{T}(n::Integer) where {T<:Number} = Circulant(T[1:n;])
 
 # metadata
-@properties Circulant [:circulant, :toeplitz, :normal, :eigen]
+@properties Circulant [:circulant, :normal]
 
 # properties
 size(A::Circulant) = (A.n, A.n)

src/matrices/clement.jl

@@ -40,4 +40,4 @@ function Clement{T}(n::Integer, k::Integer) where {T}
 end
 
 # metadata
-@properties Clement [:tridiagonal, :eigen, :nonneg, :singval] # :posdef if k = 0, :symmetric if k = 1.
+@properties Clement [:eigen, :nonneg, :singval, :tridiagonal] # :posdef if k = 0, :symmetric if k = 1.

src/matrices/companion.jl

@@ -36,7 +36,7 @@ Companion{T}(n::Integer) where {T<:Number} = Companion(T[1:n;])
 Companion{T}(polynomial::Polynomial) where {T<:Number} = Companion(T.(-polynomial.coeffs[end-1:-1:begin] ./ polynomial.coeffs[end]))
 
 # metadata
-@properties Companion Property[]
+@properties Companion [:eigen, :sparse]
 
 # properties
 size(A::Companion) = (A.n, A.n)

src/matrices/comparison.jl

@@ -27,7 +27,7 @@ end
 Comparison(A::AbstractMatrix{T}) where {T<:Number} = Comparison(A, 0)
 
 # metadata
-@properties Comparison Symbol[]
+@properties Comparison Property[]
 
 # properties
 size(A::Comparison) = size(A.A)

src/matrices/cycol.jl

@@ -34,7 +34,7 @@ Cycol{T}(n::Integer) where {T<:Number} = Cycol{T}(n, round(Int, n / 4))
 Cycol{T}(n::Integer, k::Integer) where {T<:Number} = Cycol{T}(n, n, k)
 
 # metadata
-@properties Cycol [:rectangular, :rankdef, :random]
+@properties Cycol [:random, :rankdef, :rectangular]
 
 # properties
 size(A::Cycol) = (A.m, A.n)

src/matrices/dingdong.jl

@@ -27,7 +27,7 @@ DingDong(n::Integer) = DingDong{Int}(n)
 DingDong{T}(n::Integer) where {T<:Integer} = DingDong{Rational{T}}(n)
 
 # metadata
-@properties DingDong [:symmetric, :hankel, :eigen]
+@properties DingDong [:eigen, :hankel]
 
 # properties
 size(A::DingDong) = (A.n, A.n)

src/matrices/dorr.jl

@@ -50,4 +50,4 @@ function Dorr{T}(n::Integer, theta::T) where {T<:Number}
 end
 
 # metadata
-@properties Dorr [:tridiagonal, :diagdom, :illcond, :sparse]
+@properties Dorr [:diagdom, :illcond, :sparse, :tridiagonal]

src/matrices/dramadah.jl

@@ -60,7 +60,7 @@ Dramadah(n::Integer, k::Integer) = Dramadah{Int}(n, k)
 Dramadah{T}(n::Integer) where {T<:Number} = Dramadah{T}(n, 1)
 
 # metadata
-@properties Dramadah Symbol[:toeplitz, :integer, :nonneg, :illcond, :unimodular]
+@properties Dramadah [:illcond, :nonneg, :toeplitz, :unimodular]
 
 # properties
 size(A::Dramadah) = (A.n, A.n)

src/matrices/fiedler.jl

@@ -29,7 +29,7 @@ Fiedler(n::Integer) = Fiedler{Int}(n)
 Fiedler{T}(n::Integer) where {T<:Number} = Fiedler(T[1:n;])
 
 # metadata
-@properties Fiedler [:inverse, :indefinite, :symmetric, :eigen]
+@properties Fiedler [:eigen, :indefinite, :inverse, :symmetric]
 
 # properties
 size(A::Fiedler) = (A.n, A.n)

src/matrices/forsythe.jl

@@ -31,7 +31,7 @@ function Forsythe(n::Integer, alpha::Number, lambda::Number)
 end
 
 # metadata
-@properties Forsythe [:inverse, :illcond, :eigen]
+@properties Forsythe [:eigen, :illcond, :inverse]
 
 # properties
 size(A::Forsythe) = (A.n, A.n)

src/matrices/frank.jl

@@ -33,7 +33,7 @@ Frank(n::Integer, k::Integer) = Frank{Int}(n, k)
 Frank{T}(n::Integer) where {T<:Number} = Frank{T}(n, 0)
 
 # metadata
-@properties Frank [:hessenberg, :integer, :totnonneg, :illcond, :eigen]
+@properties Frank [:eigen, :hessenberg, :illcond, :integer, :totnonneg]
 
 # properties
 size(A::Frank) = (A.n, A.n)

src/matrices/gcdmat.jl

@@ -20,7 +20,7 @@ end
 GCDMat(n::Integer) = GCDMat{Int}(n)
 
 # metadata
-@properties GCDMat [:symmetric, :posdef, :integer, :positive, :infdiv]
+@properties GCDMat [:infdiv, :integer, :posdef, :positive]
 
 # properties
 size(A::GCDMat) = (A.n, A.n)

src/matrices/gearmat.jl

@@ -35,7 +35,7 @@ GearMat(n::Integer, i::Integer, j::Integer) = GearMat{Int}(n, i, j)
 GearMat{T}(n::Integer) where {T<:Number} = GearMat{T}(n, n, -n)
 
 # metadata
-@properties GearMat Symbol[:defective, :eigen, :rankdef, :integer, :sparse]
+@properties GearMat [:defective, :eigen, :integer, :rankdef, :sparse]
 
 # properties
 size(A::GearMat) = (A.n, A.n)

src/matrices/grcar.jl

@@ -31,7 +31,7 @@ Grcar(n::Integer, k::Integer) = Grcar{Int}(n, k)
 Grcar{T}(n::Integer) where {T<:Number} = Grcar{T}(n, 3)
 
 # metadata
-@properties Grcar [:hessenberg, :toeplitz, :integer, :eigen]
+@properties Grcar [:eigen, :hessenberg, :integer, :toeplitz]
 
 # properties
 size(A::Grcar) = (A.n, A.n)

src/matrices/hadamard.jl

@@ -35,7 +35,7 @@ end
 Hadamard(n::Integer) = Hadamard{Int}(n)
 
 # metadata
-@properties Hadamard [:inverse, :integer, :fixedsize]
+@properties Hadamard [:fixedsize, :integer, :inverse]
 
 # properties
 size(A::Hadamard) = (A.n, A.n)

src/matrices/hankel.jl

@@ -36,7 +36,7 @@ Hankel{T}(n::Integer) where {T<:Number} = Hankel(T[1:n;])
 Hankel(v::AbstractVector{T}) where {T<:Number} = Hankel(v, T[])
 
 # metadata
-@properties Hankel [:symmetric, :hankel]
+@properties Hankel [:hankel]
 
 # properties
 size(A::Hankel) = (A.m, A.n)

src/matrices/hanowa.jl

@@ -25,7 +25,7 @@ Hanowa(n::Integer, alpha::T) where {T<:Number} = Hanowa{T}(n, alpha)
 Hanowa{T}(n::Integer) where {T<:Number} = Hanowa{T}(n, T(-1))
 
 # metadata
-@properties Hanowa Symbol[]
+@properties Hanowa [:eigen]
 
 # properties
 size(A::Hanowa) = (A.n, A.n)

src/matrices/hilbert.jl

@@ -38,7 +38,7 @@ Hilbert{T}(n::Integer) where {T<:Number} = Hilbert{T}(n, n)
 Hilbert{T}(m::Integer, n::Integer) where {T<:Integer} = Hilbert{Rational{T}}(m, n)
 
 # metadata
-@properties Hilbert [:symmetric, :inverse, :hankel, :illcond, :posdef, :totpos]
+@properties Hilbert [:hankel, :illcond, :inverse, :posdef, :totpos]
 
 # properties
 size(A::Hilbert) = (A.m, A.n)

src/matrices/inversehilbert.jl

@@ -31,7 +31,7 @@ InverseHilbert(n::Integer) = InverseHilbert{Int}(n)
 InverseHilbert{Rational{T}}(n::Integer) where {T<:Number} = InverseHilbert{T}(n)
 
 # metadata
-@properties InverseHilbert [:symmetric, :inverse, :illcond, :posdef]
+@properties InverseHilbert [:illcond, :inverse, :posdef]
 
 # properties
 size(A::InverseHilbert) = (A.n, A.n)

src/matrices/invhess.jl

@@ -26,7 +26,7 @@ Invhess(x::AbstractVector) = Invhess(x, -x[1:end-1])
 Invhess{T}(n::Integer) where {T<:Number} = Invhess(T[1:n;])
 
 # metadata
-@properties Invhess Symbol[:integer]
+@properties Invhess [:integer]
 
 # properties
 size(A::Invhess) = (A.n, A.n)

src/matrices/involutory.jl

@@ -26,7 +26,7 @@ Involutory(n::Integer) = Involutory{Int}(n)
 Involutory{T}(n::Integer) where {T<:Integer} = Involutory{Rational{T}}(n)
 
 # metadata
-@properties Involutory [:involutory, :integer, :illcond, :eigen]
+@properties Involutory [:eigen, :illcond, :integer, :involutory]
 
 # properties
 size(A::Involutory) = (A.n, A.n)

src/matrices/ipjfact.jl

@@ -31,7 +31,7 @@ Ipjfact(n::Integer, k::Integer) = Ipjfact{Int}(n, k)
 Ipjfact{T}(n::Integer) where {T<:Number} = Ipjfact{T}(n, 0)
 
 # metadata
-@properties Ipjfact [:symmetric, :posdef, :hankel, :illcond, :positive]
+@properties Ipjfact [:hankel, :illcond, :posdef, :positive]
 
 # properties
 size(A::Ipjfact) = (A.n, A.n)

src/matrices/jordbloc.jl

@@ -23,7 +23,7 @@ JordBloc(n::Integer, lambda::Number) = JordBloc{Int}(n, lambda)
 JordBloc{T}(n::Integer) where {T<:Number} = JordBloc{T}(n, T(1))
 
 # metadata
-@properties JordBloc Symbol[:bidiagonal, :eigen, :binary, :nonneg, :defective, :toeplitz]
+@properties JordBloc [:bidiagonal, :binary, :defective, :eigen, :nonneg, :toeplitz]
 
 # properties
 size(A::JordBloc) = (A.n, A.n)

src/matrices/kahan.jl

@@ -47,7 +47,7 @@ function Kahan(m::Integer, n::Integer, theta::AbstractFloat, pert::AbstractFloat
 end
 
 # metadata
-@properties Kahan [:rectangular, :triangular, :inverse, :illcond]
+@properties Kahan [:illcond, :inverse, :rectangular, :triangular]
 
 # properties
 size(A::Kahan) = (A.m, A.n)

src/matrices/kms.jl

@@ -32,7 +32,7 @@ KMS{T}(n::Integer) where {T<:Number} = KMS{T}(n, T(0.5))
 KMS{T}(n::Integer, rho::Number) where {T<:Number} = KMS{T}(n, convert(T, rho))
 
 # metadata
-@properties KMS [:symmetric, :inverse, :posdef, :toeplitz]
+@properties KMS [:inverse, :posdef, :toeplitz]
 
 # properties
 size(A::KMS) = (A.n, A.n)

src/matrices/lauchli.jl

@@ -29,7 +29,7 @@ Lauchli(n::Integer, mu::T) where {T<:Number} = Lauchli{T}(n, mu)
 Lauchli{T}(n::Integer) where {T<:Number} = Lauchli{T}(n, sqrt(eps(T)))
 
 # metadata
-@properties Lauchli Symbol[:rectangular]
+@properties Lauchli [:rectangular]
 
 # properties
 size(A::Lauchli) = (A.m, A.n)

src/matrices/lehmer.jl

@@ -32,7 +32,7 @@ Lehmer(n::Integer) = Lehmer{Int}(n)
 Lehmer{T}(n::Integer) where {T<:Integer} = Lehmer{Rational{T}}(n)
 
 # metadata
-@properties Lehmer [:symmetric, :inverse, :posdef, :totnonneg, :infdiv]
+@properties Lehmer [:infdiv, :inverse, :posdef, :totnonneg]
 
 # properties
 size(A::Lehmer) = (A.n, A.n)

src/matrices/leslie.jl

@@ -24,7 +24,7 @@ Leslie(n::Integer) = Leslie{Int}(n)
 Leslie{T}(n::Integer) where {T<:Number} = Leslie(ones(T, n), ones(T, n - 1))
 
 # metadata
-@properties Leslie Symbol[:nonneg, :binary]
+@properties Leslie [:binary, :nonneg]
 
 # properties
 size(A::Leslie) = (A.n, A.n)

src/matrices/lesp.jl

@@ -19,7 +19,7 @@ end
 Lesp(n::Integer) = Lesp{Float64}(n)
 
 # metadata
-@properties Lesp Symbol[:tridiagonal, :eigen]
+@properties Lesp [:eigen, :tridiagonal]
 
 # properties
 size(A::Lesp) = (A.n, A.n)

src/matrices/lotkin.jl

@@ -27,7 +27,7 @@ Lotkin(n::Integer) = Lotkin{Int}(n)
 Lotkin{T}(n::Integer) where {T<:Integer} = Lotkin{Rational{T}}(n)
 
 # metadata
-@properties Lotkin [:inverse, :illcond, :eigen]
+@properties Lotkin [:eigen, :illcond, :inverse]
 
 # properties
 size(A::Lotkin) = (A.n, A.n)

src/matrices/minij.jl

@@ -26,7 +26,7 @@ end
 Minij(n::Integer) = Minij{Int}(n)
 
 # metadata
-@properties Minij [:symmetric, :inverse, :posdef, :infdiv, :eigen, :integer, :positive]
+@properties Minij [:eigen, :infdiv, :integer, :inverse, :posdef]
 
 # properties
 size(A::Minij) = (A.n, A.n)

src/matrices/moler.jl

@@ -34,7 +34,7 @@ Moler{T}(n::Integer) where {T<:Number} = Moler{T}(n, -1)
 Moler{T}(n::Integer, alpha::Number) where {T<:Number} = Moler{T}(n, convert(T, alpha))
 
 # metadata
-@properties Moler [:symmetric, :inverse, :illcond, :posdef, :integer]
+@properties Moler [:illcond, :integer, :inverse, :posdef]
 
 # properties
 size(A::Moler) = (A.n, A.n)

src/matrices/neumann.jl

@@ -45,7 +45,7 @@ end
 Neumann(n::Integer) = Neumann{Int}(n)
 
 # metadata
-@properties Neumann [:eigen, :sparse, :rankdef, :diagdom]
+@properties Neumann [:diagdom, :eigen, :sparse, :rankdef]
 
 # properties
 size(A::Neumann) = (A.n, A.n)

src/matrices/orthog.jl

@@ -37,7 +37,7 @@ Orthog(n::Integer, k::Integer) = Orthog{Float64}(n, k)
 Orthog{T}(n::Integer) where {T<:Number} = Orthog{T}(n, 1)
 
 # metadata
-@properties Orthog Symbol[:orthogonal]
+@properties Orthog [:orthogonal]
 
 # properties
 size(A::Orthog) = (A.n, A.n)

src/matrices/oscillate.jl

@@ -54,7 +54,7 @@ function Oscillate{T}(n::Integer, mode::Integer) where {T<:Number}
 end
 
 # metadata
-@properties Oscillate [:illcond, :eigen, :random]
+@properties Oscillate [:eigen, :illcond, :random]
 
 # properties
 size(A::Oscillate) = (A.n, A.n)

src/matrices/parter.jl

@@ -28,7 +28,7 @@ Parter(n::Integer) = Parter{Int}(n)
 Parter{T}(n::Integer) where {T<:Integer} = Parter{Rational{T}}(n)
 
 # metadata
-@properties Parter [:toeplitz, :eigen]
+@properties Parter [:eigen, :toeplitz]
 
 # properties
 size(A::Parter) = (A.n, A.n)

src/matrices/pascal.jl

@@ -29,7 +29,7 @@ end
 Pascal(n::Integer) = Pascal{Int}(n)
 
 # metadata
-@properties Pascal [:symmetric, :inverse, :illcond, :posdef, :eigen, :integer, :totpos]
+@properties Pascal [:eigen, :illcond, :integer, :inverse, :posdef, :totpos]
 
 # properties
 size(A::Pascal) = (A.n, A.n)

src/matrices/pei.jl

@@ -28,7 +28,7 @@ Pei(n::Integer, alpha::T) where {T<:Number} = Pei{T}(n, alpha)
 Pei{T}(n::Integer) where {T<:Number} = Pei{T}(n, one(T))
 
 # metadata
-@properties Pei [:symmetric, :inverse, :posdef, :integer, :positive]
+@properties Pei [:integer, :inverse, :posdef, :positive]
 
 # properties
 size(A::Pei) = (A.n, A.n)

src/matrices/poisson.jl

@@ -38,7 +38,7 @@ end
 Poisson(n::Integer) = Poisson{Int}(n)
 
 # metadata
-@properties Poisson [:symmetric, :inverse, :posdef, :eigen, :sparse]
+@properties Poisson [:eigen, :inverse, :posdef, :sparse]
 
 # properties
 size(A::Poisson) = (A.n, A.n)

src/matrices/prolate.jl

@@ -34,7 +34,7 @@ Prolate(n::Integer, w::T) where {T<:Number} = Prolate{T}(n, w)
 Prolate{T}(n::Integer) where {T<:Number} = Prolate{T}(n, T(0.25))
 
 # metadata
-@properties Prolate [:symmetric, :posdef, :toeplitz, :illcond]
+@properties Prolate [:illcond, :posdef, :toeplitz]
 
 # properties
 size(A::Prolate) = (A.n, A.n)

src/matrices/randcorr.jl

@@ -59,7 +59,7 @@ end
 Randcorr(n::Integer) = Randcorr{Float64}(n)
 
 # metadata
-@properties Randcorr [:symmetric, :random, :correlation]
+@properties Randcorr [:correlation, :random]
 
 # properties
 size(A::Randcorr) = (A.n, A.n)

src/matrices/rando.jl

@@ -41,7 +41,7 @@ Rando{T}(n::Integer) where {T<:Number} = Rando{T}(n, 1)
 Rando{T}(n::Integer, k::Integer) where {T<:Number} = Rando{T}(n, n, k)
 
 # metadata
-@properties Rando [:random, :rectangular, :integer]
+@properties Rando [:integer, :random, :rectangular]
 
 # properties
 size(A::Rando) = (A.m, A.n)

src/matrices/randsvd.jl

@@ -71,7 +71,7 @@ RandSVD{T}(n::Integer, kappa::T) where {T<:Number} = RandSVD{T}(n, kappa, 3)
 RandSVD{T}(n::Integer, kappa::T, mode::Integer) where {T<:Number} = RandSVD{T}(n, n, kappa, mode)
 
 # metadata
-@properties RandSVD [:orthogonal, :rectangular, :illcond, :random]
+@properties RandSVD [:illcond, :orthogonal, :random, :rectangular]
 
 # properties
 size(A::RandSVD) = (A.m, A.n)