whitespace formatting in poly.jl

Author: Jutho

src/indexnotation/poly.jl

@@ -4,38 +4,38 @@ Base.one(x::AbstractPoly) = one(typeof(x))
 Base.zero(x::AbstractPoly) = zero(typeof(x))
 
 function Base.show(io::IO, p::AbstractPoly{D,T}) where {D,T<:Real}
-    N=degree(p)
-    for i=N:-1:0
+    N = degree(p)
+    for i = N:-1:0
         if i > 0
-            print(io,"$(abs(p[i]))*")
+            print(io, "$(abs(p[i]))*")
             print(io, "$D")
-            i>1 && print(io,"^$i")
-            print(io, p[i-1]<0 ? " - " : " + ")
+            i > 1 && print(io, "^$i")
+            print(io, p[i-1] < 0 ? " - " : " + ")
         else
-            print(io,"$(abs(p[i]))")
+            print(io, "$(abs(p[i]))")
         end
     end
 end
 function Base.show(io::IO, p::AbstractPoly{D,T}) where {D,T<:Complex}
-    N=degree(p)
-    for i=N:-1:0
-        if i>0
-            print(io,"($(p[i]))*")
-            print(io,"$D")
-            i>1 && print(io,"^$i")
+    N = degree(p)
+    for i = N:-1:0
+        if i > 0
+            print(io, "($(p[i]))*")
+            print(io, "$D")
+            i > 1 && print(io, "^$i")
             print(io, " + ")
         else
-            print(io,"($(p[i]))")
+            print(io, "($(p[i]))")
         end
     end
 end
 struct Power{D,T} <: AbstractPoly{D,T}
     coeff::T
     N::Int
 end
-degree(p::Power)=p.N
-Base.getindex(p::Power{D,T},i::Int) where {D,T} = (i==p.N ? p.coeff : zero(T))
-Power{D}(coeff::T, N::Int=0) where {D,T} = Power{D,T}(coeff, N)
+degree(p::Power) = p.N
+Base.getindex(p::Power{D,T},i::Int) where {D,T} = (i == p.N ? p.coeff : zero(T))
+Power{D}(coeff::T, N::Int = 0) where {D,T} = Power{D,T}(coeff, N)
 
 Base.one(::Type{Power{D,T}}) where {D,T} = Power{D,T}(one(T), 0)
 Base.zero(::Type{Power{D,T}}) where {D,T} = Power{D,T}(zero(T), 0)
@@ -45,18 +45,18 @@ Base.convert(::Type{Power{D,T}}, coeff::Number) where {D,T} = Power{D,T}(coeff,
 Base.convert(::Type{Power{D,T}}, p::Power{D}) where {D,T} = Power{D,T}(p.coeff, p.N)
 
 function Base.show(io::IO,p::Power{D,T}) where {D,T}
-    if p.coeff==1
-    elseif p.coeff==-1
-        print(io,"-")
-    elseif isa(p.coeff,Complex)
-        print(io,"($(p.coeff))")
+    if p.coeff == 1
+    elseif p.coeff == -1
+        print(io, "-")
+    elseif isa(p.coeff, Complex)
+        print(io, "($(p.coeff))")
     else
-        print(io,"$(p.coeff)")
+        print(io, "$(p.coeff)")
     end
-    p.coeff==1 || p.coeff==-1 || p.N==0 || print(io,"*")
-    p.N==0 && (p.coeff==1 || p.coeff==-1) && print(io,"1")
-    p.N>0 && print(io,"$D")
-    p.N>1 && print(io,"^$(p.N)")
+    p.coeff == 1 || p.coeff == -1 || p.N == 0 || print(io, "*")
+    p.N == 0 && (p.coeff == 1 || p.coeff ==- 1) && print(io, "1")
+    p.N > 0 && print(io, "$D")
+    p.N > 1 && print(io, "^$(p.N)")
 end
 
 Base.:*(p1::Power{D}, p2::Power{D}) where {D} = Power{D}(p1.coeff*p2.coeff, degree(p1)+degree(p2))
@@ -84,37 +84,37 @@ Base.convert(::Type{Poly{D}}, p::Power{D}) where {D} = Poly{D}(vcat(fill(zero(p.
 Base.convert(::Type{Poly{D,T}}, p::Power{D}) where {D,T} = Poly{D,T}(vcat(fill(zero(T), p.N), convert(T, p.coeff)))
 Base.convert(::Type{Poly{D,T}}, p::Poly{D}) where {D,T} = Poly{D,T}(convert(Vector{T}, p.coeffs))
 
-Base.:+(p::Poly{D}, s::Number) where {D} = Poly{D}([p[i]+(i==0 ? s : zero(s)) for i=0:degree(p)])
+Base.:+(p::Poly{D}, s::Number) where {D} = Poly{D}([p[i] + (i == 0 ? s : zero(s)) for i = 0:degree(p)])
 Base.:+(s::Number, p::Poly) = +(p,s)
 function Base.:+(p1::Power{D,T1}, p2::Power{D,T2}) where {D,T1,T2}
-    T=promote_type(T1,T2)
-    coeffs=zeros(T,max(degree(p1),degree(p2))+1)
-    coeffs[p1.N+1]=p1.coeff
-    coeffs[p2.N+1]+=p2.coeff
+    T = promote_type(T1,T2)
+    coeffs = zeros(T,max(degree(p1),degree(p2))+1)
+    coeffs[p1.N+1] = p1.coeff
+    coeffs[p2.N+1] += p2.coeff
     return Poly{D,T}(coeffs)
 end
 function Base.:+(p::Power{D,T1}, s::T2) where {D,T1,T2}
-    T=promote_type(T1,T2)
-    coeffs=zeros(T,degree(p)+1)
+    T = promote_type(T1,T2)
+    coeffs = zeros(T,degree(p)+1)
     coeffs[p.N+1] = p.coeff
     coeffs[1] += s
     return Poly{D,T}(coeffs)
 end
 Base.:+(s::Number, p::Power) = +(p,s)
 
 function Base.:+(p1::Power{D,T1}, p2::Poly{D,T2}) where {D,T1,T2}
-    T=promote_type(T1,T2)
-    coeffs=zeros(T,max(degree(p1),degree(p2))+1)
-    coeffs[1:(degree(p2)+1)]=p2.coeffs
-    coeffs[p1.N+1]+=p1.coeff
+    T = promote_type(T1,T2)
+    coeffs = zeros(T,max(degree(p1),degree(p2))+1)
+    coeffs[1:(degree(p2)+1)] = p2.coeffs
+    coeffs[p1.N+1] += p1.coeff
     return Poly{D,T}(coeffs)
 end
 Base.:+(p1::Poly{D},p2::Power{D}) where {D}=+(p2,p1)
 function Base.:+(p1::Poly{D,T1}, p2::Poly{D,T2}) where {D,T1,T2}
-    T=promote_type(T1,T2)
-    coeffs=zeros(T, max(degree(p1),degree(p2))+1)
+    T = promote_type(T1,T2)
+    coeffs = zeros(T, max(degree(p1),degree(p2))+1)
     coeffs[1:(degree(p1)+1)] = p1.coeffs
-    for j=0:degree(p2)
+    for j = 0:degree(p2)
         coeffs[j+1] += p2.coeffs[j+1]
     end
     return Poly{D,T}(coeffs)
@@ -130,12 +130,12 @@ Base.:*(p1::Poly{D}, p2::Power{D}) where {D} = *(p2,p1)
 Base.:*(p::Poly{D}, s::Number) where {D} = Poly{D}(s*p.coeffs)
 Base.:*(s::Number, p::Poly) = *(p,s)
 function Base.:*(p1::Poly{D}, p2::Poly{D}) where {D}
-    N=degree(p1)+degree(p2)
-    s=p1[0]*p2[0]
-    coeffs=zeros(typeof(s), N+1)
-    for i=0:degree(p1)
-        for j=0:degree(p2)
-            coeffs[i+j+1]+=p1[i]*p2[j]
+    N = degree(p1)+degree(p2)
+    s = p1[0]*p2[0]
+    coeffs = zeros(typeof(s), N+1)
+    for i = 0:degree(p1)
+        for j = 0:degree(p2)
+            coeffs[i+j+1] += p1[i]*p2[j]
         end
     end
     return Poly{D}(coeffs)
@@ -148,15 +148,15 @@ Base.promote_rule(::Type{Poly{D,T1}}, ::Type{Power{D,T2}}) where {D,T1<:Number,T
 Base.promote_rule(::Type{Poly{D,T1}}, ::Type{T2}) where {D,T1<:Number,T2<:Number} = Poly{D,promote_type(T1,T2)}
 
 function Base.:(==)(p1::AbstractPoly{D}, p2::AbstractPoly{D}) where {D}
-    for i=max(degree(p1),degree(p2)):-1:0
-        p1[i]==p2[i] || return false
+    for i = max(degree(p1),degree(p2)):-1:0
+        p1[i] == p2[i] || return false
     end
     return true
 end
 function Base.:<(p1::AbstractPoly{D}, p2::AbstractPoly{D}) where {D}
-    for i=max(degree(p1),degree(p2)):-1:0
-        p1[i]<p2[i] && return true
-        p1[i]>p2[i] && return false
+    for i = max(degree(p1),degree(p2)):-1:0
+        p1[i] < p2[i] && return true
+        p1[i] > p2[i] && return false
     end
     return false
 end