similar...

Author: fingolfin

src/Ideal.jl

@@ -70,6 +70,12 @@ function ideal(xs::AbstractVector{T}; kw...) where T<:NCRingElement
   return ideal(parent(xs[1]), xs; kw...)
 end
 
+function Base.similar(I::T, xs::Vector) where {T <: Ideal}
+  R = base_ring(I)
+  @assert T === ideal_type(R)
+  return ideal(R, xs)
+end
+
 ###############################################################################
 #
 #   Basic predicates
@@ -78,10 +84,15 @@ end
 
 iszero(I::Ideal) = all(iszero, gens(I))
 
-function is_subset(I::T, J::T) where {T <: Ideal}
+@doc raw"""
+    Base.issubset(I::T, J::T) where {T <: Ideal}
+
+Return `true` if the ideal `I` is a subset of the ideal `J`.
+"""
+function Base.issubset(I::T, J::T) where {T <: Ideal}
   I === J && return true
   check_base_ring(I, J)
-  return all(x in J for x in gens(I))
+  return all(in(J), gens(I))
 end
 
 ###############################################################################
@@ -107,12 +118,12 @@ end
 
 function Base.:+(I::T, J::T) where {T <: Ideal}
   check_base_ring(I, J)
-  return ideal(base_ring(I), vcat(gens(I), gens(J)))
+  return similar(I, vcat(gens(I), gens(J)))
 end
 
 function Base.:*(I::T, J::T) where {T <: Ideal}
   check_base_ring(I, J)
-  return ideal(base_ring(I), [x*y for x in gens(I) for y in gens(J)])
+  return similar(I, [x*y for x in gens(I) for y in gens(J)])
 end
 
 ###############################################################################
@@ -130,19 +141,17 @@ function *(x::RingElement, R::Ring)
 end
 
 function *(I::Ideal{T}, p::T) where T <: RingElement
-  R = base_ring(I)
-  iszero(p) && return ideal(R, T[])
-  return ideal(R, [v*p for v in gens(I)])
+  iszero(p) && return similar(I, T[])
+  return similar(I, [v*p for v in gens(I)])
 end
 
 function *(p::T, I::Ideal{T}) where T <: RingElement
   return I*p
 end
 
 function *(I::Ideal{T}, p::S) where {S <: RingElement, T <: RingElement}
-  R = base_ring(I)
-  iszero(p*one(R)) && return ideal(R, T[])
-  return ideal(R, [v*p for v in gens(I)])
+  iszero(p*one(R)) && return similar(I, T[])
+  return similar(I, [v*p for v in gens(I)])
 end
 
 function *(p::S, I::Ideal{T}) where {S <: RingElement, T <: RingElement}

src/generic/Ideal.jl

@@ -2098,33 +2098,14 @@ end
 
 ###############################################################################
 #
-#   Comparison
-#
-###############################################################################
-
-function ==(I::Ideal{T}, J::Ideal{T}) where T <: RingElement
-   return gens(I) == gens(J)
-end
-
-###############################################################################
-#
-#   Containment
+#   Membership
 #
 ###############################################################################
 
 function Base.in(v::T, I::Ideal{T}) where T <: RingElement
   return is_zero(normal_form(v, I))
 end
 
-@doc raw"""
-    Base.issubset(I::Ideal{T}, J::Ideal{T}) where T <: RingElement
-
-Return `true` if the ideal `I` is a subset of the ideal `J`.
-"""
-function Base.issubset(I::Ideal{T}, J::Ideal{T}) where T <: RingElement
-   return all(in(J), gens(I))
-end
-
 ###############################################################################
 #
 #   Intersection
@@ -2208,41 +2189,6 @@ function intersect(I::Ideal{T}, J::Ideal{T}) where {U <: RingElement, T <: Abstr
    return Ideal(S, GInt)
 end
 
-###############################################################################
-#
-#   Ad hoc binary operations
-#
-###############################################################################
-
-function *(I::Ideal{T}, p::T) where T <: RingElement
-   R = base_ring(I)
-   G = gens(I)
-   if iszero(p)
-      return Ideal(R, T[])
-   end
-   p = divexact(p, canonical_unit(p))
-   return Ideal(R, [v*p for v in G])
-end
-
-function *(p::T, I::Ideal{T}) where T <: RingElement
-   return I*p
-end
-
-function *(I::Ideal{T}, p::S) where {S <: RingElement, T <: RingElement}
-   R = base_ring(I)
-   G = gens(I)
-   if iszero(p*one(R))
-      return Ideal(R, T[])
-   end
-   V = [v*p for v in G]
-   V = [divexact(v, canonical_unit(v)) for v in V]
-   return Ideal(R, V)
-end
-
-function *(p::S, I::Ideal{T}) where {S <: RingElement, T <: RingElement}
-   return I*p
-end
-
 ###############################################################################
 #
 #   Ideal reduction in Euclidean domain
@@ -2294,7 +2240,9 @@ function Ideal(R::Ring, v::T, vs::T...) where T <: RingElement
 end
 
 Ideal(R::Ring) = Ideal(R, elem_type(R)[])
-Ideal(R::Ring, V::Vector{Any}) = Ideal(R, elem_type(R)[R(v) for v in V])
+Ideal(R::Ring, V::Vector) = Ideal(R, elem_type(R)[R(v) for v in V])
+
+Base.similar(I::Ideal, V::Vector) = Ideal(base_ring(I), V)
 
 ###############################################################################
 #