chakravala / Grassmann.jl

@@ -343,6 +343,12 @@
Loading
343 343
    return x,y,xy
344 344
end
345 345
346 +
DirectSum.Λ(x::Chain{V,1,<:Chain{V,1}},G) where V = compound(x,G)
347 +
compound(x,G::T) where T<:Integer = compound(x,Val(G))
348 +
@generated function compound(x::Chain{V,1,<:Chain{V,1}},::Val{G}) where {V,G}
349 +
    Expr(:call,:(Chain{V,G}),Expr(:call,:Values,[Expr(:call,:∧,[:(x[$i]) for i ∈ indices(j)]...) for j ∈ indexbasis(mdims(V),G)]...))
350 +
end
351 +
346 352
@generated function Base.:\(t::Values{M,<:Chain{V,1}},v::Chain{V,1}) where {M,V}
347 353
    W = M≠mdims(V) ? SubManifold(M) : V; N = M-1
348 354
    if M == 1 && (V === ℝ1 || V == 1)

@@ -222,10 +222,30 @@
Loading
222 222
contraction(a::Proj{W,<:Chain{W,1,<:TensorNested{V}}},b::Chain{V,1}) where {W,V} = a.v:b
223 223
contraction(a::Chain{W},b::Chain{V,G,<:Chain}) where {W,G,V} = Chain{V,G}(column(Ref(a).⋅value(b)))
224 224
contraction(a::Chain{W,L,<:Chain},b::Chain{V,G,<:Chain{W,L}}) where {W,L,G,V} = Chain{V,G}(column(Ref(a).⋅value(b)))
225 +
contraction(a::MultiVector{W,<:MultiVector},b::MultiVector{V,<:MultiVector{W}}) where {W,V} = MultiVector{V}(column(Ref(a).⋅value(b)))
225 226
Base.:(:)(a::Chain{V,1,<:Chain},b::Chain{V,1,<:Chain}) where V = sum(value(a).⋅value(b))
226 227
Base.:(:)(a::Chain{W,1,<:Dyadic{V}},b::Chain{V,1}) where {W,V} = sum(value(a).⋅Ref(b))
227 228
#Base.:(:)(a::Chain{W,1,<:Proj{V}},b::Chain{V,1}) where {W,V} = sum(broadcast(⋅,value(a),Ref(b)))
228 229
230 +
contraction(a::SubManifold{W},b::Chain{V,G,<:Chain}) where {W,G,V} = Chain{V,G}(column(Ref(a).⋅value(b)))
231 +
contraction(a::Simplex{W},b::Chain{V,G,<:Chain}) where {W,G,V} = Chain{V,G}(column(Ref(a).⋅value(b)))
232 +
contraction(x::Chain{V,G,<:Chain},y::Simplex{V,G}) where {V,G} = value(y)*x[bladeindex(mdims(V),UInt(basis(y)))]
233 +
contraction(x::Chain{V,G,<:Chain},y::SubManifold{V,G}) where {V,G} = x[bladeindex(mdims(V),UInt(y))]
234 +
#contraction(a::Chain{V,G,<:Chain{V,G}},b::Chain{V,G,<:Chain{V,G}}) where {V,G} = Chain{V,G}(Ref(a).⋅value(b))
235 +
contraction(x::Chain{W,L,<:Chain{V,G},N},y::Chain{V,G,T,N}) where {W,L,N,V,G,T} = Chain{V,G}(matmul(value(x),value(y)))
236 +
contraction(x::Chain{W,L,<:MultiVector{V},N},y::Chain{V,G,T,N}) where {W,L,N,V,G,T} = MultiVector{V}(matmul(value(x),value(y)))
237 +
contraction(x::MultiVector{W,<:Chain{V,G},N},y::MultiVector{V,T,N}) where {W,N,V,G,T} = Chain{V,G}(matmul(value(x),value(y)))
238 +
contraction(x::MultiVector{W,<:MultiVector{V},N},y::MultiVector{V,T,N}) where {W,N,V,T} = MultiVector{V}(matmul(value(x),value(y)))
239 +
@inline @generated function matmul(x::Values{N,<:Simplex{V,G}},y::Values{N}) where {N,V,G}
240 +
    Expr(:call,:Values,[Expr(:call,:+,:(y[$i]*value(x[$i]))) for i ∈ 1:N]...)
241 +
end
242 +
@inline @generated function matmul(x::Values{N,<:Chain{V,G}},y::Values{N}) where {N,V,G}
243 +
    Expr(:call,:Values,[Expr(:call,:+,[:(y[$i]*x[$i][$j]) for i ∈ 1:N]...) for j ∈ 1:binomial(mdims(V),G)]...)
244 +
end
245 +
@inline @generated function matmul(x::Values{N,<:MultiVector{V}},y::Values{N}) where {N,V,G}
246 +
    Expr(:call,:Values,[Expr(:call,:+,[:(y[$i]*value(x[$i])[$j]) for i ∈ 1:N]...) for j ∈ 1:1<<mdims(V)]...)
247 +
end
248 +
229 249
contraction(a::Dyadic{V,<:Chain{V,1,<:Chain},<:Chain{V,1,<:Chain}} where V,b::TensorGraded) = sum(value(a.x).⊗(value(a.y).⋅b))
230 250
contraction(a::Dyadic{V,<:Chain{V,1,<:Chain}} where V,b::TensorGraded) = sum(value(a.x).⊗(a.y.⋅b))
231 251
contraction(a::Dyadic{V,T,<:Chain{V,1,<:Chain}} where {V,T},b::TensorGraded) = sum(a.x.⊗(value(a.y).⋅b))
@@ -531,14 +551,29 @@
Loading
531 551
                setblade!(out,$bop(value(b,t)),UInt(basis(b)),Val{N}())
532 552
                return Chain{V,L}(out)
533 553
            end end
534 -
        else quote
535 -
            #@warn("sparse MultiGrade{V} objects not properly handled yet")
536 -
            #return MultiGrade{V}(a,b)
537 -
            $(insert_expr((:N,:t,:out))...)
538 -
            setmulti!(out,value(a,t),UInt(basis(a)),Val{N}())
539 -
            setmulti!(out,$bop(value(b,t)),UInt(basis(b)),Val{N}())
540 -
            return MultiVector{V}(out)
541 -
        end end
554 +
        else
555 +
            if mdims(V)<cache_limit
556 +
                $(insert_expr((:N,:ib),:svec)...)
557 +
                out,ib = zeros(svec(N,Any)),indexbasis(N)
558 +
                X,Y = UInt(basis(a)),UInt(basis(b))
559 +
                for k ∈ 1:1<<N
560 +
                    C = ib[k]
561 +
                    if C ∈ (X,Y)
562 +
                        val = C≠X ? :($bop(value(b,t))) : :(value(a,t))
563 +
                        @inbounds setmulti!_pre(out,val,C,Val{N}())
564 +
                    end
565 +
                end
566 +
                return Expr(:block,insert_expr((:t,),VEC)...,
567 +
                    :(MultiVector{V}($(Expr(:call,tvec(N,:t),out...)))))
568 +
            else quote
569 +
                #@warn("sparse MultiGrade{V} objects not properly handled yet")
570 +
                #return MultiGrade{V}(a,b)
571 +
                $(insert_expr((:N,:t,:out),VEC)...)
572 +
                setmulti!(out,value(a,t),UInt(basis(a)),Val{N}())
573 +
                setmulti!(out,$bop(value(b,t)),UInt(basis(b)),Val{N}())
574 +
                return MultiVector{V}(out)
575 +
            end end
576 +
        end
542 577
    end
543 578
    @noinline function adder(a::Type{<:TensorTerm{V,G}},b::Type{<:Chain{V,G,T}},op,swap=false) where {V,G,T}
544 579
        left,right,VEC = addvec(a,b,swap,op)

@@ -577,7 +577,7 @@
Loading
577 577
                    for g ∈ 1:N+1
578 578
                        ib = indexbasis(N,g-1)
579 579
                        @inbounds for i ∈ 1:bn[g]
580 -
                            val = :(m.v[$(bs[g]+i)])
580 +
                            val = :(conj(m.v[$(bs[g]+i)]))
581 581
                            v = $(c≠h ? :($pnp(V,ib[i],val)) : :val)
582 582
                            v = typeof(V)<:Signature ? ($p(V,ib[i]) ? :($SUB($v)) : v) : Expr(:call,:*,$p(V,ib[i]),v)
583 583
                            @inbounds setmulti!_pre(out,v,complement(N,ib[i],D,P),Val{N}())

@@ -64,8 +64,8 @@
Loading
64 64
Chain(v::Chain{V,G,𝕂}) where {V,G,𝕂} = Chain{V,G}(Values{binomial(mdims(V),G),𝕂}(v.v))
65 65
Chain{𝕂}(v::Chain{V,G}) where {V,G,𝕂} = Chain{V,G}(Values{binomial(mdims(V),G),𝕂}(v.v))
66 66
67 -
DyadicProduct{V,W,T,N} = Chain{V,1,Chain{W,1,T,N},N}
68 -
DyadicChain{V,T,N} = DyadicProduct{V,V,T,N}
67 +
DyadicProduct{V,W,G,T,N} = Chain{V,G,Chain{W,G,T,N},N}
68 +
DyadicChain{V,G,T,N} = DyadicProduct{V,V,G,T,N}
69 69
70 70
export Chain, DyadicProduct, DyadicChain
71 71
getindex(m::Chain,i::Int) = m.v[i]
@@ -257,6 +257,22 @@
Loading
257 257
    end
258 258
end
259 259
260 +
@generated function MultiVector{V}(args::𝕂...) where {V,𝕂}
261 +
    bg = 1<<mdims(V); ref = Values{bg}([:(args[$i]) for i ∈ 1:bg])
262 +
    :(MultiVector{V}($(Expr(:call,:(Values{$bg,𝕂}),ref...))))
263 +
end
264 +
265 +
@generated function MultiVector(args::𝕂...) where 𝕂
266 +
    N = length(args)
267 +
    V = SubManifold(try
268 +
        Int(log2(N))
269 +
    catch
270 +
        throw("Constructor for MultiVector got $N inputs, which is invalid.")
271 +
    end)
272 +
    ref = Values{N}([:(args[$i]) for i ∈ 1:N])
273 +
    :(MultiVector{$V}($(Expr(:call,:(Values{$N,𝕂}),ref...))))
274 +
end
275 +
260 276
function getindex(m::MultiVector{V,T},i::Int) where {V,T}
261 277
    N = mdims(V)
262 278
    0 <= i <= N || throw(BoundsError(m, i))
@@ -288,7 +304,7 @@
Loading
288 304
        for k ∈ 1:length(ib)
289 305
            @inbounds s = k+bs[i]
290 306
            @inbounds mvs = m.v[s]
291 -
            @inbounds if mvs ≠ 0
307 +
            @inbounds if !isnull(mvs)
292 308
                tmv = typeof(mvs)
293 309
                if |(broadcast(<:,tmv,parsym)...)
294 310
                    par = showparens(tmv)
@@ -372,11 +388,11 @@
Loading
372 388
show(io::IO,P::Proj{V,T,Λ}) where {V,T,Λ<:Real} = print(io,isone(P.λ) ? "" : P.λ,"Proj(",P.v,")")
373 389
show(io::IO,P::Proj{V,T,Λ}) where {V,T,Λ} = print(io,"(",P.λ,")Proj(",P.v,")")
374 390
375 -
DyadicChain{V,T}(P::Proj{V,T}) where {V,T} = outer(P.v*P.λ,P.v)
376 -
DyadicChain{V,T}(P::Proj{V,T}) where {V,T<:Chain{V,1,<:Chain}} = sum(outer.(value(P.v).*value(P.λ),P.v))
391 +
DyadicChain{V,1,T}(P::Proj{V,T}) where {V,T} = outer(P.v*P.λ,P.v)
392 +
DyadicChain{V,1,T}(P::Proj{V,T}) where {V,T<:Chain{V,1,<:Chain}} = sum(outer.(value(P.v).*value(P.λ),P.v))
377 393
#DyadicChain{V,T}(P::Proj{V,T}) where {V,T<:Chain{V,1,<:TensorNested}} = sum(DyadicChain.(value(P.v)))
378 -
DyadicChain{V}(P::Proj{V,T}) where {V,T} = DyadicChain{V,T}(P)
379 -
DyadicChain(P::Proj{V,T}) where {V,T} = DyadicChain{V,T}(P)
394 +
DyadicChain{V}(P::Proj{V,T}) where {V,T} = DyadicChain{V,1,T}(P)
395 +
DyadicChain(P::Proj{V,T}) where {V,T} = DyadicChain{V,1,T}(P)
380 396
381 397
struct Dyadic{V,X,Y} <: TensorNested{V}
382 398
    x::X

@@ -293,7 +293,7 @@
Loading
293 293
    out = Chain{W,1,Int,N}[]
294 294
    bnd = Int[]
295 295
    for i ∈ t
296 -
        for w ∈ Chain{W,1}.(DirectSum.combinations(sort(value(i)),N))
296 +
        for w ∈ Chain{W,1}.(Leibniz.combinations(sort(value(i)),N))
297 297
            j = findfirst(isequal(w),out)
298 298
            isnothing(j) ? push!(out,w) : push!(bnd,j)
299 299
        end
@@ -451,6 +451,25 @@
Loading
451 451
            #generate_algebra(:(Reduce.Algebra),T,:df,:RExpr)
452 452
        end
453 453
    end
454 +
    @require Symbolics="0c5d862f-8b57-4792-8d23-62f2024744c7" begin
455 +
        generate_algebra(:Symbolics,:Num)
456 +
        *(a::Symbolics.Num,b::MultiVector{V}) where V = MultiVector{V}(a*b.v)
457 +
        *(a::MultiVector{V},b::Symbolics.Num) where V = MultiVector{V}(a.v*b)
458 +
        *(a::Symbolics.Num,b::Chain{V,G}) where {V,G} = Chain{V,G}(a*b.v)
459 +
        *(a::Chain{V,G},b::Symbolics.Num) where {V,G} = Chain{V,G}(a.v*b)
460 +
        *(a::Symbolics.Num,b::Simplex{V,G,B,T}) where {V,G,B,T<:Real} = Simplex{V}(a,b)
461 +
        *(a::Simplex{V,G,B,T},b::Symbolics.Num) where {V,G,B,T<:Real} = Simplex{V}(b,a)
462 +
        Base.iszero(a::Simplex{V,G,B,Symbolics.Num}) where {V,G,B} = false
463 +
        isfixed(::Type{Symbolics.Num}) = true
464 +
        for op ∈ (:+,:-)
465 +
            for Term ∈ (:TensorGraded,:TensorMixed)
466 +
                @eval begin
467 +
                    $op(a::T,b::Symbolics.Num) where T<:$Term = $op(a,b*g_one(Manifold(a)))
468 +
                    $op(a::Symbolics.Num,b::T) where T<:$Term = $op(a*g_one(Manifold(b)),b)
469 +
                end
470 +
            end
471 +
        end
472 +
    end
454 473
    @require SymPy="24249f21-da20-56a4-8eb1-6a02cf4ae2e6" begin
455 474
        generate_algebra(:SymPy,:Sym,:diff,:symbols)
456 475
        generate_symbolic_methods(:SymPy,:Sym, (:expand,:factor,:together,:apart,:cancel), (:N,:subs))
@@ -514,20 +533,56 @@
Loading
514 533
        end
515 534
    end=#
516 535
    @require StaticArrays="90137ffa-7385-5640-81b9-e52037218182" begin
517 -
        StaticArrays.SMatrix(m::Chain{V,1,<:Chain{W,1}}) where {V,W} = StaticArrays.SMatrix{mdims(W),mdims(V)}(vcat(value.(value(m))...))
536 +
        StaticArrays.SMatrix(m::Chain{V,G,<:Chain{W,G}}) where {V,W,G} = StaticArrays.SMatrix{binomial(mdims(W),G),binomial(mdims(V),G)}(vcat(value.(value(m))...))
518 537
        DyadicChain(m::StaticArrays.SMatrix{N,N}) where N = Chain{SubManifold(N),1}(m)
519 -
        Chain{V,1}(m::StaticArrays.SMatrix{N,N}) where {V,N} = Chain{V,1}(Chain{V,1}.(getindex.(Ref(m),:,StaticArrays.SVector{N}(1:N))))
520 -
        Chain{V,1,Chain{W,1}}(m::StaticArrays.SMatrix{M,N}) where {V,W,M,N} = Chain{V,1}(Chain{W,1}.(getindex.(Ref(m),:,StaticArrays.SVector{N}(1:N))))
521 -
        Base.exp(A::Chain{V,1,<:Chain{V,1}}) where V = Chain{V,1}(exp(StaticArrays.SMatrix(A)))
522 -
        Base.log(A::Chain{V,1,<:Chain{V,1}}) where V = Chain{V,1}(log(StaticArrays.SMatrix(A)))
523 -
        LinearAlgebra.eigvals(A::Chain{V,1,<:Chain{V,1}}) where V = Chain(Values{mdims(V)}(LinearAlgebra.eigvals(StaticArrays.SMatrix(A))))
524 -
        LinearAlgebra.eigvecs(A::Chain{V,1,<:Chain{V,1}}) where V = Chain(Chain.(Values{mdims(A)}.(getindex.(Ref(LinearAlgebra.eigvecs(StaticArrays.SMatrix(A))),:,list(1,mdims(A))))))
525 -
        function LinearAlgebra.eigen(A::Chain{V,1,<:Chain{V,1}}) where V
526 -
            E,N = eigen(StaticArrays.SMatrix(A)),mdims(V)
538 +
        Chain{V,G}(m::StaticArrays.SMatrix{N,N}) where {V,G,N} = Chain{V,G}(Chain{V,G}.(getindex.(Ref(m),:,StaticArrays.SVector{N}(1:N))))
539 +
        Chain{V,G,Chain{W,G}}(m::StaticArrays.SMatrix{M,N}) where {V,W,G,M,N} = Chain{V,G}(Chain{W,G}.(getindex.(Ref(m),:,StaticArrays.SVector{N}(1:N))))
540 +
        Base.exp(A::Chain{V,G,<:Chain{V,G}}) where {V,G} = Chain{V,G}(exp(StaticArrays.SMatrix(A)))
541 +
        Base.log(A::Chain{V,G,<:Chain{V,G}}) where {V,G} = Chain{V,G}(log(StaticArrays.SMatrix(A)))
542 +
        LinearAlgebra.eigvals(A::Chain{V,G,<:Chain{V,G}}) where {V,G} = Chain(Values{binomial(mdims(V),G)}(LinearAlgebra.eigvals(StaticArrays.SMatrix(A))))
543 +
        LinearAlgebra.eigvecs(A::Chain{V,G,<:Chain{V,G}}) where {V,G} = Chain(Chain.(Values{binomial(mdims(A),G)}.(getindex.(Ref(LinearAlgebra.eigvecs(StaticArrays.SMatrix(A))),:,list(1,binomial(mdims(A),G))))))
544 +
        function LinearAlgebra.eigen(A::Chain{V,G,<:Chain{V,G}}) where {V,G}
545 +
            E,N = eigen(StaticArrays.SMatrix(A)),binomial(mdims(V),G)
527 546
            e = Chain(Chain.(Values{N}.(getindex.(Ref(E.vectors),:,list(1,N)))))
528 547
            Proj(e,Chain(Values{N}(E.values)))
529 548
        end
530 549
    end
550 +
    @require Meshes = "eacbb407-ea5a-433e-ab97-5258b1ca43fa" begin
551 +
        Meshes.Point(t::Values) = Meshes.Point(Tuple(t.v))
552 +
        Meshes.Point(t::Variables) = Meshes.Point(Tuple(t.v))
553 +
        Base.convert(::Type{Meshes.Point},t::T) where T<:TensorTerm{V} where V = Meshes.Point(value(Chain{V,valuetype(t)}(vector(t))))
554 +
        Base.convert(::Type{Meshes.Point},t::T) where T<:TensorTerm{V,0} where V = Meshes.Point(zeros(valuetype(t),mdims(V))...)
555 +
        Base.convert(::Type{Meshes.Point},t::T) where T<:TensorAlgebra = Meshes.Point(value(vector(t)))
556 +
        Base.convert(::Type{Meshes.Point},t::Chain{V,G,T}) where {V,G,T} = G == 1 ? Meshes.Point(value(vector(t))) : Meshes.Point(zeros(T,mdims(V))...)
557 +
        Meshes.Point(t::T) where T<:TensorAlgebra = convert(Meshes.Point,t)
558 +
        pointpair(p,V) = Pair(Meshes.Point.(V.(value(p)))...)
559 +
        function initmesh(m::Meshes.SimpleMesh{N}) where N
560 +
            c,f = Meshes.vertices(m),m.topology.connec
561 +
            s = N+1; V = SubManifold(ℝ^s) # s
562 +
            n = length(f[1].indices)
563 +
            p = ChainBundle([Chain{V,1}(Values{s,Float64}(1.0,k.coords...)) for k ∈ c])
564 +
            M = s ≠ n ? p(list(s-n+1,s)) : p
565 +
            t = ChainBundle([Chain{M,1}(Values{n,Int}(k.indices)) for k ∈ f])
566 +
            return (p,ChainBundle(∂(t)),t)
567 +
        end
568 +
        @pure ptype(::Meshes.Point{N,T} where N) where T = T
569 +
        export pointfield
570 +
        pointfield(t,V=Manifold(t),W=V) = p->Meshes.Point(V(vector(↓(↑((V∪Manifold(t))(Chain{W,1,ptype(p)}(p.data)))⊘t))))
571 +
        function pointfield(t,ϕ::T) where T<:AbstractVector
572 +
            M = Manifold(t)
573 +
            V = Manifold(M)
574 +
            z = mdims(V) ≠ 4 ? Meshes(0.0,0.0) : Meshes.Point(0.0,0.0,0.0)
575 +
            p->begin
576 +
                P = Chain{V,1}(one(ptype(p)),p.data...)
577 +
                for i ∈ 1:length(t)
578 +
                    ti = value(t[i])
579 +
                    Pi = Chain{V,1}(M[ti])
580 +
                    P ∈ Pi && (return Meshes.Point((Pi\P)⋅Chain{V,1}(ϕ[ti])))
581 +
                end
582 +
                return z
583 +
            end
584 +
        end
585 +
    end
531 586
    @require GeometryBasics = "5c1252a2-5f33-56bf-86c9-59e7332b4326" begin
532 587
        GeometryBasics.Point(t::Values) = GeometryBasics.Point(Tuple(t.v))
533 588
        GeometryBasics.Point(t::Variables) = GeometryBasics.Point(Tuple(t.v))
@@ -694,11 +749,11 @@
Loading
694 749
        #aran(area=0.001,angle=20) = "pa$(Printf.@sprintf("%.15f",area))q$(Printf.@sprintf("%.15f",angle))Q"
695 750
    end
696 751
    @require TetGen="c5d3f3f7-f850-59f6-8a2e-ffc6dc1317ea" begin
697 -
        function TetGen.TetgenIO(mesh::ChainBundle;
752 +
        function TetGen.JLTetGenIO(mesh::ChainBundle;
698 753
                marker = :markers, holes = TetGen.Point{3,Float64}[])
699 -
            TetGen.TetgenIO(value(mesh); marker=marker, holes=holes)
754 +
            TetGen.JLTetGenIO(value(mesh); marker=marker, holes=holes)
700 755
        end
701 -
        function TetGen.TetgenIO(mesh::Vector{<:Chain};
756 +
        function TetGen.JLTetGenIO(mesh::Vector{<:Chain};
702 757
                marker = :markers, holes = TetGen.Point{3, Float64}[])
703 758
            f = TetGen.TriangleFace{Cint}.(value.(mesh))
704 759
            kw_args = Any[:facets => TetGen.metafree(f),:holes => holes]
@@ -706,9 +761,9 @@
Loading
706 761
                push!(kw_args, :facetmarkers => getproperty(f, marker))
707 762
            end
708 763
            pm = points(mesh); V = Manifold(pm)
709 -
            TetGen.TetgenIO(TetGen.Point.(↓(V).(value(pm))); kw_args...)
764 +
            TetGen.JLTetGenIO(TetGen.Point.(↓(V).(value(pm))); kw_args...)
710 765
        end
711 -
        function initmesh(tio::TetGen.TetgenIO, command = "Qp")
766 +
        function initmesh(tio::TetGen.JLTetGenIO, command = "Qp")
712 767
            r = TetGen.tetrahedralize(tio, command); V = SubManifold(ℝ^4)
713 768
            p = ChainBundle([Chain{V,1}(Values{4,Float64}(1.0,k...)) for k ∈ r.points])
714 769
            t = Chain{p,1}.(Values{4,Int}.(r.tetrahedra))
@@ -722,7 +777,7 @@
Loading
722 777
        end
723 778
        function TetGen.tetrahedralize(mesh::Vector{<:Chain}, command = "Qp";
724 779
                marker = :markers, holes = TetGen.Point{3, Float64}[])
725 -
            initmesh(TetGen.TetgenIO(mesh;marker=marker,holes=holes),command)
780 +
            initmesh(TetGen.JLTetGenIO(mesh;marker=marker,holes=holes),command)
726 781
        end
727 782
    end
728 783
    @require MATLAB="10e44e05-a98a-55b3-a45b-ba969058deb6" begin
Files Coverage
src 28.02%
Project Totals (7 files) 28.02%
Sunburst
The inner-most circle is the entire project, moving away from the center are folders then, finally, a single file. The size and color of each slice is representing the number of statements and the coverage, respectively.
Icicle
The top section represents the entire project. Proceeding with folders and finally individual files. The size and color of each slice is representing the number of statements and the coverage, respectively.
Grid
Each block represents a single file in the project. The size and color of each block is represented by the number of statements and the coverage, respectively.
Loading