Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

minor code polish, use unicode #60

Merged
merged 4 commits into from
Aug 28, 2019
Merged

minor code polish, use unicode #60

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
1f151e7
composition with boolean UniformScaling, minor code polish, use unicode
dkarrasch Aug 25, 2019
70c146e
use unicode throughout
dkarrasch Aug 27, 2019
88792be
use shorthand notation
dkarrasch Aug 28, 2019
22c29e6
follow Julia style guide
dkarrasch Aug 28, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion src/blockmap.jl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -172,7 +172,7 @@ promote_to_lmaps(n, k, dim, A) = (promote_to_lmaps_(n[k], dim, A),)
function isblocksquare(A::BlockMap)
rows = A.rows
N = length(rows)
return all(r -> r == N, rows)
return all(==(N), rows)
end

# the following rules are sufficient but not necessary
Expand Down
50 changes: 25 additions & 25 deletions src/composition.jl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,10 +2,10 @@ struct CompositeMap{T, As<:Tuple{Vararg{LinearMap}}} <: LinearMap{T}
maps::As # stored in order of application to vector
function CompositeMap{T, As}(maps::As) where {T, As}
N = length(maps)
for n = 2:N
for n in 2:N
size(maps[n], 2) == size(maps[n-1], 1) || throw(DimensionMismatch("CompositeMap"))
end
for n = 1:N
for n in 1:N
promote_type(T, eltype(maps[n])) == T || throw(InexactError())
end
new{T, As}(maps)
Expand Down Expand Up @@ -40,11 +40,11 @@ end

# scalar multiplication and division
function Base.:(*)(α::Number, A::LinearMap)
T = promote_type(eltype(α), eltype(A))
T = promote_type(typeof(α), eltype(A))
return CompositeMap{T}(tuple(A, UniformScalingMap(α, size(A, 1))))
end
function Base.:(*)(α::Number, A::CompositeMap)
T = promote_type(eltype(α), eltype(A))
T = promote_type(typeof(α), eltype(A))
Alast = last(A.maps)
if Alast isa UniformScalingMap
return CompositeMap{T}(tuple(Base.front(A.maps)..., UniformScalingMap(α * Alast.λ, size(Alast, 1))))
Expand All @@ -53,11 +53,11 @@ function Base.:(*)(α::Number, A::CompositeMap)
end
end
function Base.:(*)(A::LinearMap, α::Number)
T = promote_type(eltype(α), eltype(A))
T = promote_type(typeof(α), eltype(A))
return CompositeMap{T}(tuple(UniformScalingMap(α, size(A, 2)), A))
end
function Base.:(*)(A::CompositeMap, α::Number)
T = promote_type(eltype(α), eltype(A))
T = promote_type(typeof(α), eltype(A))
Afirst = first(A.maps)
if Afirst isa UniformScalingMap
return CompositeMap{T}(tuple(UniformScalingMap(Afirst.λ * α, size(Afirst, 1)), Base.tail(A.maps)...))
Expand All @@ -70,28 +70,28 @@ Base.:(/)(A::LinearMap, α::Number) = A * inv(α)
Base.:(-)(A::LinearMap) = -1 * A

# composition of linear maps
function Base.:(*)(A1::CompositeMap, A2::CompositeMap)
size(A1, 2) == size(A2, 1) || throw(DimensionMismatch("*"))
T = promote_type(eltype(A1), eltype(A2))
return CompositeMap{T}(tuple(A2.maps..., A1.maps...))
function Base.:(*)(A₁::CompositeMap, A₂::CompositeMap)
size(A₁, 2) == size(A₂, 1) || throw(DimensionMismatch("*"))
T = promote_type(eltype(A₁), eltype(A₂))
return CompositeMap{T}(tuple(A₂.maps..., A₁.maps...))
end
function Base.:(*)(A1::LinearMap, A2::CompositeMap)
size(A1, 2) == size(A2, 1) || throw(DimensionMismatch("*"))
T = promote_type(eltype(A1), eltype(A2))
return CompositeMap{T}(tuple(A2.maps..., A1))
function Base.:(*)(A₁::LinearMap, A₂::CompositeMap)
size(A₁, 2) == size(A₂, 1) || throw(DimensionMismatch("*"))
T = promote_type(eltype(A₁), eltype(A₂))
return CompositeMap{T}(tuple(A₂.maps..., A₁))
end
function Base.:(*)(A1::CompositeMap, A2::LinearMap)
size(A1, 2) == size(A2, 1) || throw(DimensionMismatch("*"))
T = promote_type(eltype(A1), eltype(A2))
return CompositeMap{T}(tuple(A2, A1.maps...))
function Base.:(*)(A₁::CompositeMap, A₂::LinearMap)
size(A₁, 2) == size(A₂, 1) || throw(DimensionMismatch("*"))
T = promote_type(eltype(A₁), eltype(A₂))
return CompositeMap{T}(tuple(A₂, A₁.maps...))
end
function Base.:(*)(A1::LinearMap, A2::LinearMap)
size(A1, 2) == size(A2, 1) || throw(DimensionMismatch("*"))
T = promote_type(eltype(A1),eltype(A2))
return CompositeMap{T}(tuple(A2, A1))
function Base.:(*)(A₁::LinearMap, A₂::LinearMap)
size(A₁, 2) == size(A₂, 1) || throw(DimensionMismatch("*"))
T = promote_type(eltype(A₁), eltype(A₂))
return CompositeMap{T}(tuple(A₂, A₁))
end
Base.:(*)(A1::LinearMap, A2::UniformScaling{T}) where {T} = A1 * A2[1,1]
Base.:(*)(A1::UniformScaling{T}, A2::LinearMap) where {T} = A1[1,1] * A2
Base.:(*)(A₁::LinearMap, A₂::UniformScaling) = A₁ * A₂.λ
Base.:(*)(A₁::UniformScaling, A₂::LinearMap) = A₁.λ * A₂

# special transposition behavior
LinearAlgebra.transpose(A::CompositeMap{T}) where {T} = CompositeMap{T}(map(transpose, reverse(A.maps)))
Expand All @@ -114,7 +114,7 @@ function A_mul_B!(y::AbstractVector, A::CompositeMap, x::AbstractVector)
if N>2
dest = Array{T}(undef, size(A.maps[2], 1))
end
for n=2:N-1
for n in 2:N-1
try
resize!(dest, size(A.maps[n], 1))
catch err
Expand Down
32 changes: 16 additions & 16 deletions src/linearcombination.jl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,7 +3,7 @@ struct LinearCombination{T, As<:Tuple{Vararg{LinearMap}}} <: LinearMap{T}
function LinearCombination{T, As}(maps::As) where {T, As}
N = length(maps)
sz = size(maps[1])
for n = 1:N
for n in 1:N
size(maps[n]) == sz || throw(DimensionMismatch("LinearCombination"))
promote_type(T, eltype(maps[n])) == T || throw(InexactError())
end
Expand All @@ -20,23 +20,23 @@ LinearAlgebra.ishermitian(A::LinearCombination) = all(ishermitian, A.maps) # suf
LinearAlgebra.isposdef(A::LinearCombination) = all(isposdef, A.maps) # sufficient but not necessary

# adding linear maps
function Base.:(+)(A1::LinearCombination, A2::LinearCombination)
size(A1) == size(A2) || throw(DimensionMismatch("+"))
T = promote_type(eltype(A1), eltype(A2))
return LinearCombination{T}(tuple(A1.maps..., A2.maps...))
function Base.:(+)(A₁::LinearCombination, A₂::LinearCombination)
size(A₁) == size(A₂) || throw(DimensionMismatch("+"))
T = promote_type(eltype(A₁), eltype(A₂))
return LinearCombination{T}(tuple(A₁.maps..., A₂.maps...))
end
function Base.:(+)(A1::LinearMap, A2::LinearCombination)
size(A1) == size(A2) || throw(DimensionMismatch("+"))
T = promote_type(eltype(A1), eltype(A2))
return LinearCombination{T}(tuple(A1, A2.maps...))
function Base.:(+)(A₁::LinearMap, A₂::LinearCombination)
size(A₁) == size(A₂) || throw(DimensionMismatch("+"))
T = promote_type(eltype(A₁), eltype(A₂))
return LinearCombination{T}(tuple(A₁, A₂.maps...))
end
Base.:(+)(A1::LinearCombination, A2::LinearMap) = +(A2, A1)
function Base.:(+)(A1::LinearMap, A2::LinearMap)
size(A1)==size(A2) || throw(DimensionMismatch("+"))
T = promote_type(eltype(A1), eltype(A2))
return LinearCombination{T}(tuple(A1, A2))
Base.:(+)(A₁::LinearCombination, A₂::LinearMap) = +(A₂, A₁)
function Base.:(+)(A₁::LinearMap, A₂::LinearMap)
size(A₁) == size(A₂) || throw(DimensionMismatch("+"))
T = promote_type(eltype(A₁), eltype(A₂))
return LinearCombination{T}(tuple(A₁, A₂))
end
Base.:(-)(A1::LinearMap, A2::LinearMap) = +(A1, -A2)
Base.:(-)(A₁::LinearMap, A₂::LinearMap) = +(A₁, -A₂)

# comparison of LinearCombination objects, sufficient but not necessary
Base.:(==)(A::LinearCombination, B::LinearCombination) = (eltype(A) == eltype(B) && A.maps == B.maps)
Expand All @@ -52,7 +52,7 @@ function A_mul_B!(y::AbstractVector, A::LinearCombination, x::AbstractVector)
l = length(A.maps)
if l>1
z = similar(y)
for n=2:l
for n in 2:l
A_mul_B!(z, A.maps[n], x)
y .+= z
end
Expand Down
8 changes: 4 additions & 4 deletions src/uniformscalingmap.jl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -70,7 +70,7 @@ function LinearAlgebra.mul!(y::AbstractVector, J::UniformScalingMap{T}, x::Abstr
end

# combine LinearMap and UniformScaling objects in linear combinations
Base.:(+)(A1::LinearMap, A2::UniformScaling) = A1 + UniformScalingMap(A2.λ, size(A1, 1))
Base.:(+)(A1::UniformScaling, A2::LinearMap) = UniformScalingMap(A1.λ, size(A2, 1)) + A2
Base.:(-)(A1::LinearMap, A2::UniformScaling) = A1 - UniformScalingMap(A2.λ, size(A1, 1))
Base.:(-)(A1::UniformScaling, A2::LinearMap) = UniformScalingMap(A1.λ, size(A2, 1)) - A2
Base.:(+)(A₁::LinearMap, A₂::UniformScaling) = A₁ + UniformScalingMap(A₂.λ, size(A₁, 1))
Base.:(+)(A₁::UniformScaling, A₂::LinearMap) = UniformScalingMap(A₁.λ, size(A₂, 1)) + A₂
Base.:(-)(A₁::LinearMap, A₂::UniformScaling) = A₁ - UniformScalingMap(A₂.λ, size(A₁, 1))
Base.:(-)(A₁::UniformScaling, A₂::LinearMap) = UniformScalingMap(A₁.λ, size(A₂, 1)) - A₂
12 changes: 6 additions & 6 deletions src/wrappedmap.jl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -34,10 +34,10 @@ Ac_mul_B!(y::AbstractVector, A::WrappedMap, x::AbstractVector) =
ishermitian(A) ? A_mul_B!(y, A.lmap, x) : Ac_mul_B!(y, A.lmap, x)

# combine LinearMap and Matrix objects: linear combinations and map composition
Base.:(+)(A1::LinearMap, A2::AbstractMatrix) = +(A1, WrappedMap(A2))
Base.:(+)(A1::AbstractMatrix, A2::LinearMap) = +(WrappedMap(A1), A2)
Base.:(-)(A1::LinearMap, A2::AbstractMatrix) = -(A1, WrappedMap(A2))
Base.:(-)(A1::AbstractMatrix, A2::LinearMap) = -(WrappedMap(A1), A2)
Base.:(+)(A₁::LinearMap, A₂::AbstractMatrix) = +(A₁, WrappedMap(A₂))
Base.:(+)(A₁::AbstractMatrix, A₂::LinearMap) = +(WrappedMap(A₁), A₂)
Base.:(-)(A₁::LinearMap, A₂::AbstractMatrix) = -(A₁, WrappedMap(A₂))
Base.:(-)(A₁::AbstractMatrix, A₂::LinearMap) = -(WrappedMap(A₁), A₂)

Base.:(*)(A1::LinearMap, A2::AbstractMatrix) = *(A1, WrappedMap(A2))
Base.:(*)(A1::AbstractMatrix, A2::LinearMap) = *(WrappedMap(A1), A2)
Base.:(*)(A₁::LinearMap, A₂::AbstractMatrix) = *(A₁, WrappedMap(A₂))
Base.:(*)(A₁::AbstractMatrix, A₂::LinearMap) = *(WrappedMap(A₁), A₂)