Data commit

Task/Hamming-numbers/Julia/hamming-numbers-1.julia

@@ -0,0 +1,25 @@
+function hammingsequence(N)
+    if N < 1
+        throw("Hamming sequence exponent must be a positive integer")
+    end
+    ham = N > 4000 ? Vector{BigInt}([1]) : Vector{Int}([1])
+    base2, base3, base5 = (1, 1, 1)
+    for i in 1:N-1
+        x = min(2ham[base2], 3ham[base3], 5ham[base5])
+        push!(ham, x)
+        if 2ham[base2] <= x
+            base2 += 1
+        end
+        if 3ham[base3] <= x
+            base3 += 1
+        end
+        if 5ham[base5] <= x
+            base5 += 1
+        end
+    end
+    ham
+end
+
+println(hammingsequence(20))
+println(hammingsequence(1691)[end])
+println(hammingsequence(1000000)[end])

Task/Hamming-numbers/Julia/hamming-numbers-2.julia

@@ -0,0 +1,16 @@
+function hammingsequence(N::Int)
+    if N < 1
+        throw("Hamming sequence index must be a positive integer")
+    end
+    ham = Vector{BigInt}([1])
+    base2, base3, base5 = 1, 1, 1
+    next2, next3, next5 = BigInt(2), BigInt(3), BigInt(5)
+    for _ in 1:N-1
+        x = min(next2, next3, next5)
+        push!(ham, x)
+        next2 <= x && (base2 += 1; next2 = 2ham[base2])
+        next3 <= x && (base3 += 1; next3 = 3ham[base3])
+        next5 <= x && (base5 += 1; next5 = 5ham[base5])
+    end
+    ham
+end

Task/Hamming-numbers/Julia/hamming-numbers-3.julia

@@ -0,0 +1,79 @@
+struct LogRep
+    lg :: Float64
+    x2 :: UInt32
+    x3 :: UInt32
+    x5 :: UInt32
+end
+const ONE = LogRep(0.0, 0, 0, 0)
+const LB2_2 = 1.0
+const LB2_3 = log(2,3)
+const LB2_5 = log(2,5)
+function mult2(lr :: LogRep) # :: LogRep
+    LogRep(lr.lg + LB2_2, lr.x2 + 1, lr.x3, lr.x5)
+end
+function mult3(lr :: LogRep) # :: LogRep
+    LogRep(lr.lg + LB2_3, lr.x2, lr.x3 + 1, lr.x5)
+end
+function mult5(lr :: LogRep) # :: LogRep
+    LogRep(lr.lg + LB2_5, lr.x2, lr.x3, lr.x5 + 1)
+end
+function lr2BigInt(lr :: LogRep) # :: BigInt
+    BigInt(2)^lr.x2 * BigInt(3)^lr.x3 * BigInt(5)^lr.x5
+end
+
+mutable struct HammingsLog
+    s2 :: Vector{LogRep}
+    s3 :: Vector{LogRep}
+    s5 :: LogRep
+    mrg :: LogRep
+    s2hdi :: Int
+    s3hdi :: Int
+    HammingsLog() = new(
+        [ONE],
+        [mult3(ONE)],
+        mult5(ONE),
+        mult3(ONE),
+        1, 1
+    )
+end
+Base.eltype(::Type{HammingsLog}) = LogRep
+function Base.iterate(HM::HammingsLog, st = HM) # :: Union{Nothing,Tuple{LogRep,HammingsLog}}
+    s2sz = length(st.s2)
+    if st.s2hdi + st.s2hdi - 2 >= s2sz
+        ns2sz = s2sz - st.s2hdi + 1
+        copyto!(st.s2, 1, st.s2, st.s2hdi, ns2sz)
+        resize!(st.s2, ns2sz); st.s2hdi = 1
+    end
+    rslt = @inbounds(st.s2[st.s2hdi])
+    if rslt.lg < st.mrg.lg
+        st.s2hdi += 1
+    else
+        s3sz = length(st.s3)
+        if st.s3hdi + st.s3hdi - 2 >= s3sz
+            ns3sz = s3sz - st.s3hdi + 1
+            copyto!(st.s3, 1, st.s3, st.s3hdi, ns3sz)
+            resize!(st.s3, ns3sz); st.s3hdi = 1
+        end
+        rslt = st.mrg; push!(st.s3, mult3(rslt))
+        st.s3hdi += 1; chkv = @inbounds(st.s3[st.s3hdi])
+        if chkv.lg < st.s5.lg
+            st.mrg = chkv
+        else
+            st.mrg = st.s5; st.s5 = mult5(st.s5); st.s3hdi -= 1
+        end
+    end
+    push!(st.s2, mult2(rslt)); rslt, st
+end
+
+function test(n :: Int) :: Tuple{LogRep, Float64}
+    start = time(); rslt :: LogRep = ONE
+    count = n; for t in HammingsLog() count <= 1 && (rslt = t; break); count -= 1 end
+    elpsd = (time() - start) * 1000
+    rslt, elpsd
+end
+
+foreach(x -> print(lr2BigInt(x)," "), (Iterators.take(HammingsLog(), 20))); println()
+let count = 1691; for t in HammingsLog() count <= 1 && (println(lr2BigInt(t)); break); count -= 1 end end
+rslt, elpsd = test(1000000)
+println(lr2BigInt(rslt))
+println("This last took $elpsd milliseconds.")

Task/Hamming-numbers/Julia/hamming-numbers-4.julia

@@ -0,0 +1,41 @@
+function nthhamming(n :: UInt64) # :: Tuple{UInt32, UInt32, UInt32}
+    # take care of trivial cases too small for band size estimation to work...
+    n < 1 && throw("nthhamming:  argument must be greater than zero!!!")
+    n < 2 && return (0, 0, 0)
+    n < 3 && return (1, 0, 0)
+
+    # some constants...
+    log2of2, log2of3, log2of5 = 1.0, log(2, 3), log(2, 5)
+    fctr, crctn = 6.0 * log2of3 * log2of5, log(2, sqrt(30))
+    log2est = (fctr * Float64(n))^(1.0 / 3.0) - crctn # log2 answer from WP formula
+    log2hi = log2est + 1.0 / log2est; width = 2.0 / log2est # up to 2X higher/lower
+
+    # loop to find the count of regular numbers and band of possible candidates...
+    count :: UInt64 = 0; band = Vector{Tuple{Float64,Tuple{UInt32,UInt32,UInt32}}}()
+    fiveslmt = UInt32(ceil(log2hi / log2of5)); fives :: UInt32 = 0
+    while fives < fiveslmt
+        log2p = log2hi - fives * log2of5
+        threeslmt = UInt32(ceil(log2p / log2of3)); threes :: UInt32 = 0
+        while threes < threeslmt
+            log2q = log2p - threes * log2of3
+            twos = UInt32(floor(log2q)); frac = log2q - twos; count += twos + 1
+            frac <= width && push!(band, (log2hi - frac, (twos, threes, fives)))
+            threes += 1
+        end
+        fives += 1
+    end
+
+    # process the band found including checks for validity and range...
+    n > count && throw("nthhamming:  band high estimate is too low!!!")
+    ndx = count - n + 1
+    ndx > length(band) && throw("nthhamming:  band width estimate is too narrow!!!")
+    sort!(band, by=(tpl -> let (lg,_) = tpl; -lg end)) # sort in decending order
+
+    # get and return the answer...
+    _, tri = band[ndx]
+    tri
+end
+
+foreach(x-> print(trival(nthhamming(UInt(x))), " "), 1:20); println()
+println(trival(nthhamming(UInt64(1691))))
+println(trival(nthhamming(UInt64(1000000))))

Task/Hamming-numbers/Julia/hamming-numbers-5.julia

@@ -0,0 +1,45 @@
+function nthhamming(n :: UInt64) # :: Tuple{UInt32, UInt32, UInt32}
+    # take care of trivial cases too small for band size estimation to work...
+    n < 1 && throw("nthhamming:  argument must be greater than zero!!!")
+    n < 2 && return (0, 0, 0)
+    n < 3 && return (1, 0, 0)
+
+    # some constants...
+    log2of2, log2of3, log2of5 = 1.0, log(2, 3), log(2, 5)
+    fctr, crctn = 6.0 * log2of3 * log2of5, log(2, sqrt(30))
+    log2est = (fctr * Float64(n))^(1.0 / 3.0) - crctn # log2 answer from WP formula
+    log2hi = log2est + 1.0 / log2est; width = 2.0 / log2est # up to 2X higher/lower
+
+    # some really really big constants representing the "roll-your-own" big logs...
+    biglog2of2 = BigInt(1267650600228229401496703205376)
+    biglog2of3 = BigInt(2009178665378409109047848542368)
+    biglog2of5 = BigInt(2943393543170754072109742145491)
+
+    # loop to find the count of regular numbers and band of possible candidates...
+    count :: UInt64 = 0; band = Vector{Tuple{BigInt,Tuple{UInt32,UInt32,UInt32}}}()
+    fiveslmt = UInt32(ceil(log2hi / log2of5)); fives :: UInt32 = 0
+    while fives < fiveslmt
+        log2p = log2hi - fives * log2of5
+        threeslmt = UInt32(ceil(log2p / log2of3)); threes :: UInt32 = 0
+        while threes < threeslmt
+            log2q = log2p - threes * log2of3
+            twos = UInt32(floor(log2q)); frac = log2q - twos; count += twos + 1
+            if frac <= width
+                biglog = biglog2of2 * twos + biglog2of3 * threes + biglog2of5 * fives
+                push!(band, (biglog, (twos, threes, fives)))
+            end
+            threes += 1
+        end
+        fives += 1
+    end
+
+    # process the band found including checks for validity and range...
+    n > count && throw("nthhamming:  band high estimate is too low!!!")
+    ndx = count - n + 1
+    ndx > length(band) && throw("nthhamming:  band width estimate is too narrow!!!")
+    sort!(band, by=(tpl -> let (lg,_) = tpl; -lg end)) # sort in decending order
+
+    # get and return the answer...
+    _, tri = band[ndx]
+    tri
+end