a struct and recipe for rays, simple convergence for spiders, and beginnings of orbit portraits

Author: jeffwack

parameters/DynamicRays.jl

@@ -1,24 +1,48 @@
-using GLMakie
-using ColorSchemes
 include("../sequences/AngleDoubling.jl")
 include("../spiders/SpiderFuncs.jl")
 
-## Conjecture: if the collection of rays is a sequence of rays, we will not need this function
+struct ExternalRays
+    orb::Sequence{Rational}
+    rays::Dict{Rational,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)
     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 
 
-### DANGER ###
-#copy and pasted from HubbardTrees.jl
-#similar to above function?
-#=
-function forwardimages(htree::Dict)
-    return Dict([Pair(key,[shift(key)]) for key in keys(htree)])
-end 
-=#
+function standardrays(theta::Rational,c::Complex,R::Real,res::Int)
+    orb = orbit(theta)
+    radii = collect(LinRange(R,sqrt(R),res))
+    rays = Dict([Pair(phi,exp(2im*pi*phi).*radii) for phi in orb.items])
+    return ExternalRays(orb,rays,c)
+end
+
+function extend!(Ext::ExternalRays)
+    for (target,source) in goesto(rays)
+        z = source[end-res+1]
+        a = sqrt(-c + z)
+        b = -sqrt(-c + z)
+
+        da = abs2(target[end]-a)
+        db = abs2(target[end]-b)
+
+        if da < db
+            append!(target,path_sqrt(-c .+ source[end-res+1:end]))
+        elseif db < da
+            append!(target,-1 .* path_sqrt(-c .+ source[end-res+1:end]))
+        else
+            return error("can't decide what to glue")
+        end     
+    end
+    return Ext
+end
+
 
 function dynamicrays(c::Complex,angle::Rational,R::Real,res::Int,depth::Int)
     orb = orbit(angle)

parameters/ShowRays.jl

@@ -0,0 +1,16 @@
+using GLMakie
+using ColorSchemes
+include("DynamicRays.jl")
+
+@recipe(RayPlot,ExtRays) do scene 
+    Theme()
+end
+
+function Makie.plot!(myplot::RayPlot)
+    rays = collect(values(myplot.ExtRays[].rays))
+    n = length(rays)
+    for (j ,ray) in enumerate(rays)
+        lines!(myplot,real(ray),imag(ray),color = get(ColorSchemes.rainbow, float(j)/float(n)))
+    end
+    return myplot
+end

spiders/Spiders.jl

@@ -180,10 +180,21 @@ function spideriterates(S0::Spider,n_iter::Int)
 end
 
 #TODO modify below to have tolerance-based convergence behavior
-function parameter(S0::Spider,n_iter::Int)
+function parameter(S0::Spider,max_iter::Int)
     S = deepcopy(S0)
-    for ii in 1:n_iter
+    c_last = S.legs[2][end]/2 
+    for ii in 1:max_iter
         mapspider!(S)
+        c = S.legs[2][end]/2
+        println(repr(c)*" delta "*repr(abs(c-c_last)))
+        if abs(c-c_last)<(1e-15)
+            return c
+        end
+        c_last = c
     end
-    return S.legs[2][end]/2
+    return S.legs[2][end]/2 
+end
+
+function parameter(theta::Rational,max_iter::Int)
+    return parameter(standardspider(theta),max_iter)
 end

trees/EmbedTrees.jl

@@ -23,7 +23,7 @@ function EmbeddedHubbardTree(OHT::OrientedHubbardTree)
 
     theta = angleof(first(criticalanglesof(OZ,OHT)))
     c = parameter(standardspider(theta),250)
-    print(c)
+    println(c)
 
     #critical orbit
     rays = Dict()
@@ -37,8 +37,8 @@ function EmbeddedHubbardTree(OHT::OrientedHubbardTree)
     for node in keys(OHT.adj)
         for angle in anglelist[node]
             if !(angle in keys(rays))
-                theta = angleof(angle)
-                push!(rays,Pair(theta,dynamicrays(c,theta,100,10,20)[theta]))
+                phi = angleof(angle)
+                push!(rays,Pair(phi,dynamicrays(c,phi,100,10,20)[phi]))
             end
         end
     end
@@ -48,9 +48,11 @@ function EmbeddedHubbardTree(OHT::OrientedHubbardTree)
 
     paramorbit = [0.0+0.0im]
     n = period(theta)
+    #println(n)
     for ii in 1:n-1
         push!(paramorbit,paramorbit[end]^2+c)
     end
+    #println(paramorbit)
 
     zvalues = Dict{Sequence,ComplexF64}()
     for node in keys(OHT.adj)
@@ -62,11 +64,14 @@ function EmbeddedHubbardTree(OHT::OrientedHubbardTree)
             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)
 end
 
+function Base.show(io::IO,H::EmbeddedHubbardTree)
+    return println(io,"Embedded Hubbard tree of "*repr(H.angle)*" with "*repr(length(keys(H.adj)))*" vertices")
+end
+
 function standardedges(adj,zero,zvalues)
     edges = edgeset(adj)
 
@@ -196,4 +201,9 @@ function showtree(angle::Rational)
 end
 
 
-
+function angleclusters(H::OrientedHubbardTree)
+    charset = characteristicset(H)
+    allangles = allanglesof(H)
+    anglegroups = [allangles[branch] for branch in charset]
+    return anglegroups
+end

trees/OrientTrees.jl

@@ -1,4 +1,4 @@
-include("HubbardTrees.jl")
+include("HubbardTrees.jl") 
 
 struct OrientedHubbardTree <: AbstractHubbardTree
     zero::Sequence

trees/ShowTree.jl

@@ -1,4 +1,5 @@
 using GLMakie
+using ColorSchemes
 include("EmbedTrees.jl")
 include("../spiders/Spiders.jl")
 include("../parameters/DynamicRays.jl")