Through the refactor valley. The fancy sequence structs are implemented, hubbard trees are still dict wrappers

Author: jeffwack

src/Spiders.jl

@@ -1,7 +1,16 @@
 module Spiders
-export treeplot
-export EmbeddedHubbardTree
 include("trees/ShowTree.jl")
-# Write your package code here.
+
+export KneadingSequence
+
+export InternalAddress
+export HubbardTree
+
+export AngledInternalAddress
+export OrientedHubbardTree
+
+export HyperbolicComponent
+
+export treeplot
 
 end

src/parameters/DynamicRays.jl

@@ -2,16 +2,16 @@ include("../sequences/AngleDoubling.jl")
 include("../spidermap/SpiderFuncs.jl")
 
 struct ExternalRays
-    orb::Sequence{Rational}
-    rays::Dict{Rational,Vector{ComplexF64}}
+    orb::Sequence{BinaryExpansion}
+    rays::Dict{BinaryExpansion,Vector{ComplexF64}}
     parameter::Complex
 end
 
 ## Conjecture: if the collection of rays is a sequence of rays, we will not need this function.
 ## Question: Is it possible to update the rays in a mutating and not problematic way?
 function goesto(seq::Sequence)
     l = seq.preperiod
-    k = period(seq)
+    k = seq.period
     idx = append!(collect(1:l).+1,circshift(l+1:l+k,-1))
     return [(seq.items[x],seq.items[y]) for (x,y) in enumerate(idx)]
 end 
@@ -44,12 +44,12 @@ function extend!(Ext::ExternalRays)
 end
 
 
-function dynamicrays(c::Complex,angle::Rational,R::Real,res::Int,depth::Int)
+function dynamicrays(c::Complex,angle::BinaryExpansion,R::Real,res::Int,depth::Int)
     orb = orbit(angle)
     radii = collect(LinRange(R,sqrt(R),res))
 
     #similar to standard spider but is outer
-    rays = Sequence{Vector{ComplexF64}}([exp(2im*pi*theta).*radii for theta in orb.items],orb.preperiod)
+    rays = Sequence{Vector{ComplexF64}}([exp(2im*pi*Rational(theta)).*radii for theta in orb.items],orb.preperiod)
 
     for jj in 1:depth
         for (target,source) in goesto(rays)

src/sequences/AngleDoubling.jl

@@ -316,8 +316,10 @@ struct Digit{N} <: Integer
     end
 end
 
+Base.hash(d::Digit,h::UInt64) = hash(d.value,h)
+
 Base.show(io::IO, d::Digit{N}) where {N} = print(io, d.value)
-Base.Int(d::Digit{N}) where {N} = d.value
+Base.Int(d::Digit) = d.value
 
 const BinaryExpansion = Sequence{Digit{2}}
 

src/sequences/Sequences.jl

@@ -36,6 +36,14 @@ struct Sequence{T}
     end
 end
 
+function Base.getproperty(S::Sequence,sym::Symbol)
+    if sym === :period
+        return length(S.items) - S.preperiod
+    else
+        return getfield(S,sym)
+    end
+end
+
 function Sequence(str::String,preperiod::Int)
     return Sequence{Char}(Vector{Char}(str),preperiod)
 end
@@ -73,14 +81,6 @@ function Base.show(io::IO, s::Sequence{Char})
     end
 end
 
-function Base.getproperty(S::Sequence,sym::Symbol)
-    if sym === :period
-        return length(S.items) - S.preperiod
-    else
-        return getfield(S,sym)
-    end
-end
-
 function shift(seq::Sequence{T}) where T
     if seq.preperiod == 0 
         #then seq is periodic

src/spidermap/SpiderMap.jl

@@ -5,7 +5,7 @@ include("../sequences/AngleDoubling.jl")
 struct Spider
     angle::Rational
     orbit::Sequence{Rational}
-    kneading_sequence::Sequence{Char}
+    kneading_sequence::KneadingSequence
     legs::Vector{Vector{ComplexF64}}
 end
 
@@ -65,7 +65,7 @@ function mapspider!(S::Spider)
     λ = S.legs[2][end] #the parameter of our polynomial map z -> λ(1+z/2)^2
     a = (angle(S.legs[1][1]/λ)/(2*pi)+1)%1 #the angle whose halves will define the boundary between regions A and B at infinity. in full turns
 
-    n = length(S.orbit)
+    n = length(S.orbit.items)
 
     newLegs = Vector{Vector{ComplexF64}}(undef,n)
 
@@ -76,11 +76,11 @@ function mapspider!(S::Spider)
     #this angle lays in region A by definition. 
 
     if a/2 < theta1 && theta1 < (a+1)/2
-        cregion = 'A'
-        dregion = 'B'
+        cregion = A()
+        dregion = B()
     else
-        cregion = 'B'
-        dregion = 'A'
+        cregion = B()
+        dregion = A()
     end
 
     for ii in 2:n-1
@@ -103,13 +103,14 @@ function mapspider!(S::Spider)
         end
     end
 
+    #TODO what is going on with the periodic case? kneading sequences never have 1s and 2s now
     #we will break into periodic and preperiodic cases for the last leg
     if S.orbit.preperiod == 0 #periodic
         u = sqrt(S.legs[1][1]./λ)
         thetau = (angle(u)/(2*pi)+1)%1
 
         if abs2(thetau - a/2) < abs2(thetau - (a+1)/2)
-            if cregion == 'A'
+            if cregion == A()
                 if S.kneading_sequence.items[end] == '2'
                     newLegs[end] = path_sqrt(S.legs[1]./λ)
                 else
@@ -123,7 +124,7 @@ function mapspider!(S::Spider)
                 end
             end
         else
-            if cregion == 'A'
+            if cregion == A()
                 if S.kneading_sequence.items[end] == '1'
                     newLegs[end] = path_sqrt(S.legs[1]./λ)
                 else

src/trees/EmbedTrees.jl

@@ -2,49 +2,47 @@ include("OrientTrees.jl")
 include("../spidermap/SpiderMap.jl")
 include("../parameters/DynamicRays.jl")
 
-struct EmbeddedHubbardTree
-    zero::Sequence
-    adj::Dict{Sequence,Vector{Sequence}}
-    boundary::Vector{Sequence}
-    onezero::Dict{Sequence{Char}, Char}
+struct HyperbolicComponent
+    criticalpoint::Sequence
+    adj::Dict{KneadingSequence,Vector{KneadingSequence}}
+    boundary::Vector{KneadingSequence}
+    onezero::Dict{KneadingSequence, Union{Nothing,Digit{2}}}
     angle::Rational
-    rays::Dict{Rational,Vector{ComplexF64}}
+    rays::Dict{BinaryExpansion,Vector{ComplexF64}}
     parameter::ComplexF64
-    vertices::Dict{Sequence, ComplexF64} #maps each vertex in the tree to a point in the plane
-    edges::Dict{Set{Sequence{Char}}, Tuple{Sequence{Char}, Vector{ComplexF64}}} #maps each edge to an oriented polyline
+    vertices::Dict{KneadingSequence, ComplexF64} #maps each vertex in the tree to a point in the plane
+    edges::Dict{Set{KneadingSequence}, Tuple{KneadingSequence, Vector{ComplexF64}}} #maps each edge to an oriented polyline
 end
 
-function EmbeddedHubbardTree(OHT::OrientedHubbardTree)
+function HyperbolicComponent(OHT::OrientedHubbardTree)
 
     OZ = labelonezero(OHT)
     anglelist = allanglesof(OZ,OHT)
 
-    criticalorbit = orbit(OHT.zero) #This is a sequence orbit
+    criticalorbit = orbit(OHT.criticalpoint) #This is a sequence orbit
 
-    theta = angleof(first(criticalanglesof(OZ,OHT)))
+    theta = Rational(first(criticalanglesof(OZ,OHT)))
     c = parameter(standardspider(theta),250)
-    println(c)
 
     #critical orbit
     rays = Dict()
     #periodic branch points
     characteristicpoints = characteristicset(OHT)
     for point in characteristicpoints
-        merge!(rays,dynamicrays(c,angleof(first(anglelist[point])),100,10,20))
+        merge!(rays,dynamicrays(c,first(anglelist[point]),100,10,20))
     end
-
+    
     #preperiod branch points. This is slow!
     for node in keys(OHT.adj)
         for angle in anglelist[node]
             if !(angle in keys(rays))
-                phi = angleof(angle)
-                push!(rays,Pair(phi,dynamicrays(c,phi,100,10,20)[phi]))
+                push!(rays,Pair(angle,dynamicrays(c,angle,100,10,20)[angle]))
             end
         end
     end
 
-    merge!(rays,dynamicrays(c,1//2,100,10,40))
-    merge!(rays,dynamicrays(c,0//1,100,10,40))
+    merge!(rays,dynamicrays(c,BinaryExpansion(1//2),100,10,40))
+    merge!(rays,dynamicrays(c,BinaryExpansion(0//1),100,10,40))
 
     paramorbit = [0.0+0.0im]
     n = period(theta)
@@ -56,19 +54,19 @@ function EmbeddedHubbardTree(OHT::OrientedHubbardTree)
 
     zvalues = Dict{Sequence,ComplexF64}()
     for node in keys(OHT.adj)
-        if '*' in node.items #then it is in the critical orbit
-            idx = findone(x->x=='*',node.items)
+        if star() in node.items #then it is in the critical orbit
+            idx = findone(x->x==star(),node.items)
             push!(zvalues,Pair(node,paramorbit[mod1(n-idx+2,n)]))
         else
-            list = [rays[angleof(angle)][end] for angle in anglelist[node]]
+            list = [rays[angle][end] for angle in anglelist[node]]
             push!(zvalues,Pair(node,sum(list)/length(list)))
         end
     end
-    E = standardedges(OHT.adj,OHT.zero,zvalues)
-    return EmbeddedHubbardTree(OHT.zero,OHT.adj,OHT.boundary,OZ,theta,rays,c,zvalues,E)
+    E = standardedges(OHT.adj,OHT.criticalpoint,zvalues)
+    return HyperbolicComponent(OHT.criticalpoint,OHT.adj,OHT.boundary,OZ,theta,rays,c,zvalues,E)
 end
 
-function Base.show(io::IO,H::EmbeddedHubbardTree)
+function Base.show(io::IO,H::HyperbolicComponent)
     return println(io,"Embedded Hubbard tree of "*repr(H.angle)*" with "*repr(length(keys(H.adj)))*" vertices")
 end
 
@@ -120,15 +118,15 @@ function edgepath(graph,start, finish)
 end
 
 function refinedtree(OHT,zvalues,steps)
-    c = zvalues[shift(OHT.zero)]
+    c = zvalues[shift(OHT.criticalpoint)]
     E = standardedges(OHT,zvalues)
     for ii in 1:steps
         E = refinetree(OHT,c,E)
     end
     return E
 end
 
-function refinetree!(EHT::EmbeddedHubbardTree)
+function refinetree!(EHT)
 
     newedges = []
     for edge in keys(EHT.edges)

src/trees/Graphs.jl

@@ -1,22 +1,19 @@
+#implement adj and you should be able to use all these functions?
 abstract type Graph end
 
-struct SetGraph{T} <: Graph
-    adj::Dict{T,Set{T}}
-end
-
-struct OrientedGraph{T} <: Graph
-    adj::Dict{T,Vector{T}}
-end
-
 function Base.getindex(G::Graph,idx)
     return G.adj[idx]
 end
 
+function vertices(G::Graph)
+    return Set(keys(G.adj))
+end
+
 Base.show(io::IO,G::Graph) = display(G.adj)
 
-function adjlist(graph::Graph)
+function adjlist(graph)
     #first, assign an index to each point
-    nodes = collect(graph.vertices)
+    nodes = collect(keys(graph))
     E = Vector{Int}[]
     for node in nodes
         g = []

src/trees/HubbardTrees.jl

@@ -5,7 +5,16 @@
 include("../sequences/AngleDoubling.jl") 
 include("Graphs.jl")
 
-const HubbardTree = SetGraph{KneadingSequence}
+abstract type AbstractHubbardTree <: Graph end
+
+function criticalpoint(H::AbstractHubbardTree)
+    return first(filter(x->x[1]==star(),vertices(H)))
+end
+
+struct HubbardTree <: AbstractHubbardTree
+    adj::Dict{KneadingSequence,Set{KneadingSequence}}
+    criticalpoint::KneadingSequence
+end
 
 function HubbardTree(K::KneadingSequence)
     starK = prepend(K,star())
@@ -21,7 +30,7 @@ function HubbardTree(K::KneadingSequence)
             #println("result is $H")
         end
     end
-    return SetGraph{KneadingSequence}(H)
+    return HubbardTree(H,starK)
 end
 
 function HubbardTree(intadd::InternalAddress)
@@ -31,16 +40,6 @@ function HubbardTree(intadd::InternalAddress)
     return HubbardTree(Sequence{KneadingSymbol}(seq,0))
 end
 
-function Base.getproperty(H::HubbardTree,sym::Symbol)
-    if sym === :zero
-        return first(filter(x->x[1]==star(),H.vertices))
-    elseif sym === :vertices
-        return Set(keys(H.adj))
-    else
-        return getfield(H,sym)
-    end
-end
-
 function addsequence(Htree,Kseq,(A,Bset),newpoint)
     if newpoint in collect(keys(Htree))
         print("warning: point already in tree")
@@ -74,9 +73,9 @@ function addsequence(Htree,Kseq,(A,Bset),newpoint)
 end
 
 function extend(H::HubbardTree,new::Sequence)
-    Z = H.zero
+    Z = criticalpoint(H)
     K = shift(Z)
-    return HubbardTree(addsequence(H.adj,K,(Z,deepcopy(H.adj[Z])),new))
+    return HubbardTree(addsequence(H.adj,K,(Z,deepcopy(H.adj[Z])),new),Z)
 end
 
 function iteratetriod(K::Sequence,triod::Tuple{Sequence,Sequence,Sequence})
@@ -159,8 +158,8 @@ function findone(f,A)
     end
 end
 
-function isbetween(htree::Dict,a,b,c)
-    zero = first(filter(x->x.items[1]==star(),keys(htree)))
+function isbetween(htree::AbstractHubbardTree,a,b,c)
+    zero = htree.criticalpoint
     K = shift(zero)
     (type,vertex) = iteratetriod(K,(a,b,c))
     if type == "flat" && vertex == a