Add Type(dims) constructors for Bidiagonal, Tridiagonal, and

SymTridiagonal

For Type in Bidiagonal, Tridiagonal, SymTridiagonal, support the
following:
Type(::Dims{2})
Type(::Integer, ::Integer)
Type{T}(::Dims{2})
Type{T}(::Integer, ::Integer)

Author: martinholters

base/linalg/bidiag.jl

@@ -11,6 +11,12 @@ type Bidiagonal{T} <: AbstractMatrix{T}
         end
         new(dv, ev, isupper)
     end
+    function Bidiagonal(m::Integer, n::Integer)
+        check_array_size(m, n)
+        checksquaredims(m, n, Bidiagonal{T})
+        new(Vector{T}(n), Vector{T}(n-1))
+    end
+    Bidiagonal(dims::Dims{2}) = Bidiagonal{T}(dims...)
 end
 """
     Bidiagonal(dv, ev, isupper::Bool)
@@ -55,6 +61,17 @@ julia> ev = [7; 8; 9]
 Bidiagonal{T}(dv::AbstractVector{T}, ev::AbstractVector{T}, isupper::Bool) = Bidiagonal{T}(collect(dv), collect(ev), isupper)
 Bidiagonal(dv::AbstractVector, ev::AbstractVector) = throw(ArgumentError("did you want an upper or lower Bidiagonal? Try again with an additional true (upper) or false (lower) argument."))
 
+"""
+    Bidiagonal{T}(dims)
+
+Constructs a bidiagonal matrix with uninitialized diagonal and off-diagonal elements of
+type `T`. If `T` is omitted, it defaults to `Float64`. The dims may be given as two integer
+arguments or as tuple of two `Int`s, both of which have to be equal as `Bidiagonal`
+matrices are always square.
+"""
+Bidiagonal(m::Integer, n::Integer) = Bidiagonal{Float64}(m, n)
+Bidiagonal(dims::Dims{2}) = Bidiagonal(dims...)
+
 """
     Bidiagonal(dv, ev, uplo::Char)
 

base/linalg/tridiag.jl

@@ -12,6 +12,12 @@ immutable SymTridiagonal{T} <: AbstractMatrix{T}
         end
         new(dv,ev)
     end
+    function SymTridiagonal(m::Integer, n::Integer)
+        check_array_size(m, n)
+        checksquaredims(m, n, SymTridiagonal{T})
+        new(Vector{T}(n), Vector{T}(n-1))
+    end
+    SymTridiagonal(dims::Dims{2}) = SymTridiagonal{T}(dims...)
 end
 
 """
@@ -48,6 +54,17 @@ julia> SymTridiagonal(dv, ev)
 """
 SymTridiagonal{T}(dv::Vector{T}, ev::Vector{T}) = SymTridiagonal{T}(dv, ev)
 
+"""
+    SymTridiagonal{T}(dims)
+
+Constructs a symmetric tridiagonal matrix with uninitialized diagonal and
+sub/super--diagonal elements of type `T`. If `T` is omitted, it defaults to `Float64`. The
+dims may be given as two integer arguments or as tuple of two `Int`s, both of which have to
+be equal as `SymTridiagonal` matrices are always square.
+"""
+SymTridiagonal(m::Integer, n::Integer) = SymTridiagonal{Float64}(m, n)
+SymTridiagonal(dims::Dims{2}) = SymTridiagonal(dims...)
+
 function SymTridiagonal{Td,Te}(dv::AbstractVector{Td}, ev::AbstractVector{Te})
     T = promote_type(Td,Te)
     SymTridiagonal(convert(Vector{T}, dv), convert(Vector{T}, ev))
@@ -346,7 +363,27 @@ immutable Tridiagonal{T} <: AbstractMatrix{T}
     d::Vector{T}     # diagonal
     du::Vector{T}    # sup-diagonal
     du2::Vector{T}   # supsup-diagonal for pivoting
+
+    Tridiagonal(dl::Vector{T}, d::Vector{T}, du::Vector{T}, du2::Vector{T}) = new(dl, d, du, du2)
+    function Tridiagonal(m::Integer, n::Integer)
+        check_array_size(m, n)
+        checksquaredims(m, n, Tridiagonal{T})
+        new(Vector{T}(n-1), Vector{T}(n), Vector{T}(n-1), Vector{T}(n-2))
+    end
+    Tridiagonal(dims::Dims{2}) = Tridiagonal{T}(dims...)
 end
+Tridiagonal{T}(dl::Vector{T}, d::Vector{T}, du::Vector{T}, du2::Vector{T}) = Tridiagonal{T}(dl, d, du, du2)
+
+"""
+    Tridiagonal{T}(dims)
+
+Constructs a tridiagonal matrix with uninitialized diagonal and sub/super--diagonal
+elements of type `T`. If `T` is omitted, it defaults to `Float64`. The dims may be given as
+two integer arguments or as tuple of two `Int`s, both of which have to be equal as
+`Tridiagonal` matrices are always square.
+"""
+Tridiagonal(m::Integer, n::Integer) = Tridiagonal{Float64}(m, n)
+Tridiagonal(dims::Dims{2}) = Tridiagonal(dims...)
 
 """
     Tridiagonal(dl, d, du)

doc/stdlib/linalg.rst

@@ -317,6 +317,12 @@ Linear algebra functions in Julia are largely implemented by calling functions f
         ⋅  3  3  ⋅
         ⋅  ⋅  4  4
 
+.. function:: Bidiagonal{T}(dims)
+
+   .. Docstring generated from Julia source
+
+   Constructs a bidiagonal matrix with uninitialized diagonal and off-diagonal elements of type ``T``\ . If ``T`` is omitted, it defaults to ``Float64``\ . The dims may be given as two integer arguments or as tuple of two ``Int``\ s, both of which have to be equal as ``Bidiagonal`` matrices are always square.
+
 .. function:: SymTridiagonal(dv, ev)
 
    .. Docstring generated from Julia source
@@ -347,6 +353,12 @@ Linear algebra functions in Julia are largely implemented by calling functions f
         ⋅  8  3  9
         ⋅  ⋅  9  4
 
+.. function:: SymTridiagonal{T}(dims)
+
+   .. Docstring generated from Julia source
+
+   Constructs a symmetric tridiagonal matrix with uninitialized diagonal and sub/super–diagonal elements of type ``T``\ . If ``T`` is omitted, it defaults to ``Float64``\ . The dims may be given as two integer arguments or as tuple of two ``Int``\ s, both of which have to be equal as ``SymTridiagonal`` matrices are always square.
+
 .. function:: Tridiagonal(dl, d, du)
 
    .. Docstring generated from Julia source
@@ -383,6 +395,12 @@ Linear algebra functions in Julia are largely implemented by calling functions f
         ⋅  2  9  6
         ⋅  ⋅  3  0
 
+.. function:: Tridiagonal{T}(dims)
+
+   .. Docstring generated from Julia source
+
+   Constructs a tridiagonal matrix with uninitialized diagonal and sub/super–diagonal elements of type ``T``\ . If ``T`` is omitted, it defaults to ``Float64``\ . The dims may be given as two integer arguments or as tuple of two ``Int``\ s, both of which have to be equal as ``Tridiagonal`` matrices are always square.
+
 .. function:: Symmetric(A, uplo=:U)
 
    .. Docstring generated from Julia source

test/linalg/bidiag.jl

@@ -6,6 +6,17 @@ import Base.LinAlg: BlasReal, BlasFloat
 n = 10 #Size of test matrix
 srand(1)
 
+@testset "Constructors" begin
+    D = Bidiagonal((n, n))
+    @test size(D) == (n, n)
+    @test isa(D, Bidiagonal{Float64})
+    D = Bidiagonal(n, n)
+    @test size(D) == (n, n)
+    @test isa(D, Bidiagonal{Float64})
+    @test_throws DimensionMismatch Bidiagonal((n, n+1))
+    @test_throws DimensionMismatch Bidiagonal(n, n+1)
+end
+
 @testset for relty in (Int, Float32, Float64, BigFloat), elty in (relty, Complex{relty})
     if relty <: AbstractFloat
         dv = convert(Vector{elty}, randn(n))
@@ -28,6 +39,14 @@ srand(1)
         @test_throws ArgumentError Bidiagonal(dv,ev,'R')
         @test_throws DimensionMismatch Bidiagonal(dv,ones(elty,n),true)
         @test_throws ArgumentError Bidiagonal(dv,ev)
+        D = Bidiagonal{elty}((n, n))
+        @test size(D) == (n, n)
+        @test isa(D, Bidiagonal{elty})
+        D = Bidiagonal{elty}(n, n)
+        @test size(D) == (n, n)
+        @test isa(D, Bidiagonal{elty})
+        @test_throws DimensionMismatch Bidiagonal{elty}((n, n+1))
+        @test_throws DimensionMismatch Bidiagonal{elty}(n, n+1)
     end
 
     BD = Bidiagonal(dv, ev, true)

test/linalg/tridiag.jl

@@ -15,7 +15,40 @@ du = -rand(n-1)
 v = randn(n)
 B = randn(n,2)
 
+T = Tridiagonal((n, n))
+@test size(T) == (n, n)
+@test isa(T, Tridiagonal{Float64})
+T = Tridiagonal(n, n)
+@test size(T) == (n, n)
+@test isa(T, Tridiagonal{Float64})
+@test_throws DimensionMismatch Tridiagonal((n, n+1))
+@test_throws DimensionMismatch Tridiagonal(n, n+1)
+Ts = SymTridiagonal((n, n))
+@test size(Ts) == (n, n)
+@test isa(Ts, SymTridiagonal{Float64})
+Ts = SymTridiagonal(n, n)
+@test size(Ts) == (n, n)
+@test isa(Ts, SymTridiagonal{Float64})
+@test_throws DimensionMismatch SymTridiagonal((n, n+1))
+@test_throws DimensionMismatch SymTridiagonal(n, n+1)
+
 for elty in (Float32, Float64, Complex64, Complex128, Int)
+    T = Tridiagonal{elty}((n, n))
+    @test size(T) == (n, n)
+    @test isa(T, Tridiagonal{elty})
+    T = Tridiagonal{elty}(n, n)
+    @test size(T) == (n, n)
+    @test isa(T, Tridiagonal{elty})
+    @test_throws DimensionMismatch Tridiagonal{elty}((n, n+1))
+    @test_throws DimensionMismatch Tridiagonal{elty}(n, n+1)
+    Ts = SymTridiagonal{elty}((n, n))
+    @test size(Ts) == (n, n)
+    @test isa(Ts, SymTridiagonal{elty})
+    Ts = SymTridiagonal{elty}(n, n)
+    @test size(Ts) == (n, n)
+    @test isa(Ts, SymTridiagonal{elty})
+    @test_throws DimensionMismatch SymTridiagonal{elty}((n, n+1))
+    @test_throws DimensionMismatch SymTridiagonal{elty}(n, n+1)
     if elty == Int
         srand(61516384)
         d = rand(1:100, n)