Implement multiply-add interface in LinearAlgebra

stdlib/LinearAlgebra/src/LinearAlgebra.jl

@@ -17,7 +17,7 @@ import Base: USE_BLAS64, abs, acos, acosh, acot, acoth, acsc, acsch, adjoint, as
  strides, stride, tan, tanh, transpose, trunc, typed_hcat, vec
 using Base: hvcat_fill, IndexLinear, promote_op, promote_typeof,
  @propagate_inbounds, @pure, reduce, typed_vcat, require_one_based_indexing
-using Base.Broadcast: Broadcasted
+using Base.Broadcast: Broadcasted, broadcasted
 
 export
 # Modules

stdlib/LinearAlgebra/src/bidiag.jl

@@ -338,23 +338,23 @@ end
 
 const BiTriSym = Union{Bidiagonal,Tridiagonal,SymTridiagonal}
 const BiTri = Union{Bidiagonal,Tridiagonal}
-mul!(C::AbstractMatrix, A::SymTridiagonal, B::BiTriSym) = A_mul_B_td!(C, A, B)
-mul!(C::AbstractMatrix, A::BiTriSym, B::BiTriSym) = A_mul_B_td!(C, A, B)
-mul!(C::AbstractMatrix, A::AbstractTriangular, B::BiTriSym) = A_mul_B_td!(C, A, B)
-mul!(C::AbstractMatrix, A::AbstractMatrix, B::BiTriSym) = A_mul_B_td!(C, A, B)
-mul!(C::AbstractMatrix, A::Diagonal, B::BiTriSym) = A_mul_B_td!(C, A, B)
-mul!(C::AbstractMatrix, A::Adjoint{<:Any,<:Diagonal}, B::BiTriSym) = A_mul_B_td!(C, A, B)
-mul!(C::AbstractMatrix, A::Transpose{<:Any,<:Diagonal}, B::BiTriSym) = A_mul_B_td!(C, A, B)
-mul!(C::AbstractMatrix, A::Adjoint{<:Any,<:AbstractTriangular}, B::BiTriSym) = A_mul_B_td!(C, A, B)
-mul!(C::AbstractMatrix, A::Transpose{<:Any,<:AbstractTriangular}, B::BiTriSym) = A_mul_B_td!(C, A, B)
-mul!(C::AbstractMatrix, A::Adjoint{<:Any,<:AbstractVecOrMat}, B::BiTriSym) = A_mul_B_td!(C, A, B)
-mul!(C::AbstractMatrix, A::Transpose{<:Any,<:AbstractVecOrMat}, B::BiTriSym) = A_mul_B_td!(C, A, B)
-mul!(C::AbstractVector, A::BiTriSym, B::AbstractVector) = A_mul_B_td!(C, A, B)
-mul!(C::AbstractMatrix, A::BiTriSym, B::AbstractVecOrMat) = A_mul_B_td!(C, A, B)
-mul!(C::AbstractVecOrMat, A::BiTriSym, B::AbstractVecOrMat) = A_mul_B_td!(C, A, B)
-mul!(C::AbstractMatrix, A::BiTriSym, B::Transpose{<:Any,<:AbstractVecOrMat}) = A_mul_B_td!(C, A, B) # around bidiag line 330
-mul!(C::AbstractMatrix, A::BiTriSym, B::Adjoint{<:Any,<:AbstractVecOrMat}) = A_mul_B_td!(C, A, B)
-mul!(C::AbstractVector, A::BiTriSym, B::Transpose{<:Any,<:AbstractVecOrMat}) = throw(MethodError(mul!, (C, A, B)))
+@inline mul!(C::AbstractMatrix, A::SymTridiagonal, B::BiTriSym, alpha::Number, beta::Number) = A_mul_B_td!(C, A, B, MulAddMul(alpha, beta))
+@inline mul!(C::AbstractMatrix, A::BiTriSym, B::BiTriSym, alpha::Number, beta::Number) = A_mul_B_td!(C, A, B, MulAddMul(alpha, beta))
+@inline mul!(C::AbstractMatrix, A::AbstractTriangular, B::BiTriSym, alpha::Number, beta::Number) = A_mul_B_td!(C, A, B, MulAddMul(alpha, beta))
+@inline mul!(C::AbstractMatrix, A::AbstractMatrix, B::BiTriSym, alpha::Number, beta::Number) = A_mul_B_td!(C, A, B, MulAddMul(alpha, beta))
+@inline mul!(C::AbstractMatrix, A::Diagonal, B::BiTriSym, alpha::Number, beta::Number) = A_mul_B_td!(C, A, B, MulAddMul(alpha, beta))
+@inline mul!(C::AbstractMatrix, A::Adjoint{<:Any,<:Diagonal}, B::BiTriSym, alpha::Number, beta::Number) = A_mul_B_td!(C, A, B, MulAddMul(alpha, beta))
+@inline mul!(C::AbstractMatrix, A::Transpose{<:Any,<:Diagonal}, B::BiTriSym, alpha::Number, beta::Number) = A_mul_B_td!(C, A, B, MulAddMul(alpha, beta))
+@inline mul!(C::AbstractMatrix, A::Adjoint{<:Any,<:AbstractTriangular}, B::BiTriSym, alpha::Number, beta::Number) = A_mul_B_td!(C, A, B, MulAddMul(alpha, beta))
+@inline mul!(C::AbstractMatrix, A::Transpose{<:Any,<:AbstractTriangular}, B::BiTriSym, alpha::Number, beta::Number) = A_mul_B_td!(C, A, B, MulAddMul(alpha, beta))
+@inline mul!(C::AbstractMatrix, A::Adjoint{<:Any,<:AbstractVecOrMat}, B::BiTriSym, alpha::Number, beta::Number) = A_mul_B_td!(C, A, B, MulAddMul(alpha, beta))
+@inline mul!(C::AbstractMatrix, A::Transpose{<:Any,<:AbstractVecOrMat}, B::BiTriSym, alpha::Number, beta::Number) = A_mul_B_td!(C, A, B, MulAddMul(alpha, beta))
+@inline mul!(C::AbstractVector, A::BiTriSym, B::AbstractVector, alpha::Number, beta::Number) = A_mul_B_td!(C, A, B, MulAddMul(alpha, beta))
+@inline mul!(C::AbstractMatrix, A::BiTriSym, B::AbstractVecOrMat, alpha::Number, beta::Number) = A_mul_B_td!(C, A, B, MulAddMul(alpha, beta))
+@inline mul!(C::AbstractVecOrMat, A::BiTriSym, B::AbstractVecOrMat, alpha::Number, beta::Number) = A_mul_B_td!(C, A, B, MulAddMul(alpha, beta))
+@inline mul!(C::AbstractMatrix, A::BiTriSym, B::Transpose{<:Any,<:AbstractVecOrMat}, alpha::Number, beta::Number) = A_mul_B_td!(C, A, B, MulAddMul(alpha, beta)) # around bidiag line 330
+@inline mul!(C::AbstractMatrix, A::BiTriSym, B::Adjoint{<:Any,<:AbstractVecOrMat}, alpha::Number, beta::Number) = A_mul_B_td!(C, A, B, MulAddMul(alpha, beta))
+@inline mul!(C::AbstractVector, A::BiTriSym, B::Transpose{<:Any,<:AbstractVecOrMat}, alpha::Number, beta::Number) = throw(MethodError(mul!, (C, A, B)), MulAddMul(alpha, beta))
 
 function check_A_mul_B!_sizes(C, A, B)
  require_one_based_indexing(C)
@@ -386,11 +386,15 @@ function _diag(A::Bidiagonal, k)
  end
 end
 
-function A_mul_B_td!(C::AbstractMatrix, A::BiTriSym, B::BiTriSym)
+function A_mul_B_td!(C::AbstractMatrix, A::BiTriSym, B::BiTriSym,
+ _add::MulAddMul = MulAddMul())
  check_A_mul_B!_sizes(C, A, B)
  n = size(A,1)
- n <= 3 && return mul!(C, Array(A), Array(B))
- fill!(C, zero(eltype(C)))
+ n <= 3 && return mul!(C, Array(A), Array(B), _add.alpha, _add.beta)
+ # We use `_rmul_or_fill!` instead of `_modify!` here since using
+ # `_modify!` in the following loop will not update the
+ # off-diagonal elements for non-zero beta.
+ _rmul_or_fill!(C, _add.beta)
  Al = _diag(A, -1)
  Ad = _diag(A, 0)
  Au = _diag(A, 1)
@@ -399,14 +403,14 @@ function A_mul_B_td!(C::AbstractMatrix, A::BiTriSym, B::BiTriSym)
  Bu = _diag(B, 1)
  @inbounds begin
  # first row of C
- C[1,1] = A[1,1]*B[1,1] + A[1, 2]*B[2, 1]
- C[1,2] = A[1,1]*B[1,2] + A[1,2]*B[2,2]
- C[1,3] = A[1,2]*B[2,3]
+ C[1,1] += _add(A[1,1]*B[1,1] + A[1, 2]*B[2, 1])
+ C[1,2] += _add(A[1,1]*B[1,2] + A[1,2]*B[2,2])
+ C[1,3] += _add(A[1,2]*B[2,3])
  # second row of C
- C[2,1] = A[2,1]*B[1,1] + A[2,2]*B[2,1]
- C[2,2] = A[2,1]*B[1,2] + A[2,2]*B[2,2] + A[2,3]*B[3,2]
- C[2,3] = A[2,2]*B[2,3] + A[2,3]*B[3,3]
- C[2,4] = A[2,3]*B[3,4]
+ C[2,1] += _add(A[2,1]*B[1,1] + A[2,2]*B[2,1])
+ C[2,2] += _add(A[2,1]*B[1,2] + A[2,2]*B[2,2] + A[2,3]*B[3,2])
+ C[2,3] += _add(A[2,2]*B[2,3] + A[2,3]*B[3,3])
+ C[2,4] += _add(A[2,3]*B[3,4])
  for j in 3:n-2
  Ajj₋1 = Al[j-1]
  Ajj = Ad[j]
@@ -420,26 +424,27 @@ function A_mul_B_td!(C::AbstractMatrix, A::BiTriSym, B::BiTriSym)
  Bj₊1j = Bl[j]
  Bj₊1j₊1 = Bd[j+1]
  Bj₊1j₊2 = Bu[j+1]
- C[j,j-2] = Ajj₋1*Bj₋1j₋2
- C[j, j-1] = Ajj₋1*Bj₋1j₋1 + Ajj*Bjj₋1
- C[j, j ] = Ajj₋1*Bj₋1j + Ajj*Bjj + Ajj₊1*Bj₊1j
- C[j, j+1] = Ajj *Bjj₊1 + Ajj₊1*Bj₊1j₊1
- C[j, j+2] = Ajj₊1*Bj₊1j₊2
+ C[j,j-2] += _add( Ajj₋1*Bj₋1j₋2)
+ C[j, j-1] += _add(Ajj₋1*Bj₋1j₋1 + Ajj*Bjj₋1)
+ C[j, j ] += _add(Ajj₋1*Bj₋1j + Ajj*Bjj + Ajj₊1*Bj₊1j)
+ C[j, j+1] += _add(Ajj *Bjj₊1 + Ajj₊1*Bj₊1j₊1)
+ C[j, j+2] += _add(Ajj₊1*Bj₊1j₊2)
  end
  # row before last of C
- C[n-1,n-3] = A[n-1,n-2]*B[n-2,n-3]
- C[n-1,n-2] = A[n-1,n-1]*B[n-1,n-2] + A[n-1,n-2]*B[n-2,n-2]
- C[n-1,n-1] = A[n-1,n-2]*B[n-2,n-1] + A[n-1,n-1]*B[n-1,n-1] + A[n-1,n]*B[n,n-1]
- C[n-1,n ] = A[n-1,n-1]*B[n-1,n ] + A[n-1, n]*B[n ,n ]
+ C[n-1,n-3] += _add(A[n-1,n-2]*B[n-2,n-3])
+ C[n-1,n-2] += _add(A[n-1,n-1]*B[n-1,n-2] + A[n-1,n-2]*B[n-2,n-2])
+ C[n-1,n-1] += _add(A[n-1,n-2]*B[n-2,n-1] + A[n-1,n-1]*B[n-1,n-1] + A[n-1,n]*B[n,n-1])
+ C[n-1,n ] += _add(A[n-1,n-1]*B[n-1,n ] + A[n-1, n]*B[n ,n ])
  # last row of C
- C[n,n-2] = A[n,n-1]*B[n-1,n-2]
- C[n,n-1] = A[n,n-1]*B[n-1,n-1] + A[n,n]*B[n,n-1]
- C[n,n ] = A[n,n-1]*B[n-1,n ] + A[n,n]*B[n,n ]
+ C[n,n-2] += _add(A[n,n-1]*B[n-1,n-2])
+ C[n,n-1] += _add(A[n,n-1]*B[n-1,n-1] + A[n,n]*B[n,n-1])
+ C[n,n ] += _add(A[n,n-1]*B[n-1,n ] + A[n,n]*B[n,n ])
  end # inbounds
  C
 end
 
-function A_mul_B_td!(C::AbstractMatrix, A::BiTriSym, B::Diagonal)
+function A_mul_B_td!(C::AbstractMatrix, A::BiTriSym, B::Diagonal,
+ _add::MulAddMul = MulAddMul())
  check_A_mul_B!_sizes(C, A, B)
  n = size(A,1)
  n <= 3 && return mul!(C, Array(A), Array(B))
@@ -450,29 +455,30 @@ function A_mul_B_td!(C::AbstractMatrix, A::BiTriSym, B::Diagonal)
  Bd = B.diag
  @inbounds begin
  # first row of C
- C[1,1] = A[1,1]*B[1,1]
- C[1,2] = A[1,2]*B[2,2]
+ _modify!(_add, A[1,1]*B[1,1], C, (1,1))
+ _modify!(_add, A[1,2]*B[2,2], C, (1,2))
  # second row of C
- C[2,1] = A[2,1]*B[1,1]
- C[2,2] = A[2,2]*B[2,2]
- C[2,3] = A[2,3]*B[3,3]
+ _modify!(_add, A[2,1]*B[1,1], C, (2,1))
+ _modify!(_add, A[2,2]*B[2,2], C, (2,2))
+ _modify!(_add, A[2,3]*B[3,3], C, (2,3))
  for j in 3:n-2
- C[j, j-1] = Al[j-1]*Bd[j-1]
- C[j, j ] = Ad[j ]*Bd[j ]
- C[j, j+1] = Au[j ]*Bd[j+1]
+ _modify!(_add, Al[j-1]*Bd[j-1], C, (j, j-1))
+ _modify!(_add, Ad[j ]*Bd[j ], C, (j, j ))
+ _modify!(_add, Au[j ]*Bd[j+1], C, (j, j+1))
  end
  # row before last of C
- C[n-1,n-2] = A[n-1,n-2]*B[n-2,n-2]
- C[n-1,n-1] = A[n-1,n-1]*B[n-1,n-1]
- C[n-1,n ] = A[n-1, n]*B[n ,n ]
+ _modify!(_add, A[n-1,n-2]*B[n-2,n-2], C, (n-1,n-2))
+ _modify!(_add, A[n-1,n-1]*B[n-1,n-1], C, (n-1,n-1))
+ _modify!(_add, A[n-1, n]*B[n ,n ], C, (n-1,n ))
  # last row of C
- C[n,n-1] = A[n,n-1]*B[n-1,n-1]
- C[n,n ] = A[n,n ]*B[n, n ]
+ _modify!(_add, A[n,n-1]*B[n-1,n-1], C, (n,n-1))
+ _modify!(_add, A[n,n ]*B[n, n ], C, (n,n ))
  end # inbounds
  C
 end
 
-function A_mul_B_td!(C::AbstractVecOrMat, A::BiTriSym, B::AbstractVecOrMat)
+function A_mul_B_td!(C::AbstractVecOrMat, A::BiTriSym, B::AbstractVecOrMat,
+ _add::MulAddMul = MulAddMul())
  require_one_based_indexing(C)
  require_one_based_indexing(B)
  nA = size(A,1)
@@ -483,28 +489,29 @@ function A_mul_B_td!(C::AbstractVecOrMat, A::BiTriSym, B::AbstractVecOrMat)
  if size(C,2) != nB
  throw(DimensionMismatch("A has second dimension $nA, B has $(size(B,2)), C has $(size(C,2)) but all must match"))
  end
- nA <= 3 && return mul!(C, Array(A), Array(B))
+ nA <= 3 && return mul!(C, Array(A), Array(B), _add.alpha, _add.beta)
  l = _diag(A, -1)
  d = _diag(A, 0)
  u = _diag(A, 1)
  @inbounds begin
  for j = 1:nB
  b₀, b₊ = B[1, j], B[2, j]
- C[1, j] = d[1]*b₀ + u[1]*b₊
+ _modify!(_add, d[1]*b₀ + u[1]*b₊, C, (1, j))
  for i = 2:nA - 1
  b₋, b₀, b₊ = b₀, b₊, B[i + 1, j]
- C[i, j] = l[i - 1]*b₋ + d[i]*b₀ + u[i]*b₊
+ _modify!(_add, l[i - 1]*b₋ + d[i]*b₀ + u[i]*b₊, C, (i, j))
  end
- C[nA, j] = l[nA - 1]*b₀ + d[nA]*b₊
+ _modify!(_add, l[nA - 1]*b₀ + d[nA]*b₊, C, (nA, j))
  end
  end
  C
 end
 
-function A_mul_B_td!(C::AbstractMatrix, A::AbstractMatrix, B::BiTriSym)
+function A_mul_B_td!(C::AbstractMatrix, A::AbstractMatrix, B::BiTriSym,
+ _add::MulAddMul = MulAddMul())
  check_A_mul_B!_sizes(C, A, B)
  n = size(A,1)
- n <= 3 && return mul!(C, Array(A), Array(B))
+ n <= 3 && return mul!(C, Array(A), Array(B), _add.alpha, _add.beta)
  m = size(B,2)
  Bl = _diag(B, -1)
  Bd = _diag(B, 0)
@@ -516,16 +523,16 @@ function A_mul_B_td!(C::AbstractMatrix, A::AbstractMatrix, B::BiTriSym)
  Bmm = Bd[m]
  Bm₋1m = Bu[m-1]
  for i in 1:n
- C[i, 1] = A[i,1] * B11 + A[i, 2] * B21
- C[i, m] = A[i, m-1] * Bm₋1m + A[i, m] * Bmm
+ _modify!(_add, A[i,1] * B11 + A[i, 2] * B21, C, (i, 1))
+ _modify!(_add, A[i, m-1] * Bm₋1m + A[i, m] * Bmm, C, (i, m))
  end
  # middle columns of C
  for j = 2:m-1
  Bj₋1j = Bu[j-1]
  Bjj = Bd[j]
  Bj₊1j = Bl[j]
  for i = 1:n
- C[i, j] = A[i, j-1] * Bj₋1j + A[i, j]*Bjj + A[i, j+1] * Bj₊1j
+ _modify!(_add, A[i, j-1] * Bj₋1j + A[i, j]*Bjj + A[i, j+1] * Bj₊1j, C, (i, j))
  end
  end
  end # inbounds

stdlib/LinearAlgebra/src/blas.jl

@@ -571,7 +571,9 @@ for (fname, elty) in ((:dgemv_,:Float64),
  # CHARACTER TRANS
  #* .. Array Arguments ..
  # DOUBLE PRECISION A(LDA,*),X(*),Y(*)
- function gemv!(trans::AbstractChar, alpha::($elty), A::AbstractVecOrMat{$elty}, X::AbstractVector{$elty}, beta::($elty), Y::AbstractVector{$elty})
+ function gemv!(trans::AbstractChar, alpha::Union{($elty), Bool},
+ A::AbstractVecOrMat{$elty}, X::AbstractVector{$elty},
+ beta::Union{($elty), Bool}, Y::AbstractVector{$elty})
  require_one_based_indexing(A, X, Y)
  m,n = size(A,1),size(A,2)
  if trans == 'N' && (length(X) != n || length(Y) != m)
@@ -656,7 +658,10 @@ for (fname, elty) in ((:dgbmv_,:Float64),
  # CHARACTER TRANS
  # * .. Array Arguments ..
  # DOUBLE PRECISION A(LDA,*),X(*),Y(*)
- function gbmv!(trans::AbstractChar, m::Integer, kl::Integer, ku::Integer, alpha::($elty), A::AbstractMatrix{$elty}, x::AbstractVector{$elty}, beta::($elty), y::AbstractVector{$elty})
+ function gbmv!(trans::AbstractChar, m::Integer, kl::Integer, ku::Integer,
+ alpha::Union{($elty), Bool}, A::AbstractMatrix{$elty},
+ x::AbstractVector{$elty}, beta::Union{($elty), Bool},
+ y::AbstractVector{$elty})
  require_one_based_indexing(A, x, y)
  chkstride1(A)
  ccall((@blasfunc($fname), libblas), Cvoid,
@@ -704,7 +709,9 @@ for (fname, elty, lib) in ((:dsymv_,:Float64,libblas),
  # CHARACTER UPLO
  # .. Array Arguments ..
  # DOUBLE PRECISION A(LDA,*),X(*),Y(*)
- function symv!(uplo::AbstractChar, alpha::($elty), A::AbstractMatrix{$elty}, x::AbstractVector{$elty}, beta::($elty), y::AbstractVector{$elty})
+ function symv!(uplo::AbstractChar, alpha::Union{($elty), Bool},
+ A::AbstractMatrix{$elty}, x::AbstractVector{$elty},
+ beta::Union{($elty), Bool}, y::AbstractVector{$elty})
  require_one_based_indexing(A, x, y)
  m, n = size(A)
  if m != n
@@ -756,7 +763,7 @@ symv(ul, A, x)
 for (fname, elty) in ((:zhemv_,:ComplexF64),
  (:chemv_,:ComplexF32))
  @eval begin
- function hemv!(uplo::AbstractChar, α::$elty, A::AbstractMatrix{$elty}, x::AbstractVector{$elty}, β::$elty, y::AbstractVector{$elty})
+ function hemv!(uplo::AbstractChar, α::Union{$elty, Bool}, A::AbstractMatrix{$elty}, x::AbstractVector{$elty}, β::Union{$elty, Bool}, y::AbstractVector{$elty})
  require_one_based_indexing(A, x, y)
  m, n = size(A)
  if m != n
@@ -1112,7 +1119,11 @@ for (gemm, elty) in
  # CHARACTER TRANSA,TRANSB
  # * .. Array Arguments ..
  # DOUBLE PRECISION A(LDA,*),B(LDB,*),C(LDC,*)
- function gemm!(transA::AbstractChar, transB::AbstractChar, alpha::($elty), A::AbstractVecOrMat{$elty}, B::AbstractVecOrMat{$elty}, beta::($elty), C::AbstractVecOrMat{$elty})
+ function gemm!(transA::AbstractChar, transB::AbstractChar,
+ alpha::Union{($elty), Bool},
+ A::AbstractVecOrMat{$elty}, B::AbstractVecOrMat{$elty},
+ beta::Union{($elty), Bool},
+ C::AbstractVecOrMat{$elty})
 # if any([stride(A,1), stride(B,1), stride(C,1)] .!= 1)
 # error("gemm!: BLAS module requires contiguous matrix columns")
 # end # should this be checked on every call?
@@ -1175,7 +1186,9 @@ for (mfname, elty) in ((:dsymm_,:Float64),
  # CHARACTER SIDE,UPLO
  # .. Array Arguments ..
  # DOUBLE PRECISION A(LDA,*),B(LDB,*),C(LDC,*)
- function symm!(side::AbstractChar, uplo::AbstractChar, alpha::($elty), A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty}, beta::($elty), C::AbstractMatrix{$elty})
+ function symm!(side::AbstractChar, uplo::AbstractChar, alpha::Union{($elty), Bool},
+ A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty},
+ beta::Union{($elty), Bool}, C::AbstractMatrix{$elty})
  require_one_based_indexing(A, B, C)
  m, n = size(C)
  j = checksquare(A)
@@ -1244,7 +1257,9 @@ for (mfname, elty) in ((:zhemm_,:ComplexF64),
  # CHARACTER SIDE,UPLO
  # .. Array Arguments ..
  # DOUBLE PRECISION A(LDA,*),B(LDB,*),C(LDC,*)
- function hemm!(side::AbstractChar, uplo::AbstractChar, alpha::($elty), A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty}, beta::($elty), C::AbstractMatrix{$elty})
+ function hemm!(side::AbstractChar, uplo::AbstractChar, alpha::Union{($elty), Bool},
+ A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty},
+ beta::Union{($elty), Bool}, C::AbstractMatrix{$elty})
  require_one_based_indexing(A, B, C)
  m, n = size(C)
  j = checksquare(A)
@@ -1309,8 +1324,8 @@ for (fname, elty) in ((:dsyrk_,:Float64),
  # * .. Array Arguments ..
  # REAL A(LDA,*),C(LDC,*)
  function syrk!(uplo::AbstractChar, trans::AbstractChar,
- alpha::($elty), A::AbstractVecOrMat{$elty},
- beta::($elty), C::AbstractMatrix{$elty})
+ alpha::Union{($elty), Bool}, A::AbstractVecOrMat{$elty},
+ beta::Union{($elty), Bool}, C::AbstractMatrix{$elty})
  require_one_based_indexing(A, C)
  n = checksquare(C)
  nn = size(A, trans == 'N' ? 1 : 2)
@@ -1366,8 +1381,9 @@ for (fname, elty, relty) in ((:zherk_, :ComplexF64, :Float64),
  # * ..
  # * .. Array Arguments ..
  # COMPLEX A(LDA,*),C(LDC,*)
- function herk!(uplo::AbstractChar, trans::AbstractChar, α::$relty, A::AbstractVecOrMat{$elty},
- β::$relty, C::AbstractMatrix{$elty})
+ function herk!(uplo::AbstractChar, trans::AbstractChar,
+ α::Union{$relty, Bool}, A::AbstractVecOrMat{$elty},
+ β::Union{$relty, Bool}, C::AbstractMatrix{$elty})
  require_one_based_indexing(A, C)
  n = checksquare(C)
  nn = size(A, trans == 'N' ? 1 : 2)