Clean up redundant mul! methods

Nemocas · Sep 16, 2024 · bb26fa7 · bb26fa7
1 parent 25a581c
commit bb26fa7
Show file tree

Hide file tree

Showing 11 changed files with 6 additions and 39 deletions.
diff --git a/src/Groups.jl b/src/Groups.jl
@@ -236,6 +236,9 @@ end
 # Mutable API where modifications are recommended for performance reasons
 ################################################################################
 
+# further mutable functions in fundamental_interface.jl:
+# mul!(out::T, g::T, h::T) where {T<:GroupElem} = g * h
+
 """
     one!(g::GroupElem)
 
@@ -251,14 +254,6 @@ allowed.
 """
 inv!(out::T, g::T) where {T<:GroupElem} = inv(g)
 
-"""
-    mul!(out::T, g::T, h::T) where {GEl <: GroupElem}
-
-Return `g*h`, possibly modifying `out`. Aliasing of `g` or `h` with `out` is
-allowed.
-"""
-mul!(out::T, g::T, h::T) where {T<:GroupElem} = g * h
-
 """
     div_right!(out::T, g::T, h::T) where {GEl <: GroupElem}
 

diff --git a/src/NCRings.jl b/src/NCRings.jl
@@ -130,10 +130,6 @@ Base.:\(y::Union{Integer, Rational, AbstractFloat}, x::NCRingElem) = divexact_le
 
 Base.literal_pow(::typeof(^), x::NCRingElem, ::Val{p}) where {p} = x^p
 
-function mul!(z::T, x::T, y::T) where T <: NCRingElem
-   return x*y
-end
-
 function addmul!(z::T, x::T, y::T, c::T) where T <: NCRingElem
    c = mul!(c, x, y)
    z = addeq!(z, c)

diff --git a/src/algorithms/MPolyEvaluate.jl b/src/algorithms/MPolyEvaluate.jl
@@ -4,10 +4,6 @@
 #
 ###############################################################################
 
-function mul!(z::T, a, b)::T where T
-  return a*b
-end
-
 function pow!(z::T, a, b)::T where T
   return a^b
 end

diff --git a/src/generic/FactoredFraction.jl b/src/generic/FactoredFraction.jl
@@ -476,8 +476,9 @@ function zero!(c::FactoredFracFieldElem)
     return c
 end
 
+# needed as mul!(c::FracElem{T}, a::FracElem{T}, b::FracElem{T}) is incompatible
 function mul!(c::FactoredFracFieldElem{T}, a::FactoredFracFieldElem{T}, b::FactoredFracFieldElem{T}) where T <: RingElement
-    return a*b
+  return a*b
 end
 
 function addeq!(a::FactoredFracFieldElem{T}, b::FactoredFracFieldElem{T}) where T <: RingElement

diff --git a/src/generic/MatRing.jl b/src/generic/MatRing.jl
@@ -94,11 +94,6 @@ end
 #
 ###############################################################################
 
-function mul!(A::MatRingElem{T}, B::MatRingElem{T},
-                                C::MatRingElem{T}) where T <: NCRingElement
-   return B*C
-end
-
 function addeq!(A::MatRingElem{T}, B::MatRingElem{T}) where T <: NCRingElement
    n = degree(A)
    for i = 1:n

diff --git a/src/generic/Misc/Localization.jl b/src/generic/Misc/Localization.jl
@@ -102,8 +102,6 @@ Poly: deg(N(a/b)), rest the same
 #
 ###############################################################################
 
-mul!(c::LocalizedEuclideanRingElem, a::LocalizedEuclideanRingElem, b::LocalizedEuclideanRingElem) = a * b
-
 addeq!(a::LocalizedEuclideanRingElem, b::LocalizedEuclideanRingElem) = a + b
 
 ###############################################################################

diff --git a/src/generic/UnivPoly.jl b/src/generic/UnivPoly.jl
@@ -1012,7 +1012,7 @@ function add!(a::UnivPoly{T}, b::UnivPoly{T}, c::UnivPoly{T}) where {T <: RingEl
 end
 
 function mul!(a::UnivPoly{T}, b::UnivPoly{T}, c::UnivPoly{T}) where {T <: RingElement}
-   a.p = (b*c).p
+   a.p = mul!(a.p, b.p, c.p)
    return a
 end
 

diff --git a/src/julia/Float.jl b/src/julia/Float.jl
@@ -162,10 +162,6 @@ end
 # See #1077
 
 
-function mul!(a::T, b::T, c::T) where T <: AbstractFloat
-   return b*c
-end
-
 function addmul!(a::T, b::T, c::T, d::T) where T <: AbstractFloat
    return a + b*c
 end

diff --git a/src/julia/GF.jl b/src/julia/GF.jl
@@ -360,10 +360,6 @@ function zero!(z::GFElem{T}) where T <: Integer
    return GFElem{T}(d, R)
 end
 
-function mul!(z::GFElem{T}, x::GFElem{T}, y::GFElem{T}) where T <: Integer
-   return x*y
-end
-
 function mul!(z::GFElem{BigInt}, x::GFElem{BigInt}, y::GFElem{BigInt})
    R = parent(x)
    p = R.p::BigInt

diff --git a/src/julia/Integer.jl b/src/julia/Integer.jl
@@ -540,10 +540,6 @@ end
 # See #1077
 
 
-function mul!(a::T, b::T, c::T) where T <: Integer
-   return b*c
-end
-
 function addmul!(a::T, b::T, c::T, d::T) where T <: Integer
    return a + b*c
 end

diff --git a/src/julia/Rational.jl b/src/julia/Rational.jl
@@ -285,8 +285,6 @@ function addmul!(a::Rational{T}, b::Rational{T}, c::Rational{T}, d::Rational{T})
    return a
 end
 
-mul!(z::Rational{T}, x::Rational{T}, y::T) where T <: Integer = x * y
-
 ###############################################################################
 #
 #   Random generation