Skip to content

Commit

Permalink
Add precompilation statements
Browse files Browse the repository at this point in the history
  • Loading branch information
@Liozou
Liozou committed May 27, 2022
1 parent d67eb9a commit 0fea183
Show file tree
Hide file tree
Showing 5 changed files with 167 additions and 53 deletions.
4 changes: 2 additions & 2 deletions src/PeriodicGraphEmbeddings.jl
View file
Original file line number Diff line number Diff line change
@@ -1,9 +1,9 @@
"""
PeriodicGraphEmbeddings
A module for embeddings of periodic graphs in euclidean space.
A module for manipulating embeddings of periodic graphs in euclidean space.
Symmetry properties are provied on graphs up to dimension 3 through
Symmetry properties are provided on graphs up to dimension 3 through
[spglib](https://spglib.github.io/spglib/).
"""
module PeriodicGraphEmbeddings
Expand Down
2 changes: 1 addition & 1 deletion src/other.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -13,4 +13,4 @@ function PeriodicGraphs.swap_axes!(pge::PeriodicGraphEmbedding{N}, t) where N
for (i,x) in enumerate(pge.pos)
pge.pos[i] = x[t]
end
end
end
187 changes: 150 additions & 37 deletions src/precompile.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,59 +6,172 @@ end
function _precompile_()
ccall(:jl_generating_output, Cint, ()) == 1 || return nothing

# utils.jl
@enforce precompile(Tuple{typeof(prepare_periodic_distance_computations), Matrix{Float64}})
@enforce precompile(Tuple{typeof(prepare_periodic_distance_computations), SMatrix{3,3,Float64,9}})
@enforce precompile(Tuple{typeof(periodic_distance!), MVector{3,Float64}, SVector{3,Float64}, Matrix{Float64}, Bool, Float64})
@enforce precompile(Tuple{typeof(periodic_distance!), MVector{3,Float64}, SVector{3,Float64}, SMatrix{3,3,Float64,9}, Bool, Float64})
@enforce precompile(Tuple{typeof(periodic_distance!), MVector{3,Float64}, MVector{3,Float64}, Matrix{Float64}, Bool, Float64})
@enforce precompile(Tuple{typeof(periodic_distance!), MVector{3,Float64}, MVector{3,Float64}, SMatrix{3,3,Float64,9}, Bool, Float64})
@enforce precompile(Tuple{typeof(periodic_distance!), MVector{3,Float64}, Matrix{Float64}, Bool, Float64})
@enforce precompile(Tuple{typeof(periodic_distance!), MVector{3,Float64}, SMatrix{3,3,Float64,9}, Bool, Float64})
@enforce precompile(Tuple{typeof(periodic_distance), SVector{3,Float64}, Matrix{Float64}, Bool, Float64})
@enforce precompile(Tuple{typeof(periodic_distance), SVector{3,Float64}, Matrix{Float64}, Nothing, Nothing})
@enforce precompile(Tuple{typeof(periodic_distance), SVector{3,Float64}, Matrix{Float64}})
@enforce precompile(Tuple{typeof(periodic_distance), SVector{3,Float64}, SMatrix{3,3,Float64,9}, Bool, Float64})
@enforce precompile(Tuple{typeof(periodic_distance), SVector{3,Float64}, SMatrix{3,3,Float64,9}, Nothing, Nothing})
@enforce precompile(Tuple{typeof(periodic_distance), SVector{3,Float64}, SMatrix{3,3,Float64,9}})

# types.jl
@enforce precompile(Tuple{Type{EquivalentPosition}, SMatrix{3,3,Int,9}, SVector{3,Rational{Int}}})
@enforce precompile(Tuple{Type{EquivalentPosition}, SMatrix{3,3,Int,9}, SVector{3,Float64}})
@enforce precompile(Tuple{typeof(Base.deepcopy_internal),Vector{EquivalentPosition{T}},IdDict{Any, Any}})
@enforce precompile(Tuple{typeof(find_refid), Vector{String}})
@enforce precompile(Tuple{typeof(parse), Type{EquivalentPosition{T}}, String, NTuple{3,String}})
@enforce precompile(Tuple{typeof(PeriodicGraphEmbeddings.rationaltostring), Int, Bool, Bool})
@enforce precompile(Tuple{typeof(show), Base.TTY, EquivalentPosition{T}})
@enforce precompile(Tuple{typeof(show), Base.IOStream, EquivalentPosition{T}})
@enforce precompile(Tuple{Type{cell}, Int, mat, Vector{EquivalentPosition{Rational{Int}}}})
@enforce precompile(Tuple{Type{cell}, Int, Matrix{BigFloat}, Vector{EquivalentPosition{Rational{Int}}}})
@enforce precompile(Tuple{typeof(==), cell, cell})
@enforce precompile(Tuple{Type{cell}, Int, NTuple{3,BigFloat}, NTuple{3,BigFloat}, Vector{EquivalentPosition{Rational{Int}}}})
@enforce precompile(Tuple{Type{cell}, Int, NTuple{3,Int}, NTuple{3,Int}, Vector{EquivalentPosition{Rational{Int}}}})
@enforce precompile(Tuple{Type{cell}})
@enforce precompile(Tuple{typeof(cell_parameters), mat})
@enforce precompile(Tuple{typeof(cell_parameters), fmat})
@enforce precompile(Tuple{typeof(cell_parameters), cell})
@enforce precompile(Tuple{Type{cell}, mat})
@enforce precompile(Tuple{Type{cell}, fmat})
@enforce precompile(Tuple{typeof(show), Base.TTY, cell})
@enforce precompile(Tuple{typeof(show), Base.IOStream, cell})
@enforce precompile(Tuple{typeof(show), Base.TTY, MIME"text/plain", cell})
@enforce precompile(Tuple{typeof(show), Base.IOStream, MIME"text/plain", cell})
@enforce precompile(Tuple{typeof(prepare_periodic_distance_computations), mat})
@enforce precompile(Tuple{typeof(prepare_periodic_distance_computations), fmat})
@enforce precompile(Tuple{typeof(periodic_distance!), MVector{3,Float64}, _pos, fmat, Bool, Float64})
@enforce precompile(Tuple{typeof(periodic_distance!), MVector{3,Float64}, fmat, Bool, Float64})
@enforce precompile(Tuple{typeof(cell_parameters), SMatrix{3,3,BigFloat,9}})
for T in (Float64,Float32,Rational{Int})
@enforce precompile(Tuple{Type{EquivalentPosition{T}}})
@enforce precompile(Tuple{EquivalentPosition{T}, SMatrix{3,3,Int,9}})
@enforce precompile(Tuple{EquivalentPosition{T}, SVector{3,Float64}})
@enforce precompile(Tuple{EquivalentPosition{T}, SVector{3,Rational{Int}}})
@enforce precompile(Tuple{typeof(Base.deepcopy_internal),Vector{EquivalentPosition{T}},IdDict{Any, Any}})
end
@enforce precompile(Tuple{typeof(parse), Type{EquivalentPosition}, String, NTuple{3,String}})
@enforce precompile(Tuple{typeof(parse), Type{EquivalentPosition}, String})
for T in (Float64,Float32,Rational{Int})
@enforce precompile(Tuple{typeof(PeriodicGraphEmbeddings.__tostring), T, Bool, Bool})
@enforce precompile(Tuple{typeof(show), Base.TTY, EquivalentPosition{T}})
@enforce precompile(Tuple{typeof(show), Base.IOStream, EquivalentPosition{T}})
@enforce precompile(Tuple{Type{Cell{T}}, Int, Matrix{BigFloat}, Vector{EquivalentPosition{T}}})
@enforce precompile(Tuple{Type{Cell}, Int, Matrix{BigFloat}, Vector{EquivalentPosition{T}}})
@enforce precompile(Tuple{Type{Cell}, Int, SMatrix{3,3,T,9}, Vector{EquivalentPosition{T}}})
@enforce precompile(Tuple{Type{Cell}, Int, SMatrix{3,3,BigFloat,9}, Vector{EquivalentPosition{T}}})
@enforce precompile(Tuple{typeof(cell_parameters), Cell{T}})
@enforce precompile(Tuple{typeof(==), Cell{T}, Cell{T}})
@enforce precompile(Tuple{Type{Cell{T}}, Int, NTuple{3,BigFloat}, NTuple{3,BigFloat}, Vector{EquivalentPosition{T}}})
@enforce precompile(Tuple{Type{Cell{T}}, Int, NTuple{3,Int}, NTuple{3,Int}, Vector{EquivalentPosition{T}}})
@enforce precompile(Tuple{Type{Cell}, Int, NTuple{3,BigFloat}, NTuple{3,BigFloat}, Vector{EquivalentPosition{T}}})
@enforce precompile(Tuple{Type{Cell}, Int, NTuple{3,Int}, NTuple{3,Int}, Vector{EquivalentPosition{T}}})
@enforce precompile(Tuple{Type{Cell{T}}, Int, NTuple{3,BigFloat}, NTuple{3,BigFloat}})
@enforce precompile(Tuple{Type{Cell{T}}, Int, NTuple{3,Int}, NTuple{3,Int}})
@enforce precompile(Tuple{Type{Cell{T}}})
@enforce precompile(Tuple{Type{Cell}, Cell{T}, SMatrix{3,3,BigFloat,9}})
@enforce precompile(Tuple{Type{Cell{T}}, SMatrix{3,3,BigFloat,9}})
@enforce precompile(Tuple{typeof(show), Base.TTY, Cell{T}})
@enforce precompile(Tuple{typeof(show), Base.IOStream, Cell{T}})
@enforce precompile(Tuple{typeof(show), Base.TTY, MIME"text/plain", Cell{T}})
@enforce precompile(Tuple{typeof(show), Base.IOStream, MIME"text/plain", Cell{T}})
end
@enforce precompile(Tuple{Type{Cell}, Int, NTuple{3,BigFloat}, NTuple{3,BigFloat}})
@enforce precompile(Tuple{Type{Cell}})
@enforce precompile(Tuple{Type{Cell}, SMatrix{3,3,BigFloat,9}})

cell = Cell{Rational{Int}}
for T in (Float32, Float64, Rational{Int32}, Rational{Int64}, Rational{Int128}, Rational{BigInt})
for D in 0:3
@enforce precompile(Tuple{Type{PeriodicGraphEmbedding{D,T}}, PeriodicGraph{D}, Vector{SVector{D,T}}, cell})
@enforce precompile(Tuple{typeof(==), PeriodicGraphEmbedding{D,T}, PeriodicGraphEmbedding{D,T}})
@enforce precompile(Tuple{Type{PeriodicGraphEmbedding{D,T}}, PeriodicGraph{D}, Vector{SVector{D,T}}})
@enforce precompile(Tuple{Type{PeriodicGraphEmbedding{D}}, PeriodicGraph{D}, Vector{SVector{D,T}}, cell})
@enforce precompile(Tuple{Type{PeriodicGraphEmbedding}, PeriodicGraph{D}, Vector{SVector{D,T}}, cell})
@enforce precompile(Tuple{Type{PeriodicGraphEmbedding{D,T}}, cell})
@enforce precompile(Tuple{typeof(PeriodicGraphEmbeddings.return_to_box), PeriodicGraph{D}, Matrix{T}})
@enforce precompile(Tuple{Type{PeriodicGraphEmbedding{D,T}}, PeriodicGraph{D}, Matrix{T}, cell})
@enforce precompile(Tuple{typeof(sort_periodicgraphembedding!), PeriodicGraph{D}, Matrix{T}, cell})
@enforce precompile(Tuple{typeof(sort_periodicgraphembedding!), PeriodicGraph{D}, Matrix{T}})
@enforce precompile(Tuple{typeof(getindex), PeriodicGraphEmbedding{D,T}, Int})
@enforce precompile(Tuple{typeof(getindex), PeriodicGraphEmbedding{D,T}, PeriodicVertex{D}})
@enforce precompile(Tuple{typeof(length), PeriodicGraphEmbedding{D,T}})
@enforce precompile(Tuple{typeof(getindex), PeriodicGraphEmbedding{D,T}, Vector{Int}})
for N in 0:3
for S in (Float32, Float64, Rational{Int32}, Rational{Int64}, Rational{Int128}, Rational{BigInt})
@enforce precompile(Tuple{Type{PeriodicGraphEmbedding{D,T}}, PeriodicGraphEmbedding{N,S}})
end
@enforce precompile(Tuple{Type{PeriodicGraphEmbedding{D}}, PeriodicGraphEmbedding{N,T}})
end
end
end

for T in (Float64,Float32,Rational{Int})
@enforce precompile(Tuple{typeof(getindex), Type{PeriodicSymmetry3D{T}}, Int})
@enforce precompile(Tuple{typeof(getindex), Type{PeriodicSymmetry3D{T}}, PeriodicVertex3D})
for S in (Float64,Float32,Rational{Int},Int)
@enforce precompile(Tuple{PeriodicSymmetry3D{T}, Vector{S}})
@enforce precompile(Tuple{PeriodicSymmetry3D{T}, SMatrix{3,3,S,9}})
@enforce precompile(Tuple{PeriodicSymmetry3D{T}, Matrix{T}})
end
@enforce precompile(Tuple{SymmetryGroup3D{T}, Int})
@enforce precompile(Tuple{typeof(unique), SymmetryGroup3D{T}})
@enforce precompile(Tuple{typeof(getindex), SymmetryGroup3D{T}, Int})
@enforce precompile(Tuple{typeof(iterate), SymmetryGroup3D{T}, Int})
@enforce precompile(Tuple{typeof(iterate), SymmetryGroup3D{T}})
@enforce precompile(Tuple{typeof(length), SymmetryGroup3D{T}})
@enforce precompile(Tuple{typeof(one), SymmetryGroup3D{T}})
@enforce precompile(Tuple{Type{SymmetryGroup3D}, Vector{Vector{PeriodicVertex3D}}, Vector{EquivalentPosition{T}}, Bool, Int})
@enforce precompile(Tuple{Type{SymmetryGroup3D{T}}, Vector{Vector{PeriodicVertex3D}}, Vector{SMatrix{3,3,Int,9}}, Vector{SVector{3,T}}, Bool, Int})
end

# other.jl
for D in 1:3
for T in (Float64,Float32,Rational{Int})
@enforce precompile(Tuple{typeof(PeriodicGraphs.offset_representatives!), PeriodicGraphEmbedding{D,T}, Vector{SVector{D,Int}}})
@enforce precompile(Tuple{typeof(PeriodicGraphs.swap_axes!), PeriodicGraphEmbedding{D,T}, SVector{D,Int}})
@enforce precompile(Tuple{typeof(PeriodicGraphs.swap_axes!), PeriodicGraphEmbedding{D,T}, NTuple{D,Int}})
@enforce precompile(Tuple{typeof(PeriodicGraphs.swap_axes!), PeriodicGraphEmbedding{D,T}, Vector{Int}})
end
end

# symmetries.jl
@enforce precompile(Tuple{typeof(PeriodicGraphEmbeddings.joinletters), NTuple{11,Cchar}})
@enforce precompile(Tuple{typeof(PeriodicGraphEmbeddings.joinletters), NTuple{17,Cchar}})
@enforce precompile(Tuple{typeof(PeriodicGraphEmbeddings.joinletters), NTuple{6,Cchar}})
@enforce precompile(Tuple{typeof(PeriodicGraphEmbeddings.joinletters), NTuple{7,Cchar}})
@enforce precompile(Tuple{typeof(getproperty), PeriodicGraphEmbeddings.SpglibDataset, Symbol})
@enforce precompile(Tuple{typeof(find_hall_number), String, String, String})
@enforce precompile(Tuple{typeof(find_hall_number), String, String, Int, Bool})
@enforce precompile(Tuple{typeof(find_hall_number), String, String, Int})
@enforce precompile(Tuple{typeof(find_hall_number), String, String})
@enforce precompile(Tuple{typeof(find_hall_number), String})
@enforce precompile(Tuple{typeof(get_symmetry_equivalents), Rational{Int}, Int})
@enforce precompile(Tuple{typeof(get_symmetry_equivalents), Float64, Int})
@enforce precompile(Tuple{typeof(get_symmetry_equivalents), Float32, Int})
@enforce precompile(Tuple{typeof(get_symmetry_equivalents), Int})
for T in inttypes
@enforce precompile(Tuple{typeof(PeriodicGraphEmbeddings.get_spglib_dataset), cnet{3,T}})
@enforce precompile(Tuple{typeof(find_symmetries), cnet{3,T}, collisions})
for T in (Float32, Float64, Rational{Int32}, Rational{Int64}, Rational{Int128}, Rational{BigInt})
@enforce precompile(Tuple{typeof(PeriodicGraphEmbeddings.get_spglib_dataset), PeriodicGraphEmbedding3D{T}, Nothing})
@enforce precompile(Tuple{typeof(PeriodicGraphEmbeddings.get_spglib_dataset), PeriodicGraphEmbedding3D{T}})
@enforce precompile(Tuple{typeof(PeriodicGraphEmbeddings.get_spglib_dataset), PeriodicGraphEmbedding3D{T}, Vector{Int}})
@enforce precompile(Tuple{typeof(PeriodicGraphEmbeddings.get_spglib_dataset), PeriodicGraphEmbedding3D{T}, Vector{Symbol}})
@enforce precompile(Tuple{typeof(check_valid_symmetry), PeriodicGraphEmbedding3D{T}, SVector{3,T}, Nothing, Nothing, Bool})
@enforce precompile(Tuple{typeof(check_valid_symmetry), PeriodicGraphEmbedding3D{T}, SVector{3,T}, Nothing, Nothing})
@enforce precompile(Tuple{typeof(check_valid_symmetry), PeriodicGraphEmbedding3D{T}, SVector{3,T}, Nothing})
@enforce precompile(Tuple{typeof(check_valid_symmetry), PeriodicGraphEmbedding3D{T}, SVector{3,T}})
@enforce precompile(Tuple{typeof(check_valid_symmetry), PeriodicGraphEmbedding3D{T}, SVector{3,T}, SMatrix{3,3,Int,9}})
@enforce precompile(Tuple{typeof(check_valid_symmetry), PeriodicGraphEmbedding3D{T}, SVector{3,T}, SMatrix{3,3,Int,9}, Vector{Symbol}})
@enforce precompile(Tuple{typeof(check_valid_symmetry), PeriodicGraphEmbedding3D{T}, SVector{3,T}, Nothing, Vector{Symbol}})
@enforce precompile(Tuple{typeof(find_symmetries), PeriodicGraphEmbedding3D{T}, Nothing, typeof(check_valid_symmetry)})
@enforce precompile(Tuple{typeof(find_symmetries), PeriodicGraphEmbedding3D{T}, Nothing})
@enforce precompile(Tuple{typeof(find_symmetries), PeriodicGraphEmbedding3D{T}})
@enforce precompile(Tuple{typeof(find_symmetries), PeriodicGraphEmbedding3D{T}, Vector{Symbol}, typeof(check_valid_symmetry)})
@enforce precompile(Tuple{typeof(find_symmetries), PeriodicGraphEmbedding3D{T}, Vector{Symbol}})
end

# topology.jl (TOCHANGE)
@enforce precompile(Tuple{typeof(check_valid_symmetry), cnet{D,T}, pos{D,T}, Vector{collision}, Nothing})
@enforce precompile(Tuple{typeof(check_valid_symmetry), cnet{D,T}, pos{D,T}, Vector{collision}})


# io (TOCHANGE)
@enforce @enforce precompile(Tuple{typeof(export_vtf), String, crystclust})
@enforce @enforce precompile(Tuple{typeof(export_cgd), String, crystclust})
# io.jl
for T in (Float32, Float64, Rational{Int32}, Rational{Int64}, Rational{Int128}, Rational{BigInt})
@enforce precompile(Tuple{typeof(export_vtf), String, PeriodicGraphEmbedding3D{T}, Nothing, Int, Bool})
@enforce precompile(Tuple{typeof(export_vtf), String, PeriodicGraphEmbedding3D{T}, Nothing, Int})
@enforce precompile(Tuple{typeof(export_vtf), String, PeriodicGraphEmbedding3D{T}, Nothing})
@enforce precompile(Tuple{typeof(export_vtf), String, PeriodicGraphEmbedding3D{T}, Vector{Symbol}, Int, Bool})
@enforce precompile(Tuple{typeof(export_vtf), String, PeriodicGraphEmbedding3D{T}, Vector{Symbol}, Int})
@enforce precompile(Tuple{typeof(export_vtf), String, PeriodicGraphEmbedding3D{T}, Vector{Symbol}})
@enforce precompile(Tuple{typeof(export_vtf), String, PeriodicGraphEmbedding3D{T}})
for D in 0:3
@enforce precompile(Tuple{typeof(export_cgd), String, PeriodicGraphEmbedding{D,T}, String, Bool})
@enforce precompile(Tuple{typeof(export_cgd), String, PeriodicGraphEmbedding{D,T}, String})
@enforce precompile(Tuple{typeof(export_cgd), String, PeriodicGraphEmbedding{D,T}})
end
end
for D in 0:3
@enforce precompile(Tuple{typeof(export_cgd), String, PeriodicGraph{D}, String, Bool})
@enforce precompile(Tuple{typeof(export_cgd), String, PeriodicGraph{D}, String})
@enforce precompile(Tuple{typeof(export_cgd), String, PeriodicGraph{D}})
end
end

#_precompile_()
_precompile_()
25 changes: 13 additions & 12 deletions src/types.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -217,15 +217,6 @@ struct Cell{T}
end
end

function ==(cell1::Cell, cell2::Cell)
cell1.hall == cell2.hall || return false
cell1.mat == cell2.mat && return true
istriu(cell1.mat) && istriu(cell2.mat) && return false
(a1, b1, c1), (α1, β1, γ1) = cell_parameters(cell1.mat)
(a2, b2, c2), (α2, β2, γ2) = cell_parameters(cell2.mat)
return Float32.((a1, b1, c1, α1, β1, γ1)) == Float32.((a2, b2, c2, α2, β2, γ2))
end

function Cell{T}(hall, (a, b, c), (α, β, γ), eqs=EquivalentPosition{T}[]) where T
cosα = cosd(α); cosβ = cosd(β); cosγ = cosd(γ); sinγ = sind(γ)
ω = sqrt(1 - cosα^2 - cosβ^2 - cosγ^2 + 2*cosα*cosβ*cosγ)
Expand All @@ -242,6 +233,10 @@ Cell(hall, vecs, angs, eqs=EquivalentPosition{Rational{Int}}[]) = Cell{Rational{
Cell{T}() where {T} = Cell(1, (10, 10, 10), (90, 90, 90), EquivalentPosition{T}[])
Cell() = Cell{Rational{Int}}()

Cell(cell::Cell{T}, mat::StaticArray{Tuple{3,3},BigFloat}) where {T} = Cell{T}(cell.hall, mat, cell.equivalents)
Cell{T}(mat::StaticArray{Tuple{3,3},BigFloat}) where {T} = Cell(Cell{T}(), mat)
Cell(mat::StaticArray{Tuple{3,3},BigFloat}) = Cell{Rational{Int}}(mat)

function cell_parameters(mat::AbstractMatrix)
_a, _b, _c = eachcol(mat)
a = norm(_a)
Expand All @@ -267,9 +262,15 @@ function cell_parameters(cell::Cell)
return (lengths, angles), normalized_mat
end

Cell(cell::Cell{T}, mat::StaticArray{Tuple{3,3},BigFloat}) where {T} = Cell{T}(cell.hall, mat, cell.equivalents)
Cell{T}(mat::StaticArray{Tuple{3,3},BigFloat}) where {T} = Cell(Cell{T}(), mat)
Cell(mat::StaticArray{Tuple{3,3},BigFloat}) = Cell{Rational{Int}}(mat)
function ==(cell1::Cell, cell2::Cell)
cell1.hall == cell2.hall || return false
cell1.mat == cell2.mat && return true
istriu(cell1.mat) && istriu(cell2.mat) && return false
(a1, b1, c1), (α1, β1, γ1) = cell_parameters(cell1.mat)
(a2, b2, c2), (α2, β2, γ2) = cell_parameters(cell2.mat)
return Float32.((a1, b1, c1, α1, β1, γ1)) == Float32.((a2, b2, c2, α2, β2, γ2))
end


function Base.show(io::IO, cell::Cell)
((__a, __b, __c), (__α, __β, __γ)), _ = cell_parameters(cell)
Expand Down
2 changes: 1 addition & 1 deletion src/utils.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -66,7 +66,7 @@ This implementation assumes that the cell corresponds to a reduced lattice. It m
invalid for some edge cases otherwise.
For optimal performance, use `periodic_distance!` with `buffer`, `ortho` and `safemin`
obtained from `PeriodicGraphEmbeddings.prepare_periodic_distance_computations`.
obtained from `prepare_periodic_distance_computations`.
"""
function periodic_distance(u, mat, ortho=nothing, safemin=nothing)
if ortho === nothing || safemin === nothing
Expand Down

2 comments on commit 0fea183

@Liozou
Copy link
Owner Author

@Liozou Liozou commented on 0fea183 May 27, 2022

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@JuliaRegistrator register

@JuliaRegistrator
Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Registration pull request created: JuliaRegistries/General/61188

After the above pull request is merged, it is recommended that a tag is created on this repository for the registered package version.

This will be done automatically if the Julia TagBot GitHub Action is installed, or can be done manually through the github interface, or via:

git tag -a v0.1.0 -m "<description of version>" 0fea1835457c9a3906c8f65a63f9f710719f2c3c
git push origin v0.1.0

Please sign in to comment.