...

julia/CubeShapeCounting.jl

@@ -1,6 +1,117 @@
+include("Shape.jl")
 include("ImmutableOrientedShape.jl")
+include("Powerset.jl")
+include("TupleMisc.jl")
+include("plot.jl")
+using XXhash
+using Serialization
+using DataStructures
+using ArgParse
 
-function main(i::Int64)
-    D = Dict{ImmutableOrientedShape}()
-    S = Stack{Int64}();
+function main()
+    s = ArgParseSettings()
+    @add_arg_table s begin
+        "-g"
+            help = "generator"
+            arg_type = Int
+        "-l"
+            help = "list"
+            action = :store_true
+        "-p"
+            help = "plot n_cubes i_shape"
+            nargs = '+'
+            arg_type = Int
+    end
+
+    parsed_args = parse_args(s)
+
+    generate = get(parsed_args, "g", nothing)
+    if generate !== nothing && generate > 0
+        scanForShapes(generate)
+    end
+    if get(parsed_args, "l", false)
+        listShapes()
+    end
+    plot = get(parsed_args, "p", nothing)
+    if length(plot) == 1
+        plotShapes(plot)
+    elseif length(plot) == 2
+        plotShape(plot)
+    end
 end
+
+function scanForShapes(MaxSize::Int64)
+    D = Dict{UInt, ImmutableOrientedShape}()
+    S = Stack{Shape}();
+    cube = getCube()
+    immutableCube = getImmutableOrientedShape(cube)
+    D[immutableCube.hash] = immutableCube
+    push!(S, cube)
+
+    while !isempty(S)
+        cube = pop!(S)
+        growableSpaces = collect(getPossibleNeighbors(cube))
+        acceptable_growth = MaxSize - length(cube.cubes)
+        for i ∈ 1:acceptable_growth
+            possibleGrowth = Powerset.getPowerSubSet(length(growableSpaces), i)
+            for j ∈ axes(possibleGrowth, 1)
+                cubesToAdd = growableSpaces[possibleGrowth[j, :]]
+                newShape = deepcopy(cube)
+                for c ∈ cubesToAdd
+                    push!(newShape, c)
+                end
+                collision = checkForCollision(newShape, D)
+                if !collision
+                    push!(S, newShape)
+                    immutableNewShape = getImmutableOrientedShape(newShape)
+                    D[immutableNewShape.hash] = immutableNewShape
+                end
+            end
+        end
+    end
+    sanitizedData = sanitize(D, MaxSize)
+    serialize("results.bin", sanitizedData)
+end
+
+function listShapes()
+    T = deserialize("results.bin")
+    print("size: ")
+    println(T[1])
+    for V ∈ T[2]
+        for v ∈ V
+            println(v)
+        end
+    end
+end
+
+function checkForCollision(S::Shape, D::Dict{UInt, ImmutableOrientedShape})
+    for i ∈ 1:24
+        hash = hashList(S.orderedLists[i])
+        value = get(D, hash, nothing)
+        if value !== nothing && hash == value.hash
+            return true
+        end
+    end
+    return false
+end
+
+function hashList(L::Vector{Tuple{Int64, Int64, Int64}})
+    diffList = Vector{Tuple{Int64, Int64, Int64}}(undef, length(L)-1)
+    for i ∈ eachindex(diffList)
+        diffList[i] = L[i+1] - L[i]
+    end
+    return xxh3_64(diffList)
+end
+
+function sanitize(D::Dict{UInt, ImmutableOrientedShape}, size::Int64)
+    data = Vector{Vector{Vector{Tuple{Int64, Int64, Int64}}}}(undef, size)
+    for i ∈ eachindex(data)
+        data[i] = Vector{Vector{Tuple{Int64, Int64, Int64}}}(undef, 0)
+    end
+    for (K, V) ∈ D
+        push!(data[length(V.cubes)], V.cubes)
+    end
+    return (size, data)
+end
+
+main()