Remove Re-export

Author: albertomercurio

src/QuantumToolbox.jl

@@ -5,10 +5,10 @@ module QuantumToolbox
 #   2. basic functions in LinearAlgebra and SparseArrays
 #   3. some functions in SciMLOperators
 import Reexport: @reexport
-@reexport import StaticArraysCore: SVector
-@reexport using LinearAlgebra
-@reexport using SparseArrays
-@reexport import SciMLOperators: cache_operator, iscached, isconstant
+import StaticArraysCore: SVector
+using LinearAlgebra
+using SparseArrays
+import SciMLOperators: cache_operator, iscached, isconstant
 
 # other functions in LinearAlgebra
 import LinearAlgebra: BlasReal, BlasInt, BlasFloat, BlasComplex, checksquare

src/qobj/arithmetic_and_attributes.jl

@@ -36,16 +36,16 @@ end
 
 for op in (:(+), :(-), :(*))
     @eval begin
-        function LinearAlgebra.$op(A::AbstractQuantumObject, B::AbstractQuantumObject)
+        function Base.$op(A::AbstractQuantumObject, B::AbstractQuantumObject)
             check_dimensions(A, B)
             QType = promote_op_type(A, B)
             return QType($(op)(A.data, B.data), A.type, A.dimensions)
         end
-        LinearAlgebra.$op(A::AbstractQuantumObject) = get_typename_wrapper(A)($(op)(A.data), A.type, A.dimensions)
+        Base.$op(A::AbstractQuantumObject) = get_typename_wrapper(A)($(op)(A.data), A.type, A.dimensions)
 
-        LinearAlgebra.$op(n::T, A::AbstractQuantumObject) where {T<:Number} =
+        Base.$op(n::T, A::AbstractQuantumObject) where {T<:Number} =
             get_typename_wrapper(A)($(op)(n * I, A.data), A.type, A.dimensions)
-        LinearAlgebra.$op(A::AbstractQuantumObject, n::T) where {T<:Number} =
+        Base.$op(A::AbstractQuantumObject, n::T) where {T<:Number} =
             get_typename_wrapper(A)($(op)(A.data, n * I), A.type, A.dimensions)
     end
 end
@@ -63,7 +63,7 @@ for ADimType in (:Dimensions, :GeneralDimensions)
     for BDimType in (:Dimensions, :GeneralDimensions)
         if ADimType == BDimType == :Dimensions
             @eval begin
-                function LinearAlgebra.:(*)(
+                function Base.:(*)(
                     A::AbstractQuantumObject{OperatorQuantumObject,<:$ADimType},
                     B::AbstractQuantumObject{OperatorQuantumObject,<:$BDimType},
                 )
@@ -74,7 +74,7 @@ for ADimType in (:Dimensions, :GeneralDimensions)
             end
         else
             @eval begin
-                function LinearAlgebra.:(*)(
+                function Base.:(*)(
                     A::AbstractQuantumObject{OperatorQuantumObject,<:$ADimType},
                     B::AbstractQuantumObject{OperatorQuantumObject,<:$BDimType},
                 )
@@ -91,56 +91,56 @@ for ADimType in (:Dimensions, :GeneralDimensions)
     end
 end
 
-function LinearAlgebra.:(*)(
+function Base.:(*)(
     A::AbstractQuantumObject{OperatorQuantumObject},
     B::QuantumObject{KetQuantumObject,<:Dimensions},
 )
     check_mul_dimensions(get_dimensions_from(A), get_dimensions_to(B))
     return QuantumObject(A.data * B.data, Ket, Dimensions(get_dimensions_to(A)))
 end
-function LinearAlgebra.:(*)(
+function Base.:(*)(
     A::QuantumObject{BraQuantumObject,<:Dimensions},
     B::AbstractQuantumObject{OperatorQuantumObject},
 )
     check_mul_dimensions(get_dimensions_from(A), get_dimensions_to(B))
     return QuantumObject(A.data * B.data, Bra, Dimensions(get_dimensions_from(B)))
 end
-function LinearAlgebra.:(*)(A::QuantumObject{KetQuantumObject}, B::QuantumObject{BraQuantumObject})
+function Base.:(*)(A::QuantumObject{KetQuantumObject}, B::QuantumObject{BraQuantumObject})
     check_dimensions(A, B)
     return QuantumObject(A.data * B.data, Operator, A.dimensions) # to align with QuTiP, don't use kron(A, B) to do it.
 end
-function LinearAlgebra.:(*)(A::QuantumObject{BraQuantumObject}, B::QuantumObject{KetQuantumObject})
+function Base.:(*)(A::QuantumObject{BraQuantumObject}, B::QuantumObject{KetQuantumObject})
     check_dimensions(A, B)
     return A.data * B.data
 end
-function LinearAlgebra.:(*)(
+function Base.:(*)(
     A::AbstractQuantumObject{SuperOperatorQuantumObject},
     B::QuantumObject{OperatorQuantumObject},
 )
     check_dimensions(A, B)
     return QuantumObject(vec2mat(A.data * mat2vec(B.data)), Operator, A.dimensions)
 end
-function LinearAlgebra.:(*)(A::QuantumObject{OperatorBraQuantumObject}, B::QuantumObject{OperatorKetQuantumObject})
+function Base.:(*)(A::QuantumObject{OperatorBraQuantumObject}, B::QuantumObject{OperatorKetQuantumObject})
     check_dimensions(A, B)
     return A.data * B.data
 end
-function LinearAlgebra.:(*)(
+function Base.:(*)(
     A::AbstractQuantumObject{SuperOperatorQuantumObject},
     B::QuantumObject{OperatorKetQuantumObject},
 )
     check_dimensions(A, B)
     return QuantumObject(A.data * B.data, OperatorKet, A.dimensions)
 end
-function LinearAlgebra.:(*)(
+function Base.:(*)(
     A::QuantumObject{OperatorBraQuantumObject},
     B::AbstractQuantumObject{SuperOperatorQuantumObject},
 )
     check_dimensions(A, B)
     return QuantumObject(A.data * B.data, OperatorBra, A.dimensions)
 end
 
-LinearAlgebra.:(^)(A::QuantumObject, n::T) where {T<:Number} = QuantumObject(^(A.data, n), A.type, A.dimensions)
-LinearAlgebra.:(/)(A::AbstractQuantumObject, n::T) where {T<:Number} =
+Base.:(^)(A::QuantumObject, n::T) where {T<:Number} = QuantumObject(^(A.data, n), A.type, A.dimensions)
+Base.:(/)(A::AbstractQuantumObject, n::T) where {T<:Number} =
     get_typename_wrapper(A)(A.data / n, A.type, A.dimensions)
 
 @doc raw"""
@@ -221,7 +221,7 @@ Base.conj(A::AbstractQuantumObject) = get_typename_wrapper(A)(conj(A.data), A.ty
 
 Lazy matrix transpose of the [`AbstractQuantumObject`](@ref).
 """
-LinearAlgebra.transpose(
+Base.transpose(
     A::AbstractQuantumObject{OpType},
 ) where {OpType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject}} =
     get_typename_wrapper(A)(transpose(A.data), A.type, transpose(A.dimensions))
@@ -236,15 +236,15 @@ Lazy adjoint (conjugate transposition) of the [`AbstractQuantumObject`](@ref)
 !!! note
     `A'` and `dag(A)` are synonyms of `adjoint(A)`.
 """
-LinearAlgebra.adjoint(
+Base.adjoint(
     A::AbstractQuantumObject{OpType},
 ) where {OpType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject}} =
     get_typename_wrapper(A)(adjoint(A.data), A.type, adjoint(A.dimensions))
-LinearAlgebra.adjoint(A::QuantumObject{KetQuantumObject}) = QuantumObject(adjoint(A.data), Bra, adjoint(A.dimensions))
-LinearAlgebra.adjoint(A::QuantumObject{BraQuantumObject}) = QuantumObject(adjoint(A.data), Ket, adjoint(A.dimensions))
-LinearAlgebra.adjoint(A::QuantumObject{OperatorKetQuantumObject}) =
+Base.adjoint(A::QuantumObject{KetQuantumObject}) = QuantumObject(adjoint(A.data), Bra, adjoint(A.dimensions))
+Base.adjoint(A::QuantumObject{BraQuantumObject}) = QuantumObject(adjoint(A.data), Ket, adjoint(A.dimensions))
+Base.adjoint(A::QuantumObject{OperatorKetQuantumObject}) =
     QuantumObject(adjoint(A.data), OperatorBra, adjoint(A.dimensions))
-LinearAlgebra.adjoint(A::QuantumObject{OperatorBraQuantumObject}) =
+Base.adjoint(A::QuantumObject{OperatorBraQuantumObject}) =
     QuantumObject(adjoint(A.data), OperatorKet, adjoint(A.dimensions))
 
 @doc raw"""
@@ -415,7 +415,7 @@ Matrix square root of [`QuantumObject`](@ref)
 !!! note
     `√(A)` (where `√` can be typed by tab-completing `\sqrt` in the REPL) is a synonym of `sqrt(A)`.
 """
-LinearAlgebra.sqrt(A::QuantumObject) = QuantumObject(sqrt(to_dense(A.data)), A.type, A.dimensions)
+Base.sqrt(A::QuantumObject) = QuantumObject(sqrt(to_dense(A.data)), A.type, A.dimensions)
 
 @doc raw"""
     log(A::QuantumObject)
@@ -424,7 +424,7 @@ Matrix logarithm of [`QuantumObject`](@ref)
 
 Note that this function only supports for [`Operator`](@ref) and [`SuperOperator`](@ref)
 """
-LinearAlgebra.log(A::QuantumObject{ObjType}) where {ObjType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject}} =
+Base.log(A::QuantumObject{ObjType}) where {ObjType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject}} =
     QuantumObject(log(to_dense(A.data)), A.type, A.dimensions)
 
 @doc raw"""
@@ -434,11 +434,11 @@ Matrix exponential of [`QuantumObject`](@ref)
 
 Note that this function only supports for [`Operator`](@ref) and [`SuperOperator`](@ref)
 """
-LinearAlgebra.exp(
+Base.exp(
     A::QuantumObject{ObjType,DimsType,<:AbstractMatrix},
 ) where {ObjType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject},DimsType} =
     QuantumObject(to_sparse(exp(A.data)), A.type, A.dimensions)
-LinearAlgebra.exp(
+Base.exp(
     A::QuantumObject{ObjType,DimsType,<:AbstractSparseMatrix},
 ) where {ObjType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject},DimsType} =
     QuantumObject(_spexp(A.data), A.type, A.dimensions)
@@ -483,7 +483,7 @@ Matrix sine of [`QuantumObject`](@ref), defined as
 
 Note that this function only supports for [`Operator`](@ref) and [`SuperOperator`](@ref)
 """
-LinearAlgebra.sin(A::QuantumObject{ObjType}) where {ObjType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject}} =
+Base.sin(A::QuantumObject{ObjType}) where {ObjType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject}} =
     (exp(1im * A) - exp(-1im * A)) / 2im
 
 @doc raw"""
@@ -495,7 +495,7 @@ Matrix cosine of [`QuantumObject`](@ref), defined as
 
 Note that this function only supports for [`Operator`](@ref) and [`SuperOperator`](@ref)
 """
-LinearAlgebra.cos(A::QuantumObject{ObjType}) where {ObjType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject}} =
+Base.cos(A::QuantumObject{ObjType}) where {ObjType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject}} =
     (exp(1im * A) + exp(-1im * A)) / 2
 
 @doc raw"""

src/qobj/dimensions.jl

@@ -91,9 +91,9 @@ _get_space_size(s::AbstractSpace)::Int = s.size
 Base.prod(dims::Dimensions) = prod(dims.to)
 Base.prod(spaces::NTuple{N,AbstractSpace}) where {N} = prod(_get_space_size, spaces)
 
-LinearAlgebra.transpose(dimensions::Dimensions) = dimensions
-LinearAlgebra.transpose(dimensions::GeneralDimensions) = GeneralDimensions(dimensions.from, dimensions.to) # switch `to` and `from`
-LinearAlgebra.adjoint(dimensions::AbstractDimensions) = transpose(dimensions)
+Base.transpose(dimensions::Dimensions) = dimensions
+Base.transpose(dimensions::GeneralDimensions) = GeneralDimensions(dimensions.from, dimensions.to) # switch `to` and `from`
+Base.adjoint(dimensions::AbstractDimensions) = transpose(dimensions)
 
 # this is used to show `dims` for Qobj and QobjEvo
 _get_dims_string(dimensions::Dimensions) = string(dimensions_to_dims(dimensions))

src/qobj/functions.jl

@@ -187,7 +187,7 @@ julia> a.dims, O.dims
 ([20], [20, 20])
 ```
 """
-function LinearAlgebra.kron(
+function Base.kron(
     A::AbstractQuantumObject{OpType,<:Dimensions},
     B::AbstractQuantumObject{OpType,<:Dimensions},
 ) where {OpType<:Union{KetQuantumObject,BraQuantumObject,OperatorQuantumObject}}
@@ -201,7 +201,7 @@ for ADimType in (:Dimensions, :GeneralDimensions)
     for BDimType in (:Dimensions, :GeneralDimensions)
         if !(ADimType == BDimType == :Dimensions) # not for this case because it's already implemented
             @eval begin
-                function LinearAlgebra.kron(
+                function Base.kron(
                     A::AbstractQuantumObject{OperatorQuantumObject,<:$ADimType},
                     B::AbstractQuantumObject{OperatorQuantumObject,<:$BDimType},
                 )
@@ -226,7 +226,7 @@ for AOpType in (:KetQuantumObject, :BraQuantumObject, :OperatorQuantumObject)
     for BOpType in (:KetQuantumObject, :BraQuantumObject, :OperatorQuantumObject)
         if (AOpType != BOpType)
             @eval begin
-                function LinearAlgebra.kron(A::AbstractQuantumObject{$AOpType}, B::AbstractQuantumObject{$BOpType})
+                function Base.kron(A::AbstractQuantumObject{$AOpType}, B::AbstractQuantumObject{$BOpType})
                     QType = promote_op_type(A, B)
                     _lazy_tensor_warning(A.data, B.data)
                     return QType(
@@ -243,8 +243,8 @@ for AOpType in (:KetQuantumObject, :BraQuantumObject, :OperatorQuantumObject)
     end
 end
 
-LinearAlgebra.kron(A::AbstractQuantumObject) = A
-function LinearAlgebra.kron(A::Vector{<:AbstractQuantumObject})
+Base.kron(A::AbstractQuantumObject) = A
+function Base.kron(A::Vector{<:AbstractQuantumObject})
     @warn "`tensor(A)` or `kron(A)` with `A` is a `Vector` can hurt performance. Try to use `tensor(A...)` or `kron(A...)` instead."
     return kron(A...)
 end