put gcd into common since it only depends on divrem being implemented

Author: mileslucas

src/common.jl

@@ -437,9 +437,18 @@ Polynomial(4.0 - 6.0*x + 2.0*x^2)
 
 ```
 """
-function Base.gcd(p1::P, p2::O) where {P <: AbstractPolynomial,O <: AbstractPolynomial}
-    p1, p2 = promote(p1, p1)
-    return gcd(p1, p2)
+function Base.gcd(p1::AbstractPolynomial{T}, p2::AbstractPolynomial{S}) where {T, S}
+    r₀, r₁ = promote(p1, p2)
+    iter    = 1
+    itermax = length(r₁)
+  
+    while r₁ ≉ zero(r₁) && iter ≤ itermax   # just to avoid unnecessary recursion
+      _, rtemp  = divrem(r₀, r₁)
+      r₀        = r₁
+      r₁        = truncate(rtemp)
+      iter      += 1
+    end
+    return r₀
 end
 
 """

src/polynomials/ChebyshevT.jl

@@ -147,7 +147,6 @@ function Base.:*(p1::ChebyshevT{T}, p2::ChebyshevT{S}) where {T,S}
     return truncate!(ret)
 end
 
-##
 function Base.divrem(num::ChebyshevT{T}, den::ChebyshevT{S}) where {T,S}
     num.var != den.var && error("Polynomials must have same variable")
     n = length(num) - 1
@@ -162,30 +161,14 @@ function Base.divrem(num::ChebyshevT{T}, den::ChebyshevT{S}) where {T,S}
         den[0] ≈ 0 && throw(DivideError())
         return num ./ den[end], zero(P)
     end
-    
+
     znum = _c_to_z(num.coeffs)
     zden = _c_to_z(den.coeffs)
     quo, rem = _z_division(znum, zden)
     q_coeff = _z_to_c(quo)
     r_coeff = _z_to_c(rem)
     return P(q_coeff, num.var), P(r_coeff, num.var)
 end
-# ##
-# function Base.gcd(a::ChebyshevT{T}, b::ChebyshevT{S}) where {T,S}
-#     U       = typeof(one(T) / one(S))
-#     r₀ = convert(ChebyshevT{U}, a)
-#     r₁ = truncate!(convert(ChebyshevT{U}, b))
-#     iter    = 1
-#     itermax = length(b)
-
-#     while r₁ ≉ zero(r₁) && iter ≤ itermax   # just to avoid unnecessary recursion
-#         _, rtemp  = divrem(r₀, r₁)
-#         r₀        = r₁
-#         r₁        = truncate(rtemp)
-#         iter      += 1
-#     end
-#     return r₀
-# end
 
 function printpoly(io::IO, p::ChebyshevT{T}, mimetype = MIME"text/plain"(); descending_powers = false, offset::Int = 0) where {T}
     chopped = chop(p)

src/polynomials/Poly.jl

@@ -147,20 +147,4 @@ function Base.divrem(num::Poly{T}, den::Poly{S}) where {T,S}
     return P(q_coeff, num.var), P(r_coeff, num.var)
 end
 
-function Base.gcd(a::Poly{T}, b::Poly{S}) where {T,S}
-  U       = typeof(one(T) / one(S))
-  r₀ = convert(Poly{U}, a)
-  r₁ = truncate!(convert(Poly{U}, b))
-  iter    = 1
-  itermax = length(b)
-
-  while r₁ ≉ zero(r₁) && iter ≤ itermax   # just to avoid unnecessary recursion
-    _, rtemp  = divrem(r₀, r₁)
-    r₀        = r₁
-    r₁        = truncate(rtemp)
-    iter      += 1
-  end
-  return r₀
-end
-
 showterm(io::IO, ::Type{Poly{T}}, pj::T, var, j, first::Bool, mimetype) where{T} = showterm(io, Polynomial{T}, pj, var, j, first, mimetype)

src/polynomials/Polynomial.jl

@@ -154,22 +154,6 @@ function Base.divrem(num::Polynomial{T}, den::Polynomial{S}) where {T,S}
     return P(q_coeff, num.var), P(r_coeff, num.var)
 end
 
-function Base.gcd(a::Polynomial{T}, b::Polynomial{S}) where {T,S}
-  U       = typeof(one(T) / one(S))
-  r₀ = convert(Polynomial{U}, a)
-  r₁ = truncate!(convert(Polynomial{U}, b))
-  iter    = 1
-  itermax = length(b)
-
-  while r₁ ≉ zero(r₁) && iter ≤ itermax   # just to avoid unnecessary recursion
-    _, rtemp  = divrem(r₀, r₁)
-    r₀        = r₁
-    r₁        = truncate(rtemp)
-    iter      += 1
-  end
-  return r₀
-end
-
 function showterm(io::IO, ::Type{Polynomial{T}}, pj::T, var, j, first::Bool, mimetype) where {T}
     if pj == zero(T) return false end
     pj = printsign(io, pj, first, mimetype)

test/ChebyshevT.jl

@@ -107,6 +107,11 @@ end
     @test coeffs(d) ≈ [0, 2]
     @test coeffs(r) ≈ [-2, -4]
 
+
+    # GCD
+    c1 = ChebyshevT([1, 2, 3])
+    c2 = ChebyshevT([3, 2, 1])
+    @test gcd(c1, c2) ≈ ChebyshevT(6)
 end
 
 @testset "z-series" for i in 1:5

test/runtests.jl

@@ -7,7 +7,7 @@ using RecipesBase: apply_recipe
 
 import SparseArrays: sparse, nnz
 
-# @testset "Polynomial" begin include("Polynomial.jl") end
+@testset "Polynomial" begin include("Polynomial.jl") end
 @testset "ChebyshevT" begin include("ChebyshevT.jl") end
 # @testset "Deprecations" begin include("deprecated.jl") end
 # @testset "Poly (deprecaterd)" begin include("Poly.jl") end