strict types

Author: CarloLucibello

src/fillalgebra.jl

@@ -1,5 +1,10 @@
 const FillVector{F,A} = Fill{F,1,A}
 const FillMatrix{F,A} = Fill{F,2,A}
+const OnesVector{F,A} = Ones{F,1,A}
+const OnesMatrix{F,A} = Ones{F,2,A}
+const ZerosVector{F,A} = Zeros{F,1,A}
+const ZerosMatrix{F,A} = Zeros{F,2,A}
+
 
 ## vec
 vec(a::Ones{T}) where T = Ones{T}(length(a))
@@ -17,6 +22,13 @@ adjoint(a::Zeros{T,2}) where T = Zeros{T}(reverse(a.axes))
 transpose(a::Fill{T,2}) where T = Fill{T}(transpose(a.value), reverse(a.axes))
 adjoint(a::Fill{T,2}) where T = Fill{T}(adjoint(a.value), reverse(a.axes))
 
+fillsimilar(a::Ones{T}, axes) where T = Ones{T}(axes)
+fillsimilar(a::Zeros{T}, axes) where T = Zeros{T}(axes)
+fillsimilar(a::AbstractFill, axes) = Fill(getindex_value(a), axes)
+fillsimilar(a::Ones, ::Type{T}, axes) where T = Ones{T}(axes)
+fillsimilar(a::Zeros, ::Type{T}, axes) where T = Zeros{T}(axes)
+fillsimilar(a::AbstractFill, ::Type{T}, axes) where T = Fill{T}(getindex_value(a), axes)
+
 permutedims(a::AbstractFill{<:Any,1}) = fillsimilar(a, (1, length(a)))
 permutedims(a::AbstractFill{<:Any,2}) = fillsimilar(a, reverse(a.axes))
 
@@ -34,20 +46,25 @@ end
 function mult_fill(a::AbstractFill, b::AbstractFill{<:Any,2})
     axes(a, 2) ≠ axes(b, 1) &&
         throw(DimensionMismatch("Incompatible matrix multiplication dimensions"))
-    return Fill(getindex_value(a)*getindex_value(b)*size(a,2), (axes(a, 1), axes(b, 2)))
+    return Fill(getindex_value(a)*getindex_value(b), (axes(a, 1), axes(b, 2)))
 end
 
 function mult_fill(a::AbstractFill, b::AbstractFill{<:Any,1})
     axes(a, 2) ≠ axes(b, 1) &&
         throw(DimensionMismatch("Incompatible matrix multiplication dimensions"))
-    return Fill(getindex_value(a)*getindex_value(b)*size(a,2), (axes(a, 1),))
+    return Fill(getindex_value(a)*getindex_value(b), (axes(a, 1),))
 end
 
-function mult_ones(a::AbstractVector, b::AbstractMatrix)
+function mult_ones(a, b::AbstractMatrix)
     axes(a, 2) ≠ axes(b, 1) &&
         throw(DimensionMismatch("Incompatible matrix multiplication dimensions"))
     return Ones{promote_type(eltype(a), eltype(b))}((axes(a, 1), axes(b, 2)))
 end
+function mult_ones(a, b::AbstractVector)
+    axes(a, 2) ≠ axes(b, 1) &&
+        throw(DimensionMismatch("Incompatible matrix multiplication dimensions"))
+    return Ones{promote_type(eltype(a), eltype(b))}((axes(a, 1),))
+end
 
 function mult_zeros(a, b::AbstractMatrix)
     axes(a, 2) ≠ axes(b, 1) &&
@@ -65,6 +82,8 @@ end
 *(a::AbstractFill{<:Any,2}, b::AbstractFill{<:Any,1}) = mult_fill(a,b)
 
 *(a::Ones{<:Any,1}, b::Ones{<:Any,2}) = mult_ones(a, b)
+*(a::Ones{<:Any,2}, b::Ones{<:Any,2}) = mult_ones(a, b)
+*(a::Ones{<:Any,2}, b::Ones{<:Any,1}) = mult_ones(a, b)
 
 *(a::Zeros{<:Any,1}, b::Zeros{<:Any,2}) = mult_zeros(a, b)
 *(a::Zeros{<:Any,2}, b::Zeros{<:Any,2}) = mult_zeros(a, b)
@@ -89,14 +108,6 @@ end
 *(a::Zeros{<:Any,2}, b::Diagonal) = mult_zeros(a, b)
 *(a::Diagonal, b::Zeros{<:Any,1}) = mult_zeros(a, b)
 *(a::Diagonal, b::Zeros{<:Any,2}) = mult_zeros(a, b)
-function *(a::Diagonal, b::AbstractFill{<:Any,2}) 
-    size(a,2) == size(b,1) || throw(DimensionMismatch("A has dimensions $(size(a)) but B has dimensions $(size(b))"))
-    a.diag .* b # use special broadcast
-end
-function *(a::AbstractFill{<:Any,2}, b::Diagonal) 
-    size(a,2) == size(b,1) || throw(DimensionMismatch("A has dimensions $(size(a)) but B has dimensions $(size(b))"))
-    a .* permutedims(b.diag) # use special broadcast
-end
 
 *(a::Adjoint{T, <:StridedMatrix{T}},   b::Fill{T, 1}) where T = reshape(sum(conj.(parent(a)); dims=1) .* b.value, size(parent(a), 2))
 *(a::Transpose{T, <:StridedMatrix{T}}, b::Fill{T, 1}) where T = reshape(sum(parent(a); dims=1) .* b.value, size(parent(a), 2))
@@ -116,30 +127,29 @@ function *(f::FillMatrix, x::AbstractMatrix)
     repeat(sum(x, dims=1) * f.value, m, 1) 
 end
 
-function *(x::AbstractMatrix, f::Ones)
+function *(x::AbstractMatrix, f::OnesMatrix)
     axes(x, 2) ≠ axes(f, 1) &&
         throw(DimensionMismatch("Incompatible matrix multiplication dimensions"))
     m = size(f, 2)
     repeat(sum(x, dims=2) * one(eltype(f)), 1, m) 
 end
 
-function *(f::Ones, x::AbstractMatrix)
+function *(f::OnesMatrix, x::AbstractMatrix)
     axes(f, 2) ≠ axes(x, 1) &&
         throw(DimensionMismatch("Incompatible matrix multiplication dimensions"))
     m = size(f, 1)
     repeat(sum(x, dims=1) * one(eltype(f)), m, 1) 
 end
 
-function _adjvec_mul_zeros(a::Adjoint{T}, b::Zeros{S, 1}) where {T, S}
+
+
+function *(a::Adjoint{T, <:AbstractVector{T}}, b::Zeros{S, 1}) where {T, S}
     la, lb = length(a), length(b)
     if la ≠ lb
         throw(DimensionMismatch("dot product arguments have lengths $la and $lb"))
     end
-    return zero(Base.promote_op(*, T, S))
+    return zero(promote_type(T, S))
 end
-
-*(a::AdjointAbsVec, b::Zeros{<:Any, 1}) = _adjvec_mul_zeros(a, b)
-*(a::AdjointAbsVec{<:Number}, b::Zeros{<:Number, 1}) = _adjvec_mul_zeros(a, b)
 *(a::Adjoint{T, <:AbstractMatrix{T}} where T, b::Zeros{<:Any, 1}) = mult_zeros(a, b)
 
 function *(a::Transpose{T, <:AbstractVector{T}}, b::Zeros{T, 1}) where T<:Real
@@ -161,7 +171,6 @@ function +(a::Zeros{T}, b::Zeros{V}) where {T, V}
     return Zeros{promote_type(T,V)}(size(a)...)
 end
 -(a::Zeros, b::Zeros) = -(a + b)
--(a::Ones, b::Ones) = Zeros(a)+Zeros(b)
 
 # Zeros +/- Fill and Fill +/- Zeros
 function +(a::AbstractFill{T}, b::Zeros{V}) where {T, V}
@@ -241,14 +250,8 @@ end
 
 function rmul!(z::AbstractFill, x::Number)
     λ = getindex_value(z)
-    # Following check ensures consistency w/ lmul!(x, Array(z))
+	# Following check ensures consistency w/ lmul!(x, Array(z))
     # for, e.g., lmul!(NaN, z)
     λ*x == λ || throw(ArgumentError("Cannot scale by $x"))
     z
-end
-
-fillzero(::Type{Fill{T,N,AXIS}}, n, m) where {T,N,AXIS} = Fill{T,N,AXIS}(zero(T), (n, m))
-fillzero(::Type{Zeros{T,N,AXIS}}, n, m) where {T,N,AXIS} = Zeros{T,N,AXIS}((n, m))
-fillzero(::Type{F}, n, m) where F = throw(ArgumentError("Cannot create a zero array of type $F"))
-
-diagzero(D::Diagonal{F}, i, j) where F<:AbstractFill = fillzero(F, axes(D.diag[i], 1), axes(D.diag[j], 2))
+end