Strict parent checks in == methods

src/AbsSeries.jl

@@ -486,8 +486,7 @@ that power series to different precisions may still be arithmetically
 equal to the minimum of the two precisions.
 """
 function ==(x::AbsPowerSeriesRingElem{T}, y::AbsPowerSeriesRingElem{T}) where T <: RingElement
-   b = check_parent(x, y, false)
-   !b && return false
+   check_parent(x, y)
 
    prec = min(precision(x), precision(y))
    m1 = min(length(x), length(y))

src/Fraction.jl

@@ -417,8 +417,7 @@ that power series to different precisions may still be arithmetically
 equal to the minimum of the two precisions.
 """
 function ==(x::FracElem{T}, y::FracElem{T}) where {T <: RingElem}
-   b  = check_parent(x, y, false)
-   !b && return false
+   check_parent(x, y)
 
    return (denominator(x, false) == denominator(y, false) &&
            numerator(x, false) == numerator(y, false)) ||

src/Matrix.jl

@@ -1303,8 +1303,7 @@ that power series to different precisions may still be arithmetically
 equal to the minimum of the two precisions.
 """
 function ==(x::MatrixElem{T}, y::MatrixElem{T}) where {T <: NCRingElement}
-   b = check_parent(x, y, false)
-   !b && return false
+   check_parent(x, y)
    for i = 1:nrows(x)
       for j = 1:ncols(x)
          if x[i, j] != y[i, j]

src/NCPoly.jl

@@ -342,15 +342,13 @@ that power series to different precisions may still be arithmetically
 equal to the minimum of the two precisions.
 """
 function ==(x::NCPolyRingElem{T}, y::NCPolyRingElem{T}) where T <: NCRingElem
-   b = check_parent(x, y, false)
-   !b && return false
+   check_parent(x, y)
    if length(x) != length(y)
       return false
-   else
-      for i = 1:length(x)
-         if coeff(x, i - 1) != coeff(y, i - 1)
-            return false
-         end
+   end
+   for i = 1:length(x)
+      if coeff(x, i - 1) != coeff(y, i - 1)
+         return false
       end
    end
    return true

src/Poly.jl

@@ -839,15 +839,14 @@ that power series to different precisions may still be arithmetically
 equal to the minimum of the two precisions.
 """
 function ==(x::PolyRingElem{T}, y::PolyRingElem{T}) where T <: RingElement
-   b = check_parent(x, y, false)
-   !b && return false
+   check_parent(x, y)
+
    if length(x) != length(y)
       return false
-   else
-      for i = 1:length(x)
-         if coeff(x, i - 1) != coeff(y, i - 1)
-            return false
-         end
+   end
+   for i = 1:length(x)
+      if coeff(x, i - 1) != coeff(y, i - 1)
+         return false
       end
    end
    return true

src/RelSeries.jl

@@ -727,8 +727,7 @@ that power series to different precisions may still be arithmetically
 equal to the minimum of the two precisions.
 """
 function ==(x::RelPowerSeriesRingElem{T}, y::RelPowerSeriesRingElem{T}) where T <: RingElement
-   b = check_parent(x, y, false)
-   !b && return false
+   check_parent(x, y)
 
    xval = valuation(x)
    xprec = precision(x)

src/Residue.jl

@@ -243,8 +243,7 @@ that power series to different precisions may still be arithmetically
 equal to the minimum of the two precisions.
 """
 function ==(a::ResElem{T}, b::ResElem{T}) where {T <: RingElement}
-   fl = check_parent(a, b, false)
-   !fl && return false
+   check_parent(a, b)
    return data(a) == data(b)
 end
 

src/ResidueField.jl

@@ -227,8 +227,7 @@ that power series to different precisions may still be arithmetically
 equal to the minimum of the two precisions.
 """
 function ==(a::ResFieldElem{T}, b::ResFieldElem{T}) where {T <: RingElement}
-   fl = check_parent(a, b, false)
-   !fl && return false
+   check_parent(a, b)
    return data(a) == data(b)
 end
 

src/generic/FreeAssociativeAlgebra.jl

@@ -295,8 +295,7 @@ end
 ###############################################################################
 
 function ==(a::FreeAssociativeAlgebraElem{T}, b::FreeAssociativeAlgebraElem{T}) where T
-    fl = check_parent(a, b, false)
-    !fl && return false
+    check_parent(a, b)
     return a.length == b.length &&
            view(a.exps, 1:a.length) == view(b.exps, 1:b.length) &&
            view(a.coeffs, 1:a.length) == view(b.coeffs, 1:b.length)

src/generic/LaurentMPoly.jl

@@ -132,7 +132,7 @@ end
 ###############################################################################
 
 function ==(a::LaurentMPolyWrap, b::LaurentMPolyWrap)
-    check_parent(a, b, false) || return false
+    check_parent(a, b)
     if a.mindegs == b.mindegs
         return a.mpoly == b.mpoly
     end

src/generic/LaurentSeries.jl

@@ -1037,8 +1037,7 @@ that power series to different precisions may still be arithmetically
 equal to the minimum of the two precisions.
 """
 function ==(x::LaurentSeriesElem{T}, y::LaurentSeriesElem{T}) where {T <: RingElement}
-   b = check_parent(x, y, false)
-   !b && return false
+   check_parent(x, y)
    xval = valuation(x)
    xprec = precision(x)
    yval = valuation(y)

src/generic/MPoly.jl

@@ -2022,8 +2022,7 @@ end
 ###############################################################################
 
 function ==(a::MPoly{T}, b::MPoly{T}) where {T <: RingElement}
-   fl = check_parent(a, b, false)
-   !fl && return false
+   check_parent(a, b)
    if a.length != b.length
       return false
    end

src/generic/PuiseuxSeries.jl

@@ -555,8 +555,7 @@ end
 ###############################################################################
 
 function ==(a::PuiseuxSeriesElem{T}, b::PuiseuxSeriesElem{T}) where T <: RingElement
-   fl = check_parent(a, b, false)
-   !fl && return false
+   check_parent(a, b)
    s = gcd(a.scale, b.scale)
    zscale = div(a.scale*b.scale, s)
    ainf = div(a.scale, s)

src/generic/TotalFraction.jl

@@ -306,8 +306,7 @@ end
 ###############################################################################
 
 function ==(x::TotFrac{T}, y::TotFrac{T}) where {T <: RingElem}
-   b  = check_parent(x, y, false)
-   !b && return false
+   check_parent(x, y)
 
    return (denominator(x, false) == denominator(y, false) &&
            numerator(x, false) == numerator(y, false)) ||