licenses
sequencelengths 1
3
| version
stringclasses 677
values | tree_hash
stringlengths 40
40
| path
stringclasses 1
value | type
stringclasses 2
values | size
stringlengths 2
8
| text
stringlengths 25
67.1M
| package_name
stringlengths 2
41
| repo
stringlengths 33
86
|
|---|---|---|---|---|---|---|---|---|
[
"MIT"
] | 0.1.0 | 8830ae3d26179ed6fc177335b4c252158192c0e5 | code | 1182 | function errors_main()
lim = 10
uf = UnionFinder(lim)
@test_throws BoundsError union!(uf, lim, 0)
@test_throws BoundsError union!(uf, 0, lim)
@test_throws BoundsError union!(uf, lim, lim + 1)
@test_throws BoundsError union!(uf, lim + 1, lim)
@test_throws ArgumentError union!(uf, [lim, lim, lim], [lim, lim])
@test_throws BoundsError union!(uf, [lim], [0])
@test_throws BoundsError union!(uf, [0], [lim])
@test_throws BoundsError union!(uf, [lim], [lim + 1])
@test_throws BoundsError union!(uf, [lim + 1], [lim])
@test_throws BoundsError union!(uf, [(lim, 0)])
@test_throws BoundsError union!(uf, [(0, lim)])
@test_throws BoundsError union!(uf, [(lim, lim + 1)])
@test_throws BoundsError union!(uf, [(lim + 1, lim)])
@test_throws BoundsError find!(uf, lim + 1)
@test_throws BoundsError find!(uf, 0)
@test_throws BoundsError size!(uf, lim + 1)
@test_throws BoundsError size!(uf, 0)
cf = CompressedFinder(uf)
@test_throws BoundsError find(cf, lim + 1)
@test_throws BoundsError find(cf, 0)
@test_throws ArgumentError UnionFinder(0)
end
errors_main()
| UnionFind | https://github.com/epatters/UnionFind.jl.git |
|
[
"MIT"
] | 0.1.0 | 8830ae3d26179ed6fc177335b4c252158192c0e5 | code | 818 | function polymorphism_main()
uf = UnionFinder(convert(UInt16, 2))
union!(uf, convert(UInt16, 1), convert(UInt16, 2))
reset!(uf)
@test UInt16 == typeof(find!(uf, convert(UInt16, 1)))
@test UInt16 == typeof(size!(uf, convert(UInt16, 1)))
@test_throws MethodError union!(uf, convert(Int64, 1), convert(Int64, 2))
@test_throws MethodError union!(uf, convert(UInt16, 1), convert(Int64, 2))
@test_throws MethodError union!(uf, convert(Int64, 1), convert(UInt16, 2))
@test_throws MethodError find!(uf, convert(Int64, 1))
@test_throws MethodError size!(uf, convert(Int64, 1))
cf = CompressedFinder(uf)
@test UInt16 == typeof(find(cf, convert(UInt16, 1)))
@test UInt16 == typeof(groups(cf))
@test_throws MethodError find(cf, convert(Int64, 1))
end
polymorphism_main()
| UnionFind | https://github.com/epatters/UnionFind.jl.git |
|
[
"MIT"
] | 0.1.0 | 8830ae3d26179ed6fc177335b4c252158192c0e5 | code | 273 | using UnionFind
using Printf
using Test
@testset "Polymorphism" begin
include("polymorphism.jl")
end
@testset "Table" begin
include("table.jl")
end
@testset "Errors" begin
include("errors.jl")
end
@testset "Benchmark" begin
include("benchmark.jl")
end
| UnionFind | https://github.com/epatters/UnionFind.jl.git |
|
[
"MIT"
] | 0.1.0 | 8830ae3d26179ed6fc177335b4c252158192c0e5 | code | 4869 | function check(uf :: UnionFinder, groups :: Vector{Vector{Int}})
# Check node count.
if sum(length, groups) != length(uf)
println("Found $(length(uf)), but expected $(sum(length, groups)).")
return false
end
# Check that all nodes which should be in groups together are, in fact,
# in groups together.
for group in groups
if !all(id -> find!(uf, id) == find!(uf, group[1]), group)
ids = map(id -> find!(uf, id), group)
println("Group $group has ids $ids.")
return false
elseif !all(id -> length(group) == size!(uf, id), group)
sizes = map(id -> size!(uf, id), group)
println("Group $group has sizes $sizes.")
return false
end
end
# Check uniqueness of groups.
for i in 1:length(groups)
for j in 1:length(groups)
if i == j
continue
elseif find!(uf, groups[i][1]) == find!(uf, groups[j][1])
println("Group $(groups[i]) and $(groups[j]) have same id.")
return false
end
end
end
return true
end
function check(cf :: CompressedFinder, group_set :: Vector{Vector{Int}})
# Check node count and group count.
if sum(length, group_set) != length(cf)
println("Found $(length(cf)), but expected $(sum(length, group_set)).")
return false
elseif length(group_set) != groups(cf)
println("Expected $(length(groups)) groups, but got $(groups(cf)).")
return false
end
# Check that all nodes which should be in groups together are, in fact,
# in groups together.
for group in group_set
if !all(id -> find(cf, id) == find(cf, group[1]), group)
ids = map(id -> find(cf, id), group)
println("Group $group has ids $ids.")
return false
elseif find(cf, group[1]) <= 0 || find(cf, group[1]) > groups(cf)
println("Group $group has invlaid id, $(find(cf, group[1]))")
return false
end
end
# Check uniqueness of groups.
for i in 1:length(group_set)
for j in 1:length(group_set)
if i == j
continue
elseif find(cf, group_set[i][1]) == find(cf, group_set[j][1])
println("Group $(group_set[i]) and $(group_set[j]) " +
"have same id.")
return false
end
end
end
return true
end
function sc_println(test_num :: Integer, uf :: UnionFinder)
println("Test $test_num:")
print("parents: [")
for (i, id) in enumerate(uf.parents)
print("$i: $id")
if i != length(uf.parents)
print(", ")
end
end
println("]")
print("sizes: [")
for (i, size) in enumerate(uf.sizes)
print("$i: $size")
if i != length(uf.sizes)
print(", ")
end
end
println("]")
return true
end
function sc_println(test_num :: Integer, cf :: CompressedFinder)
println("Test $test_num:")
print("ids: [")
for (i, id) in enumerate(cf.ids)
print("$i: $id")
if i != length(cf.ids)
print(", ")
end
end
println("]")
return true
end
tests = [# singleton
(Int[], Int[], [[1]]),
# self loop
([1], [1], [[1]]),
# unconnected pair
(Int[], Int[], [[1],[2]]),
# connected pair
([1], [2], [[1,2]]),
# floater
([1], [2], [[1,2],[3]]),
# "V"
([1,2], [2,3], [[1,2,3]]),
# triangle
([1,2,3], [3,1,2], [[1,2,3]]),
# "Z": order 1
([1,2,3], [2,3,4], [[1,2,3,4]]),
# "Z": order 2
([1,4,2], [2,3,3], [[1,2,3,4]]),
# diamond
([1,2,4,3,1], [2,4,3,4,3], [[1,2,3,4]]),
# K-5
([1,1,1,1], [2,3,4,5], [[1,2,3,4,5]]),
([2,2,2,2], [1,3,4,5], [[1,2,3,4,5]]),
([3,3,3,3], [1,2,4,5], [[1,2,3,4,5]]),
([4,4,4,4], [1,2,3,5], [[1,2,3,4,5]]),
([5,5,5,5], [1,2,3,4], [[1,2,3,4,5]]),
# jewish star
([1,3,5,6,4,2], [3,5,1,2,6,4], [[1,3,5],[2,4,6]]),
# barbell
([1,2,3,4,5,6,6], [2,3,1,5,6,4,3], [[1,2,3,4,5,6]])
]
function table_main()
for (i, (us, vs, groups)) in enumerate(tests)
uf = UnionFinder(sum(length, groups))
union!(uf, us, vs)
cf = CompressedFinder(uf)
@test check(uf, groups) || !sc_println(i, uf)
@test check(cf, groups) || !sc_println(i, cf)
reset!(uf)
for (u, v) in zip(us, vs)
union!(uf, u, v)
end
@test check(uf, groups) || !sc_println(i, uf)
reset!(uf)
union!(uf, zip(us, vs))
@test check(uf, groups) || !sc_println(i, uf)
end
end
table_main()
| UnionFind | https://github.com/epatters/UnionFind.jl.git |
|
[
"MIT"
] | 0.1.0 | 8830ae3d26179ed6fc177335b4c252158192c0e5 | docs | 4268 | UnionFind.jl
============
`UnionFind.jl` is a light-weight library for identifying groups of nodes in
undirected graphs. It is written in [Julia 0.7](http://julialang.org/). It is
currently in version 0.1.0.
# API
This library exports two types, `UnionFinder`, and `CompressedFinder`.
## UnionFinder
`UnionFinder{T <: Integer}` is a graph representation which allows for the
dynamic addition of edges as well as the identification of groups.
### Constructors
* `UnionFinder{T <: Integer}(nodes :: T) :: UnionFinder{T}` returns a
`UnionFinder` instance representing a graph of `nodes` unconnected nodes.
Each node will be indexed by a unique integer of type `T` in the inclusive
range [`1`, `nodes`]. If `nodes` is non-positive, an `ArgumentError` will
be thrown.
### Methods
The identification of groups is handled lazily, meaning that all non-trivial
methods will modify the contents of the target `UnionFinder` instance.
* `union!{T <: Integer}(uf :: UnionFinder{T}, u :: T, v :: T)` adds an edge
to `uf` connecting node `u` to node `v`. If either `u` or `v` is
non-positive or greater than `nodes`, a `BoundsError` will be thrown.
* `union!{T <: Integer}(uf :: UnionFinder{T}, edges :: Array{(T, T)})` adds
each edges within `edges` to `uf`. This method obeys the same bounds
restrictions as the single edge `union!` method.
* `union!{T <: Integer}(uf :: UnionFinder{T}, us :: Array{T}, vs :: Array{T})`
adds edges of the form (`us[i]`, `vs[i]`) to `uf`. This method obeys the
same bounds restrictions as the single edge `union!` method.
* `find!{T <: Integer}(uf :: UnionFinder{T}, node :: T) :: T` returns the
unique id of the node group containing `node`.
* `size!{T <: Integer}(uf :: UnionFinder{T}, node :: T) :: T` returns the
number of nodes in the group containing `node`.
* `reset!(uf :: UnionFinder)` disconnects all nodes within `uf`, allowing for
a new set of edges to be analyzed without making further allocations.
* `length(uf :: UnionFinder) :: Int` returns the number of nodes within `uf`.
### Fields
The fields of `UnionFinder` instances should not be accesed by user-level code.
## CompressedFinder
`CompressedFinder{T <: Integer}`
### Constructors
* `CompressedFinder{T <: Integer}(uf :: UnionFinder) :: CompressedFinder{T}`
returns a `CompressedFinder` instance corresponding to the same groups
represented by
### Methods
* `find{T <: Integer}(cf :: CompressedFinder{T}, node :: T) :: T` returns the
unique id of the group containing `node`. If `node` is non-positive or
is larger than the number of nodes in `cf`, a `BoundsError` is thrown.
* `groups{T <: Integer}(cf :: CompressedFinder{T}) :: T` returns the number
of groups within `cf`.
### Fields
* `ids :: Array{T}` is an array mapping node indices to the group which
contains them.
* `groups :: T` is the number of groups in the `CompressedFinder` instance.
# Examples
## Floodfill
```julia
using UnionFind
function floodfill(grid, wrap=false)
uf = UnionFinder(length(grid))
height, width = size(grid)
for x in 1:width
for y in 1:height
# Look rightwards.
if x != width && grid[x, y] == grid[x + 1, y]
union!(uf, flatten(x, y, grid), flatten(x + 1, y, grid))
elseif wrap && grid[x, y] == grid[1, y]
union!(uf, flatten(x, y, grid), flatten(1, y, grid))
end
# Look upwards.
if y != height && grid[x, y] == grid[x, y + 1]
union!(uf, flatten(x, y, grid), flatten(x, y + 1, grid))
elseif wrap && grid[x, y] == grid[x, 1]
union!(uf, flatten(x, y, grid), flatten(x, 1, grid))
end
end
end
cf = CompressedFinder(uf)
return reshape(cf.ids, size(grid))
end
flatten(x, y, grid) = y + (x - 1)size(grid)[1]
```
## Kruskal
```julia
using UnionFind
# edges must be pre-sorted according to weight.
function kruskal{T <: Integer}(nodes :: T, edges :: Array{(T, T)})
uf = UnionFinder(nodes)
mst = Array{(T, T)}
for i in 1:length(edges)
(u, v) = edges[i]
if find!(uf, u) != find!(uf, v)
union!(uf, u, v)
push!(mst, (u, v))
end
end
end
```
| UnionFind | https://github.com/epatters/UnionFind.jl.git |
|
[
"MIT"
] | 0.2.2 | 645bed98cd47f72f67316fd42fc47dee771aefcd | code | 664 | using PolyesterWeave
using Documenter
DocMeta.setdocmeta!(
PolyesterWeave,
:DocTestSetup,
:(using PolyesterWeave);
recursive = true
)
makedocs(;
modules = [PolyesterWeave],
authors = "Chris Elrod <[email protected]> and contributors",
repo = "https://github.com/JuliaSIMD/PolyesterWeave.jl/blob/{commit}{path}#{line}",
sitename = "PolyesterWeave.jl",
format = Documenter.HTML(;
prettyurls = get(ENV, "CI", "false") == "true",
canonical = "https://JuliaSIMD.github.io/PolyesterWeave.jl",
assets = String[]
),
pages = ["Home" => "index.md"]
)
deploydocs(;
repo = "github.com/JuliaSIMD/PolyesterWeave.jl",
devbranch = "main"
)
| PolyesterWeave | https://github.com/JuliaSIMD/PolyesterWeave.jl.git |
|
[
"MIT"
] | 0.2.2 | 645bed98cd47f72f67316fd42fc47dee771aefcd | code | 1700 | module PolyesterWeave
if isdefined(Base, :Experimental) &&
isdefined(Base.Experimental, Symbol("@max_methods"))
@eval Base.Experimental.@max_methods 1
end
using BitTwiddlingConvenienceFunctions: nextpow2
using ThreadingUtilities: _atomic_store!, _atomic_or!, _atomic_xchg!
using Static
using IfElse: ifelse
export request_threads, free_threads!
@static if VERSION ≥ v"1.6.0-DEV.674"
@inline function assume(b::Bool)
Base.llvmcall(
(
"""
declare void @llvm.assume(i1)
define void @entry(i8 %byte) alwaysinline {
top:
%bit = trunc i8 %byte to i1
call void @llvm.assume(i1 %bit)
ret void
}
""",
"entry"
),
Cvoid,
Tuple{Bool},
b
)
end
else
@inline assume(b::Bool) = Base.llvmcall(
(
"declare void @llvm.assume(i1)",
"%b = trunc i8 %0 to i1\ncall void @llvm.assume(i1 %b)\nret void"
),
Cvoid,
Tuple{Bool},
b
)
end
const WORKERS = Ref{NTuple{8,UInt64}}(ntuple(((zero ∘ UInt64)), Val(8)))
include("unsignediterator.jl")
include("request.jl")
dynamic_thread_count() = min((Sys.CPU_THREADS)::Int, Threads.nthreads())
worker_mask_init(x) = if x < 0
0x0000000000000000
elseif x ≥ 64
0xffffffffffffffff
else
((0x0000000000000001 << x) - 0x0000000000000001)
end
# function static_thread_init()
# nt = num_threads()
# Base.Cartesian.@ntuple 8 i -> worker_mask_init(nt - (i-1)*64)
# end
function reset_workers!()
# workers = ntuple(((zero ∘ UInt64)), Val(8))
nt = dynamic_thread_count() - 1
WORKERS[] = Base.Cartesian.@ntuple 8 i -> worker_mask_init(nt - (i - 1) * 64)
end
__init__() = reset_workers!()
include("utility.jl")
end
| PolyesterWeave | https://github.com/JuliaSIMD/PolyesterWeave.jl.git |
|
[
"MIT"
] | 0.2.2 | 645bed98cd47f72f67316fd42fc47dee771aefcd | code | 6018 | import CPUSummary
function worker_bits()
wts = nextpow2(CPUSummary.sys_threads()) # Typically sys_threads (i.e. Sys.CPU_THREADS) does not change between runs, thus it will precompile well.
ws = static(8sizeof(UInt)) # For testing purposes it can be overridden by JULIA_CPU_THREADS,
ifelse(Static.lt(wts, ws), ws, wts)
end
function worker_mask_count()
bits = worker_bits()
(bits + StaticInt{63}()) ÷ StaticInt{64}() # cld not defined on `StaticInt`
end
worker_pointer() = Base.unsafe_convert(Ptr{UInt}, pointer_from_objref(WORKERS))
function free_threads!(freed_threads::U) where {U<:Unsigned}
_atomic_or!(worker_pointer(), freed_threads)
nothing
end
function free_threads!(freed_threads_tuple::NTuple{1,U}) where {U<:Unsigned}
_atomic_or!(worker_pointer(), freed_threads_tuple[1])
nothing
end
function free_threads!(
freed_threads_tuple::Tuple{U,Vararg{U,N}}
) where {N,U<:Unsigned}
wp = worker_pointer()
for freed_threads in freed_threads_tuple
_atomic_or!(wp, freed_threads)
wp += sizeof(UInt)
end
nothing
end
@inline _remaining(x::Tuple) = Base.tail(x)
@inline _remaining(@nospecialize(x)) = nothing
@inline _first(::Tuple{}) = nothing
@inline _first(x::Tuple{X,Vararg}) where {X<:Unsigned} = getfield(x, 1)
@inline _first(x::Union{Unsigned,Nothing}) = x
@inline function _request_threads(
num_requested::UInt32,
wp::Ptr,
::StaticInt{N},
threadmask
) where {N}
ui, ft, num_requested, wp =
__request_threads(num_requested, wp, _first(threadmask))
uit, ftt = _request_threads(
num_requested,
wp,
StaticInt{N}() - StaticInt{1}(),
_remaining(threadmask)
)
(ui, uit...), (ft, ftt...)
end
@inline function _request_threads(
num_requested::UInt32,
wp::Ptr,
::StaticInt{1},
threadmask
)
ui, ft, num_requested, wp =
__request_threads(num_requested, wp, _first(threadmask))
(ui,), (ft,)
end
@inline function _exchange_mask!(wp, ::Nothing)
all_threads = _atomic_xchg!(wp, zero(UInt))
all_threads, all_threads
end
@inline function _exchange_mask!(wp, threadmask::Unsigned)
all_threads = _atomic_xchg!(wp, zero(UInt))
tm = threadmask % UInt
saved = all_threads & (~tm)
_atomic_store!(wp, saved)
all_threads | saved, all_threads & tm
end
@inline function __request_threads(num_requested::UInt32, wp::Ptr, threadmask)
no_threads = zero(UInt)
if (num_requested ≢ StaticInt{-1}()) && (num_requested % Int32 ≤ zero(Int32))
return UnsignedIteratorEarlyStop(zero(UInt), 0x00000000),
no_threads,
0x00000000,
wp
end
# to get more, we xchng, setting all to `0`
# then see which we need, and free those we aren't using.
wpret = wp + 8 # (UInt === UInt64) | (worker_mask_count() === StaticInt(1)) #, so adding 8 is fine.
# _all_threads = all_threads = _apply_mask(_atomic_xchg!(wp, no_threads), threadmask)
_all_threads, all_threads = _exchange_mask!(wp, threadmask)
additional_threads = count_ones(all_threads) % UInt32
# num_requested === StaticInt{-1}() && return reserved_threads, all_threads
if num_requested === StaticInt{-1}()
return UnsignedIteratorEarlyStop(all_threads),
all_threads,
num_requested,
wpret
end
nexcess = num_requested - additional_threads
if signed(nexcess) ≥ 0
return UnsignedIteratorEarlyStop(all_threads), all_threads, nexcess, wpret
end
# we need to return the `excess` to the pool.
lz = leading_zeros(all_threads) % UInt32
while true
# start by trying to trim off excess from lz
lz += (-nexcess) % UInt32
m = (one(UInt) << (UInt32(8sizeof(UInt)) - lz)) - one(UInt)
masked = (all_threads & m) ⊻ all_threads
nexcess += count_ones(masked) % UInt32
all_threads &= (~masked)
nexcess == zero(nexcess) && break
end
_atomic_store!(wp, _all_threads & (~all_threads))
return UnsignedIteratorEarlyStop(all_threads, num_requested),
all_threads,
0x00000000,
wpret
end
@inline function request_threads(num_requested, threadmask)
_request_threads(
num_requested % UInt32,
worker_pointer(),
worker_mask_count(),
threadmask
)
end
@inline request_threads(num_requested) = request_threads(num_requested, nothing)
"""
`request_threads` is called to request a set of `ThreadingUtilities` worker tasks to run on.
```
julia> using PolyesterWeave
julia> PolyesterWeave.request_threads(12)
((Thread (12) Iterator: U[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],), (0x0000000000000fff,))
```
This returns an iterator over the available threads 1-12
`U[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]`, as well as a mask that must be used for freeing
these threads when done.
Note that the thread doing the requesting should also always do part of the work. Thus if
you want to run on 13 threads, you'd request 12. If you want to run on 8 threads, you'd
request 7. Etc.
If you request more threads than available on the system, you get only what is available:
```
julia> Sys.CPU_THREADS, Threads.nthreads()
(16, 8)
julia> r1 = PolyesterWeave.request_threads(30) # Note you get only 7, not 8
((Thread (7) Iterator: U[1, 2, 3, 4, 5, 6, 7],), (0x000000000000007f,))
julia> r2 = PolyesterWeave.request_threads(30)
((Thread (0) Iterator: UInt64[],), (0x0000000000000000,))
```
The following are unsupported features that might be yanked out at any time:
During request you can also mask out which threads you can get. For instance, this call:
```
julia> Sys.CPU_THREADS, Threads.nthreads()
(96, 96)
julia> r1 = PolyesterWeave.request_threads(96, 0xa)
((Thread (2) Iterator: U[2, 4], Thread (31) Iterator: U[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]), (0x000000000000000a, 0x000000007fffffff))
```
Is saying you want 96 threads, but you have the mask `0x0a` which turns off all threads from
the first set of 64 except for 2 and 4:
```
julia> bitstring(0xa)
"00001010"
```
Hence you got the iterator `U[2,4]`, plus an iterator over all the available works from the
next batch of 64.
"""
function request_threads end
| PolyesterWeave | https://github.com/JuliaSIMD/PolyesterWeave.jl.git |
|
[
"MIT"
] | 0.2.2 | 645bed98cd47f72f67316fd42fc47dee771aefcd | code | 3297 | struct UnsignedIterator{U}
u::U
end
Base.IteratorSize(::Type{<:UnsignedIterator}) = Base.HasShape{1}()
Base.IteratorEltype(::Type{<:UnsignedIterator}) = Base.HasEltype()
Base.eltype(::UnsignedIterator) = UInt32
Base.length(u::UnsignedIterator) = count_ones(u.u)
Base.size(u::UnsignedIterator) = (count_ones(u.u),)
# @inline function Base.iterate(u::UnsignedIterator, uu = u.u)
# tz = trailing_zeros(uu) % UInt32
# # tz ≥ 0x00000020 && return nothing
# tz > 0x0000001f && return nothing
# uu ⊻= (0x00000001 << tz)
# tz, uu
# end
@inline function Base.iterate(u::UnsignedIterator, (i, uu) = (0x00000000, u.u))
tz = trailing_zeros(uu) % UInt32
tz == 0x00000020 && return nothing
i += tz
tz += 0x00000001
uu >>>= tz
(i, (i + 0x00000001, uu))
end
"""
UnsignedIteratorEarlyStop(thread_mask[, num_threads = count_ones(thread_mask)])
Iterator, returning `(i,t) = Tuple{UInt32,UInt32}`, where `i` iterates from `1,2,...,num_threads`, and `t` gives the threadids to call `ThreadingUtilities.taskpointer` with.
Unfortunately, codegen is suboptimal when used in the ergonomic `for (i,tid) ∈ thread_iterator` fashion. If you want to microoptimize,
You'd get better performance from a pattern like:
```julia
function sumk(u, l = count_ones(u) % UInt32)
uu = ServiceSolicitation.UnsignedIteratorEarlyStop(u, l)
s = zero(UInt32)
state = ServiceSolicitation.initial_state(uu)
while true
iter = iterate(uu, state)
iter === nothing && break
(i, t), state = iter
s += t
end
s
end
```
This iterator will iterate at least once; it's important to check and exit early with a single threaded version.
"""
struct UnsignedIteratorEarlyStop{U}
u::U
i::UInt32
end
UnsignedIteratorEarlyStop(u) =
UnsignedIteratorEarlyStop(u, count_ones(u) % UInt32)
UnsignedIteratorEarlyStop(u, i) = UnsignedIteratorEarlyStop(u, i % UInt32)
mask(u::UnsignedIteratorEarlyStop) = getfield(u, :u)
Base.IteratorSize(::Type{<:UnsignedIteratorEarlyStop}) = Base.HasShape{1}()
Base.IteratorEltype(::Type{<:UnsignedIteratorEarlyStop}) = Base.HasEltype()
Base.eltype(::UnsignedIteratorEarlyStop) = Tuple{UInt32,UInt32}
Base.length(u::UnsignedIteratorEarlyStop) = getfield(u, :i)
Base.size(u::UnsignedIteratorEarlyStop) = (getfield(u, :i),)
@inline function initial_state(u::UnsignedIteratorEarlyStop)
# LLVM should figure this out if you check?
assume(0x00000000 ≠ u.i)
(0x00000000, u.u)
end
@inline function iter(i, uu)
assume(uu ≠ zero(uu))
tz = trailing_zeros(uu) % UInt32
tz += 0x00000001
i += tz
uu >>>= tz
i, uu
end
@inline function Base.iterate(
u::UnsignedIteratorEarlyStop,
((i, uu), j) = (initial_state(u), 0x00000000)
)
# assume(u.i ≤ 0x00000020)
# assume(j ≤ count_ones(uu))
# iszero(j) && return nothing
j == u.i && return nothing
j += 0x00000001
i, uu = iter(i, uu)
((j, i), ((i, uu), j))
end
function Base.show(io::IO, u::UnsignedIteratorEarlyStop)
l = length(u)
s = Vector{Int}(undef, l)
if l > 0
s .= last.(u)
end
print("Thread ($l) Iterator: U", s)
end
# @inline function Base.iterate(u::UnsignedIteratorEarlyStop, (i,uu) = (0xffffffff,u.u))
# tz = trailing_zeros(uu) % UInt32
# tz == 0x00000020 && return nothing
# tz += 0x00000001
# i += tz
# uu >>>= tz
# (i, (i,uu))
# end
| PolyesterWeave | https://github.com/JuliaSIMD/PolyesterWeave.jl.git |
|
[
"MIT"
] | 0.2.2 | 645bed98cd47f72f67316fd42fc47dee771aefcd | code | 940 | """
disable_polyester_threads(f::F)
A context manager function that disables Polyester threads without affecting the scheduling
of `Base.Treads.@threads`. Particularly useful for cases when Polyester has been used to
multithread an inner small problem that is now to be used in an outer embarassingly parallel
problem (in such cases it is best to multithread only at the outermost level).
This call will disable all PolyesterWeave threads, including those in
`LoopVectorization.@tturbo` and `Octavian.matmul`.
Avoid calling it as `@threads for i in 1:n disable_polyester_threads(f) end` as that creates
unnecessary per-thread overhead. Rather call it in the outermost scope, e.g. as given here:
```
disable_polyester_threads() do
@threads for i in 1:n f()
end
```
"""
function disable_polyester_threads(f::F) where {F}
_, r = request_threads(Threads.nthreads())
try
f()
finally
foreach(free_threads!, r)
end
end
| PolyesterWeave | https://github.com/JuliaSIMD/PolyesterWeave.jl.git |
|
[
"MIT"
] | 0.2.2 | 645bed98cd47f72f67316fd42fc47dee771aefcd | code | 1086 | println(
"Starting tests with $(Threads.nthreads()) threads out of `Sys.CPU_THREADS = $(Sys.CPU_THREADS)`..."
)
using PolyesterWeave, Aqua
using Test
@testset "PolyesterWeave.jl" begin
threads, torelease = PolyesterWeave.request_threads(Threads.nthreads() - 1)
@test threads isa NTuple{
Int(PolyesterWeave.worker_mask_count()),
PolyesterWeave.UnsignedIteratorEarlyStop{UInt}
}
@test sum(map(length, threads)) == PolyesterWeave.dynamic_thread_count() - 1
PolyesterWeave.free_threads!(torelease)
r1 = PolyesterWeave.request_threads(Sys.CPU_THREADS, 0x0a)
@test (r1[2][1] & 0x0a) == r1[2][1]
r2 = PolyesterWeave.request_threads(Sys.CPU_THREADS, 0xff)
@test (r2[2][1] & 0xff) == r2[2][1]
@test count_ones(r1[2][1] ⊻ r2[2][1]) ≤ min(8, Sys.CPU_THREADS)
@test iszero(r1[2][1] & r2[2][1])
PolyesterWeave.free_threads!(r1[2])
PolyesterWeave.free_threads!(r2[2])
@testset "Valid State" begin
@test sum(map(count_ones, PolyesterWeave.WORKERS[])) ==
min(512, PolyesterWeave.dynamic_thread_count() - 1)
end
end
Aqua.test_all(PolyesterWeave)
| PolyesterWeave | https://github.com/JuliaSIMD/PolyesterWeave.jl.git |
|
[
"MIT"
] | 0.2.2 | 645bed98cd47f72f67316fd42fc47dee771aefcd | docs | 388 | # PolyesterWeave
[](https://JuliaSIMD.github.io/PolyesterWeave.jl/stable)
[](https://JuliaSIMD.github.io/PolyesterWeave.jl/dev)
[](https://github.com/JuliaSIMD/PolyesterWeave.jl/actions)
| PolyesterWeave | https://github.com/JuliaSIMD/PolyesterWeave.jl.git |
|
[
"MIT"
] | 0.2.2 | 645bed98cd47f72f67316fd42fc47dee771aefcd | docs | 207 | ```@meta
CurrentModule = PolyesterWeave
```
# PolyesterWeave
Documentation for [PolyesterWeave](https://github.com/JuliaSIMD/PolyesterWeave.jl).
```@index
```
```@autodocs
Modules = [PolyesterWeave]
```
| PolyesterWeave | https://github.com/JuliaSIMD/PolyesterWeave.jl.git |
|
[
"MIT"
] | 0.1.0 | 4d79790c746e50b109ae4bd8c13f66ea60d51f49 | code | 12907 | module BestModelSubset
using DataFrames: DataFrame
using GLM
using Combinatorics: combinations
using MLBase: deviance, r2, adjr2, aic, bic
using Suppressor: @suppress
export ModelSelection
export fit!
export best_subset
export forward_stepwise
export backward_stepwise
"""
ModelSelection(algorithm::AbstractString, param1::AbstractString, param2::AbstractString)
Returns a ModelSelection object
ModelSelection(algorithm::Union{Function,Nothing}
deviance::Union{Function,Real,Nothing}
r2::Union{Function,Real,Nothing}
adjr2::Union{Function,Real,Nothing}
aic::Union{Function,Real,Nothing}
bic::Union{Function,Real,Nothing}
param1::Union{Function,Real,Nothing}
param2::Union{Function,Real,Nothing})
For example:
ModelSelection("bess", "r2", "adjr2") returns
ModelSelection(BestModelSubset.best_subset, nothing, StatsAPI.r2, StatsAPI.adjr2,
nothing, nothing, StatsAPI.r2, StatsAPI.adjr2)
ModelSelection("forward","deviance","aic")
ModelSelection(BestModelSubset.forward_stepwise, StatsAPI.deviance, nothing, nothing,
StatsAPI.aic, nothing, StatsAPI.deviance, StatsAPI.aic)
"""
mutable struct ModelSelection
algorithm::Union{Function,Nothing}
deviance::Union{Function,Real,Nothing}
r2::Union{Function,Real,Nothing}
adjr2::Union{Function,Real,Nothing}
aic::Union{Function,Real,Nothing}
bic::Union{Function,Real,Nothing}
param1::Union{Function,Real,Nothing}
param2::Union{Function,Real,Nothing}
function ModelSelection(algorithm, deviance, r2, adjr2, aic, bic, param1, param2)
if typeof(r2) <: Nothing
if typeof(bic) <: Nothing
return new(algorithm, deviance, r2, adjr2, aic, bic, deviance, aic)
else
return new(algorithm, deviance, r2, adjr2, aic, bic, deviance, bic)
end
end
if typeof(deviance) <: Nothing
if (typeof(aic) <: Nothing) & (typeof(bic) <: Nothing)
return new(algorithm, deviance, r2, adjr2, aic, bic, r2, adjr2)
end
if (typeof(adjr2) <: Nothing) & (typeof(bic) <: Nothing)
return new(algorithm, deviance, r2, adjr2, aic, bic, r2, aic)
end
if (typeof(adjr2) <: Nothing) & (typeof(aic) <: Nothing)
return new(algorithm, deviance, r2, adjr2, aic, bic, r2, bic)
end
end
end
end
function ModelSelection(algorithm::AbstractString, param1::AbstractString, param2::AbstractString)
dict = Dict([
"best" => best_subset, "bess" => best_subset,
"best_subset" => best_subset, "best_subset_selection" => best_subset,
"forward" => forward_stepwise, "forward_stepwise" => forward_stepwise,
"forward_stepwise_selection" => forward_stepwise, "backward" => backward_stepwise,
"backward_stepwise" => backward_stepwise, "backward_stepwise_selection" => backward_stepwise,
"deviance" => deviance, "r2" => r2, "adjr2" => adjr2, "aic" => aic, "bic" => bic])
if (lowercase(param1) == "deviance") & (lowercase(param2) == "aic")
return ModelSelection(
values(dict[lowercase(algorithm)]),
values(dict[lowercase(param1)]),
nothing,
nothing,
values(dict[lowercase(param2)]),
nothing,
nothing,
nothing)
end
if (lowercase(param1) == "deviance") & (lowercase(param2) == "bic")
return ModelSelection(
values(dict[lowercase(algorithm)]),
values(dict[lowercase(param1)]),
nothing,
nothing,
nothing,
values(dict[lowercase(param2)]),
nothing,
nothing)
end
if (lowercase(param1) == "r2") & (lowercase(param2) == "adjr2")
return ModelSelection(
values(dict[lowercase(algorithm)]),
nothing,
values(dict[lowercase(param1)]),
values(dict[lowercase(param2)]),
nothing,
nothing,
nothing,
nothing)
end
if (lowercase(param1) == "r2") & (lowercase(param2) == "aic")
return ModelSelection(
values(dict[lowercase(algorithm)]),
nothing,
values(dict[lowercase(param1)]),
nothing,
values(dict[lowercase(param2)]),
nothing,
nothing,
nothing)
end
if (lowercase(param1) == "r2") & (lowercase(param2) == "bic")
return ModelSelection(
values(dict[lowercase(algorithm)]),
nothing,
values(dict[lowercase(param1)]),
nothing,
nothing,
values(dict[lowercase(param2)]),
nothing,
nothing)
end
end
"""
fit!(obj::ModelSelection, data::Union{DataFrame,AbstractMatrix{<:Real}}) -> Vector{Vector{T}}
Fit the data to the ModelSelection object.
"""
function fit!(obj::ModelSelection, data::Union{DataFrame,AbstractMatrix{<:Real}})
@suppress begin
if Set(Array(data[:, end])) == Set([0.0, 1.0])
dev = obj.algorithm(obj, data)
final = []
for d in dev
logreg = glm(Array(data[:, d]), Array(data[:, end]), Binomial(), ProbitLink())
push!(final, obj.param2(logreg))
end
obj.param2 = minimum(final)
obj.r2 = nothing
obj.adjr2 = nothing
obj.deviance = deviance(glm(Array(data[:, dev[indexin(minimum(final), final)[1]]]),
Array(data[:, end]), Binomial(), ProbitLink()))
obj.param1 = obj.deviance
obj.aic = aic(glm(Array(data[:, dev[indexin(minimum(final), final)[1]]]),
Array(data[:, end]), Binomial(), ProbitLink()))
obj.bic = bic(glm(Array(data[:, dev[indexin(minimum(final), final)[1]]]),
Array(data[:, end]), Binomial(), ProbitLink()))
else
dev = obj.algorithm(obj, data)
final = []
for d in dev
logreg = lm(Array(data[:, d]), Array(data[:, end]))
push!(final, obj.param2(logreg))
end
obj.param2 = minimum(final)
obj.r2 = r2(lm(Array(data[:, dev[indexin(minimum(final), final)[1]]]),
Array(data[:, end])))
obj.adjr2 = adjr2(lm(Array(data[:, dev[indexin(minimum(final), final)[1]]]),
Array(data[:, end])))
obj.param1 = obj.r2
obj.aic = aic(lm(Array(data[:, dev[indexin(minimum(final), final)[1]]]),
Array(data[:, end])))
obj.bic = bic(lm(Array(data[:, dev[indexin(minimum(final), final)[1]]]),
Array(data[:, end])))
end
return [dev[indexin(minimum(final), final)[1]]]
end
end
"""
forward_stepwise(obj::ModelSelection, df::DataFrame) -> Vector{Vector{T}}
Executes the forward step-wise selection algorithm.
"""
function forward_stepwise(obj::ModelSelection, df::DataFrame)
@suppress begin
if Set(Array(df[:, end])) == Set([0.0, 1.0])
dev = []
comb = collect(combinations(1:length(names(df))-1, 1))
for num in 1:length(names(df))-1
val = []
for j in comb
logreg = glm(Array(df[:, j]), Array(df[:, names(df)[end]]), Binomial(), ProbitLink())
push!(val, obj.param1(logreg))
end
push!(dev, comb[indexin(minimum(val), val)])
comb = collect(combinations(1:length(names(df))-1, num + 1))
l = []
for j in 1:length(comb)
a = true
for i in dev[end][1]
a = a & (i in comb[j])
end
push!(l, a)
end
comb = comb[[i for i in l]]
end
return [dev[i][1] for i in 1:length(names(df))-1]
else
dev = []
comb = collect(combinations(1:length(names(df))-1, 1))
for num in 1:length(names(df))-1
val = []
for j in comb
logreg = lm(Array(df[:, j]), Array(df[:, names(df)[end]]))
push!(val, obj.param1(logreg))
end
push!(dev, comb[indexin(maximum(val), val)])
comb = collect(combinations(1:length(names(df))-1, num + 1))
l = []
for j in 1:length(comb)
a = true
for i in dev[end][1]
a = a & (i in comb[j])
end
push!(l, a)
end
comb = comb[[i for i in l]]
end
return [dev[i][1] for i in 1:length(names(df))-1]
end
end
end
"""
forward_stepwise(obj::ModelSelection, df::AbstractMatrix{<:Real}) -> Vector{Vector{T}}
Executes the forward step-wise selection algorithm.
"""
function forward_stepwise(obj::ModelSelection, df::AbstractMatrix{<:Real})
df = DataFrame(df, :auto)
forward_stepwise(obj, df)
end
"""
best_subset(obj::ModelSelection, df::DataFrame) -> Vector{Vector{T}}
Executes the best subset selection algorithm.
"""
function best_subset(obj::ModelSelection, df::DataFrame)
@suppress begin
if size(df)[1] > size(df)[2]
if Set(Array(df[:, end])) == Set([0.0, 1.0])
dev = []
for num in 1:length(names(df))-1
val = []
for i in collect(combinations(1:length(names(df))-1, num))
logreg = glm(Array(df[:, i]), Array(df[:, end]), Binomial(), ProbitLink())
push!(val, obj.param1(logreg))
end
push!(dev, collect(combinations(1:length(names(df))-1, num))[indexin(minimum(val), val)])
end
return [dev[i][1] for i in 1:length(names(df))-1]
else
dev = []
for num in 1:length(names(df))-1
val = []
for i in collect(combinations(1:length(names(df))-1, num))
logreg = lm(Array(df[:, i]), Array(df[:, end]))
push!(val, obj.param1(logreg))
end
push!(dev, collect(combinations(1:length(names(df))-1, num))[indexin(maximum(val), val)])
end
return [dev[i][1] for i in 1:length(names(df))-1]
end
else
forward_stepwise(obj, df)
end
end
end
"""
best_subset(obj::ModelSelection, df::AbstractMatrix{<:Real}) -> Vector{Vector{T}}
Executes the best subset selection algorithm.
"""
function best_subset(obj::ModelSelection, df::AbstractMatrix{<:Real})
df = DataFrame(df, :auto)
best_subset(obj, df)
end
"""
backward_stepwise(obj::ModelSelection, df::DataFrame) -> Vector{Vector{T}}
Executes the backward step-wise selection algorithm.
"""
function backward_stepwise(obj::ModelSelection, df::DataFrame)
@suppress begin
if size(df)[1] > size(df)[2]
if Set(Array(df[:, end])) == Set([0.0, 1.0])
dev = [[s for s in 1:length(names(df))-1]]
comb = collect(combinations(dev[1], length(names(df)) - 2))
while length(dev[end]) != 1
val = []
for j in comb
logreg = glm(Array(df[:, j]), Array(df[:, names(df)[end]]), Binomial(), ProbitLink())
push!(val, obj.param1(logreg))
end
push!(dev, comb[indexin(minimum(val), val)][1])
comb = collect(combinations(dev[end], length(dev[end]) - 1))
end
return dev
else
dev = [[s for s in 1:length(names(df))-1]]
comb = collect(combinations(dev[1], length(names(df)) - 2))
while length(dev[end]) != 1
val = []
for j in comb
logreg = lm(Array(df[:, j]), Array(df[:, names(df)[end]]))
push!(val, obj.param1(logreg))
end
push!(dev, comb[indexin(maximum(val), val)][1])
comb = collect(combinations(dev[end], length(dev[end]) - 1))
end
return dev
end
else
forward_stepwise(obj, df)
end
end
end
"""
backward_stepwise(obj::ModelSelection, df::DataFrame) -> Vector{Vector{T}}
Executes the backward step-wise selection algorithm.
"""
function backward_stepwise(obj::ModelSelection, df::AbstractMatrix{<:Real})
df = DataFrame(df, :auto)
backward_stepwise(obj, df)
end
end | BestModelSubset | https://github.com/waitasecant/BestModelSubset.jl.git |
|
[
"MIT"
] | 0.1.0 | 4d79790c746e50b109ae4bd8c13f66ea60d51f49 | code | 3452 | using BestModelSubset
using Test
using DataFrames, Random
Random.seed!(1234)
df1 = hcat(rand(Float64, (50, 20)), rand([0, 1], (50, 1))) # n>p
df2 = hcat(rand(Float64, (10, 20)), rand([0, 1], (10, 1))) # n<p
df3 = hcat(rand(Float64, (50, 21))) # n>p
df4 = hcat(rand(Float64, (10, 21))) # n<p
@testset "Fit- Forward Step-wise" begin
@test fit!(ModelSelection("forward", "deviance", "aic"), DataFrame(df1, :auto)) isa Array # DataFrame(n>p)
@test fit!(ModelSelection("forward_stepwise", "deviance", "bic"), DataFrame(df2, :auto)) isa Array # DataFrame(n<p)
@test fit!(ModelSelection("forward", "deviance", "aic"), df1) isa Array # Matrix(n>p)
@test fit!(ModelSelection("forward_stepwise", "deviance", "bic"), df2) isa Array # Matrix(n<p)
@test fit!(ModelSelection("forward", "r2", "aic"), DataFrame(df3, :auto)) isa Array # DataFrame(n>p)
@test fit!(ModelSelection("forward_stepwise", "r2", "bic"), df3) isa Array # DataFrame(n>p)
@test fit!(ModelSelection("forward", "R2", "adjr2"), DataFrame(df3, :auto)) isa Array # DataFrame(n>p)
@test fit!(ModelSelection("forward_stepwise", "R2", "aic"), df4) isa Array # Matrix(n<p)
@test fit!(ModelSelection("forward", "R2", "bic"), DataFrame(df4, :auto)) isa Array # Matrix(n<p)
@test fit!(ModelSelection("forward_stepwise", "r2", "adjr2"), df4) isa Array # Matrix(n<p)
end
@testset "Fit- Best Subset" begin
@test fit!(ModelSelection("bess", "deviance", "aic"), DataFrame(df1, :auto)) isa Array # DataFrame(n>p)
@test fit!(ModelSelection("best", "deviance", "bic"), DataFrame(df2, :auto)) isa Array # DataFrame(n<p)
@test fit!(ModelSelection("best_subset", "deviance", "aic"), df1) isa Array # Matrix(n>p)
@test fit!(ModelSelection("best_subset_selection", "deviance", "bic"), df2) isa Array # Matrix(n<p)
@test fit!(ModelSelection("bess", "r2", "aic"), DataFrame(df3, :auto)) isa Array # DataFrame(n>p)
@test fit!(ModelSelection("best", "r2", "bic"), df3) isa Array # DataFrame(n>p)
@test fit!(ModelSelection("best_subset", "R2", "adjr2"), DataFrame(df3, :auto)) isa Array # DataFrame(n>p)
@test fit!(ModelSelection("bess", "R2", "aic"), df4) isa Array # Matrix(n<p)
@test fit!(ModelSelection("best", "R2", "bic"), DataFrame(df4, :auto)) isa Array # Matrix(n<p)
@test fit!(ModelSelection("best_subset", "r2", "adjr2"), df4) isa Array # Matrix(n<p)
end
@testset "Fit- Backward Step-wise" begin
@test fit!(ModelSelection("backward", "deviance", "aic"), DataFrame(df1, :auto)) isa Array # DataFrame(n>p)
@test fit!(ModelSelection("backward_stepwise", "deviance", "bic"), DataFrame(df2, :auto)) isa Array # DataFrame(n<p)
@test fit!(ModelSelection("backward", "deviance", "aic"), df1) isa Array # Matrix(n>p)
@test fit!(ModelSelection("backward_stepwise", "deviance", "bic"), df2) isa Array # Matrix(n<p)
@test fit!(ModelSelection("backward", "r2", "aic"), DataFrame(df3, :auto)) isa Array # DataFrame(n>p)
@test fit!(ModelSelection("backward_stepwise", "r2", "bic"), df3) isa Array # DataFrame(n>p)
@test fit!(ModelSelection("backward", "R2", "adjr2"), DataFrame(df3, :auto)) isa Array # DataFrame(n>p)
@test fit!(ModelSelection("backward_stepwise", "R2", "aic"), df4) isa Array # Matrix(n<p)
@test fit!(ModelSelection("backward", "R2", "bic"), DataFrame(df4, :auto)) isa Array # Matrix(n<p)
@test fit!(ModelSelection("backward_stepwise", "r2", "adjr2"), df4) isa Array # Matrix(n<p)
end | BestModelSubset | https://github.com/waitasecant/BestModelSubset.jl.git |
|
[
"MIT"
] | 0.1.0 | 4d79790c746e50b109ae4bd8c13f66ea60d51f49 | docs | 1517 | # BestModelSubset.jl
*A julia package to implement model selection algorithms on basic regression models.*
[](https://ci.appveyor.com/project/waitasecant/bestmodelsubset-jl)
[](https://codecov.io/gh/waitasecant/BestModelSubset.jl)
[](LICENSE)
## Installation
You can install BestModelSubset.jl using Julia's package manager
```julia-repl
julia> using Pkg; Pkg.add("BestModelSubset.jl")
```
## Example
Instantiate a `ModelSelection` object
```julia-repl
# To execute best subset selection with primary parameter to be R-squared score
# and secondary parameter to be aic.
julia> obj = ModelSelection("bess", "r2", "aic")
ModelSelection(BestModelSubset.best_subset, nothing, StatsAPI.r2, nothing, StatsAPI.aic,
nothing, StatsAPI.r2, StatsAPI.aic)
```
Fit the `ModelSelection`object to the data
```julia-repl
# The fit! function updates the fields of the `ModelSelection` object.
julia> Random.seed!(123); df = hcat(rand(Float64, (50, 21))); # 50*21 Matrix
julia> fit!(obj, df)
1-element Vector{Vector{Int64}}:
[5, 6, 16, 17, 18, 20]
```
Access various statistics like r2, adjr2, aic and bic for the selected model
```julia-repl
julia> obj.r2
0.8161760683631274
julia> obj.aic
21.189713760250477
```
| BestModelSubset | https://github.com/waitasecant/BestModelSubset.jl.git |
|
[
"MIT"
] | 0.2.0 | e6f7ddf48cf141cb312b078ca21cb2d29d0dc11d | code | 2660 | module ReadOnlyArrays
export ReadOnlyArray, ReadOnlyVector, ReadOnlyMatrix
using Base: @propagate_inbounds
"""
ReadOnlyArray(X)
Returns a read-only view into the parent array `X`.
# Examples
```jldoctest
julia> a = [1 2; 3 4]
2×2 Array{Int64,2}:
1 2
3 4
julia> r = ReadOnlyArray(a)
2×2 ReadOnlyArray{Int64,2,Array{Int64,2}}:
1 2
3 4
julia> r[1]
1
julia> r[1] = 10
CanonicalIndexError: setindex! not defined for ReadOnlyArray{Int64,2,Array{Int64,2}}
[...]
```
"""
struct ReadOnlyArray{T,N,A} <: AbstractArray{T,N}
parent::A
function ReadOnlyArray(parent::AbstractArray{T,N}) where {T,N}
new{T,N,typeof(parent)}(parent)
end
end
ReadOnlyArray{T}(parent::AbstractArray{T,N}) where {T,N} = ReadOnlyArray(parent)
ReadOnlyArray{T,N}(parent::AbstractArray{T,N}) where {T,N} = ReadOnlyArray(parent)
ReadOnlyArray{T,N,P}(parent::P) where {T,N,P<:AbstractArray{T,N}} = ReadOnlyArray(parent)
#--------------------------------------
# aliases
const ReadOnlyVector{T,P} = ReadOnlyArray{T,1,P}
ReadOnlyVector(parent::AbstractVector) = ReadOnlyArray(parent)
const ReadOnlyMatrix{T,P} = ReadOnlyArray{T,2,P}
ReadOnlyMatrix(parent::AbstractMatrix) = ReadOnlyArray(parent)
#--------------------------------------
# interface, excluding setindex!() and similar()
# https://docs.julialang.org/en/v1/manual/interfaces/#man-interface-parentay
Base.size(x::ReadOnlyArray, args...) = size(x.parent, args...)
@propagate_inbounds function Base.getindex(x::ReadOnlyArray, args...)
getindex(x.parent, args...)
end
Base.IndexStyle(::Type{<:ReadOnlyArray{T,N,P}}) where {T,N,P} = IndexStyle(P)
Base.iterate(x::ReadOnlyArray, args...) = iterate(x.parent, args...)
Base.length(x::ReadOnlyArray) = length(x.parent)
Base.similar(x::ReadOnlyArray) = similar(x.parent)
Base.axes(x::ReadOnlyArray) = axes(x.parent)
function Base.IteratorSize(::Type{<:ReadOnlyArray{T,N,P}}) where {T,N,P}
Base.IteratorSize(P)
end
function Base.IteratorEltype(::Type{<:ReadOnlyArray{T,N,P}}) where {T,N,P}
Base.IteratorEltype(P)
end
function Base.eltype(::Type{<:ReadOnlyArray{T,N,P}}) where {T,N,P}
eltype(P)
end
Base.firstindex(x::ReadOnlyArray) = firstindex(x.parent)
Base.lastindex(x::ReadOnlyArray) = lastindex(x.parent)
Base.strides(x::ReadOnlyArray) = strides(x.parent)
function Base.unsafe_convert(p::Type{Ptr{T}}, x::ReadOnlyArray) where {T}
Base.unsafe_convert(p, x.parent)
end
Base.stride(x::ReadOnlyArray, i::Int) = stride(x.parent, i)
Base.parent(x::ReadOnlyArray) = x.parent
function Base.convert(::Type{ReadOnlyArray{T,N}}, mutable_parent::AbstractArray{T,N}) where {T,N}
ReadOnlyArray(mutable_parent)
end
end
| ReadOnlyArrays | https://github.com/JuliaArrays/ReadOnlyArrays.jl.git |
|
[
"MIT"
] | 0.2.0 | e6f7ddf48cf141cb312b078ca21cb2d29d0dc11d | code | 2332 | using ReadOnlyArrays, Test
const x = rand(5, 10)
const r = ReadOnlyArray(x)
@testset "Constructors" begin
@test ReadOnlyArray{Float64}(x) == r
@test ReadOnlyArray{Float64,2}(x) == r
@test ReadOnlyArray{Float64,2,typeof(x)}(x) == r
end
@testset "Interface" begin
@testset "size" begin
@test size(r) == size(x)
@test size(r, 1) == size(x, 1)
@test size(r, 2) == size(x, 2)
@test length(r) == length(x)
end
@testset "indexing" begin
@test firstindex(r) == firstindex(x)
@test lastindex(r) == lastindex(x)
@test IndexStyle(typeof(r)) == IndexStyle(typeof(x))
end
@testset "iteration" begin
@test Base.IteratorSize(typeof(r)) == Base.IteratorSize(typeof(x))
@test Base.IteratorEltype(typeof(r)) == Base.IteratorEltype(typeof(x))
@test eltype(typeof(r)) == eltype(r) == eltype(x)
@test r[end] == x[end]
@test r[1:2, end] == x[1:2, end]
@test_throws BoundsError r[0]
@test_throws BoundsError r[end+1]
@test iterate(r) == iterate(x)
@test iterate(r, firstindex(r)) == iterate(x, firstindex(x))
@test iterate(r, lastindex(r)) == iterate(x, lastindex(x))
@test begin
iterate(r, iterate(r, lastindex(r))[2]) == iterate(x, iterate(x, lastindex(x))[2])
end
end
@testset "misc" begin
@test axes(r) == axes(x)
@test parent(r) === x
# Test the implicit conversion from mutable array to read-only.
f()::ReadOnlyArray{Float64,2} = x
fa = f()
@test fa isa ReadOnlyArray{Float64,2}
@test fa == x
a = ReadOnlyArray([1, 2])
@test typeof(similar(a)) === Vector{Int64}
@test copy(a) == [1, 2]
@test typeof(copy(a)) === Vector{Int64}
end
end
@testset "Aliases" begin
@test ReadOnlyVector([4, 5]) isa ReadOnlyArray{Int,1,Vector{Int}}
@test ReadOnlyVector{Int}([4, 5]) isa ReadOnlyArray{Int,1,Vector{Int}}
@test ReadOnlyVector{Int,Vector{Int}}([4, 5]) isa ReadOnlyVector{Int,Vector{Int}}
@test ReadOnlyMatrix([1 2; 3 4]) isa ReadOnlyArray{Int,2,Matrix{Int}}
@test ReadOnlyMatrix{Int}([1 2; 3 4]) isa ReadOnlyArray{Int,2,Matrix{Int}}
@test ReadOnlyMatrix{Int,Matrix{Int}}([1 2; 3 4]) isa ReadOnlyArray{Int,2,Matrix{Int}}
end
| ReadOnlyArrays | https://github.com/JuliaArrays/ReadOnlyArrays.jl.git |
|
[
"MIT"
] | 0.2.0 | e6f7ddf48cf141cb312b078ca21cb2d29d0dc11d | docs | 1632 | ReadOnlyArrays.jl
=============
This small package provides the `ReadOnlyArray` type, which wraps any `AbstractArray` and reimplements the array inferface without the setindex! function. The array can be used in all the usually ways but its elements cannot be modified. Attempting to set an element's value will raise an error. This functionality can be used to protect arrays that are intended to have unchanged values from unintended changes.
A `ReadOnlyArray` is not a `StaticArray` from [`StaticArrays.jl`](https://github.com/JuliaArrays/StaticArrays.jl). Static arrays are statically sized and also usually immutable, but are intended to accelerate common operations on *small* arrays. A `ReadOnlyArray` wraps arrays of any size and does not reimplement any functionality except the usual [array interface](https://docs.julialang.org/en/v1/manual/interfaces/#man-interface-array).
For convenience, there are also `ReadOnlyVector` and `ReadOnlyMatrix` aliases available.
### Installation
In the Julia REPL:
```julia
using Pkg
Pkg.add("ReadOnlyArrays")
```
or use package management mode by pressing `]` and entering `add ReadOnlyArrays`.
### Usage
Wrap any array by contructing a read-only version.
```julia
using ReadOnlyArrays
x = [1.0, 2.0, 3.0]
x = ReadOnlyArray(x)
```
The elements of this array cannot be modified. Attempting to set element values
```julia
x[1] = 2.0
```
will raise an error
```
ERROR: CanonicalIndexError: setindex! not defined for ReadOnlyVector{Float64, Vector{Float64}}
```
This read only array also identifies as a read only vector, for convenience.
```julia
typeof(y) <: ReadOnlyVector
``` | ReadOnlyArrays | https://github.com/JuliaArrays/ReadOnlyArrays.jl.git |
|
[
"MIT"
] | 0.3.2 | 3d6d7432a5fba335d09e704ae387be3c15146bc6 | code | 409 |
module PolynomialFactors
## TODO
## * performance is still really poor for larger degrees.
using AbstractAlgebra
using Combinatorics
import Primes
import LinearAlgebra
import LinearAlgebra: norm, dot, I
include("utils.jl")
include("polyutils.jl")
include("factor_zp.jl")
include("lll.jl")
include("factor_zx.jl")
export poly_factor, factormod
#export factor, rational_roots, factormod
end # module
| PolynomialFactors | https://github.com/jverzani/PolynomialFactors.jl.git |
|
[
"MIT"
] | 0.3.2 | 3d6d7432a5fba335d09e704ae387be3c15146bc6 | code | 4029 | ### factor_Zp code
## 14.3
## f in Zq[x]
## return g1, g2, ..., gs: g) is product of all monic irreducible polys in Fq[x] of degree i that divide f
function distinct_degree_factorization(f, q, x=gen(parent(f)))
degree(f) > 0 || error("f is a constant poly")
h, f0, i = x, f, 0
gs = eltype(f)[]
while true
i += 1
h = _powermod(h, q, f0)
g = gcd(h - x, f)
f = divexact(f, g)
push!(gs, g)
if degree(f) < 2(i+1)
push!(gs, f)
break
end
end
gs
end
#function _equal_degree_splitting(f::AbstractAlgebra.Generic.Poly{AbstractAlgebra.gfelem{T}}, q, x, d) where {T}
function _equal_degree_splitting(f, q, x, d) #where {T}
n = degree(f)
n <= 1 && return (f, false)
# random poly of degree < n
q′ = Int(q)
ground = base_ring(f)
a = sum(ground(rand(0:(q′-1))) * x^i for i in 0:(n-1))
degree(a) <= 0 && return (f, false)
g1 = gcd(a, f)
!isone(g1) && return (g1, true)
b = _powermod(a, (q^d-1) ÷ 2, f)
g2 = gcd(b-1, f)
!isone(g2) && g2 != f && return (g2, true)
return (f, false)
end
# Algo 14.8
# f square free, monic in Fq[x]
# q odd prime power
# d divides n, all irreducible factors of f have degree d
# this calls _equal_degree_splitting which has probability 2^(1-r) of success
# returns a proper monic factor (g,true) or (f,false)
function equal_degree_splitting(f, q, x, d)
K = 50
while K > 0
g, val = _equal_degree_splitting(f, q, x, d)
val && return (g, true)
K -= 1
end
return (f, false)
end
# f square free in F_q[x]
# d divides degree(f)
# all irreducible factors of f have degree d
# return all monic factors of f in F_q[x]
function equal_degree_factorization(f, q, x, d)
degree(f) == 0 && return (f, )
degree(f) == d && return (f, )
g, val = equal_degree_splitting(f, q, x, d)
if val
return tuplejoin(equal_degree_factorization(g, q, x, d),
equal_degree_factorization(divexact(f, g), q, x, d))
else
return (f,)
end
end
# Cantor Zazzenhaus factoring of a polynomial of Zp[x]
# Algorithm 14.13 from von Zur Gathen and Gerhard, Modern Computer Algebra v1, 1999
# f in Zq[x], q prime
function factor_Zp(f, q, x=variable(f))
h = x
v = f * inv(leading_coefficient(f)) # monic
i = 0
U = Dict{typeof(f), Int}()
while true
i += 1
h = _powermod(h, q, f)
g = gcd(h - x, v)
if !isone(g)
gs = equal_degree_factorization(g, q, x, i)
for (j,gj) in enumerate(gs)
e = 0
while true
qu,re = divrem(v, gj)
if iszero(re)
v = qu
e += 1
else
break
end
end
U[gj] = e
end
end
isone(v) && break
end
U
end
# slightly faster?
# this saves a `divrem` per factor
function factor_Zp_squarefree(f, q, x=variable(f))
h = x
v = f * inv(leading_coefficient(f)) # monic
i = 0
facs = typeof(f)[]
while true
i += 1
h = _powermod(h, q, f)
g = gcd(h - x, v)
if !isone(g)
gs = equal_degree_factorization(g, q, x, i)
for (j,gj) in enumerate(gs)
qu,re = divrem(v, gj)
if iszero(re)
push!(facs, gj)
v = qu
end
end
end
isone(v) && break
end
facs
end
function factormod(f::AbstractAlgebra.Generic.Poly{T}, p::Integer) where {T <: Integer}
x = string(var(parent(f)))
fp = as_poly_Zp(f, p, x)
c = leading_coefficient(fp)
fp = fp * inv(c)
us = factor_Zp(fp, p)
if !isone(c)
us[c*one(fp)] = 1
end
us
end
function factormod(fs::Vector{T}, p::Integer) where {T <: Integer}
f = as_poly_Zp(fs, p, "x")
factor_Zp(fp, p)
end
| PolynomialFactors | https://github.com/jverzani/PolynomialFactors.jl.git |
|
[
"MIT"
] | 0.3.2 | 3d6d7432a5fba335d09e704ae387be3c15146bc6 | code | 9985 |
## Factor over Z[x]
## big prime
# Algo 15.2
# f is square free
function factor_Zx_big_prime_squarefree(f)
n = degree(f)
n == 1 && return f
A = maxnorm(f)
b = value(leading_coefficient(f))
# we use BigInt for p, B if we need to
lambda = log(typemax(Int)/(4*A*b))/(1/2 + log(2))
if n < -1 #lambda
p = 0
B = floor(Int, sqrt(n+1)*big(2)^n*big(A)*b)
else
p = big(0)
B = floor(BigInt, sqrt(n+1)*big(2)^n*big(A)*b)
end
while true
p = Primes.nextprime(rand(2B:4B))
g = gcd(as_poly_Zp(f, p, "x"), as_poly_Zp(derivative(f), p, "x"))
isone(g) && break
end
fZp = as_poly_Zp(f, p, "x")
fZp = fZp * inv(leading_coefficient(fZp))
d = factor_Zp_squarefree(fZp, p, variable(fZp))
gs = collect(keys(d))
R,x = ZZ["x"] # big?
Gs = as_poly.(poly_coeffs.(gs), x)
_factor_combinations(f, Gs, p, 1, x, b, B)
end
##################################################
# algo 15.10
# g, h rel prime
# lifts f,g,h,s,t over F_m to values in F_m^2
function hensel_step(f, g, h, s, t, m)
# f, g, h,s, t are in Z[x]
isone(leading_coefficient(h)) || error("h must be monic")
degree(f) == degree(g) + degree(h) || error("degree(f) != degree(g) + degree(h)")
degree(s) < degree(h) && degree(t) < degree(g) || error("degree(s) !< degree(h) or degree(t) !< degree(g)")
e = as_poly_modp(as_poly(f) - as_poly(g) * as_poly(h), m^2)
f, g, h, s, t = as_poly_modp.((f,g,h,s,t), m^2)
q, r = divrem(s*e, h)
gstar = g + t * e + q * g
hstar = h + r
b = s*gstar + t * hstar - one(t)
c, d = divrem(s * b, hstar)
sstar = s - d
tstar = t - t*b - c*gstar
iszero(f - gstar * hstar) || error("f != g^* * h^* mod m^2")
# isone(sstar * tstar + tstar * hstar) || error("st + th != 1 mod m^2")
as_poly.((gstar, hstar, sstar, tstar))
end
# collect factors into a tree for apply HenselStep
abstract type AbstractFactorTree end
mutable struct FactorTree <: AbstractFactorTree
fg
children
s
t
FactorTree(fg) = new(fg, Any[])
end
mutable struct FactorTree_over_Zp <: AbstractFactorTree
fg
children
s
t
FactorTree_over_Zp(fg, p) = new(fg, Any[])
end
function make_factor_tree_over_Zp(f, fs, p) # fs factors over Zp
N = length(fs)
n = ceil(Int, log2(N))
tau = FactorTree(f)
N == 1 && return tau
k = 2^(n-1)
fls = fs[1:k]
fl = prod(as_poly.(fls))
frs = fs[(k+1):end]
fr = prod(as_poly.(frs))
l, r = tau.children = Any[make_factor_tree_over_Zp(fl, fls, p),
make_factor_tree_over_Zp(fr, frs, p)]
g, s, t = gcdx(as_poly_Zp(l.fg,p), as_poly_Zp(r.fg,p))
gi = invmod(value(coeff(g, 0)), p)
tau.s = as_poly(gi*s); tau.t = as_poly(gi*t)
tau
end
function hensel_step_update_factor_tree!(tau, p)
!has_children(tau) && return
l,r = tau.children
f, g,h,s,t = tau.fg, l.fg, r.fg, tau.s, tau.t
g1,h1,s1,t1 = hensel_step(f, g, h, s, t, p)
tau.s, tau.t = s1, t1
l.fg, r.fg = g1, h1
hensel_step_update_factor_tree!(l, p)
hensel_step_update_factor_tree!(r, p)
end
has_children(tau::AbstractFactorTree) = length(tau.children) == 2
function all_children(tau::AbstractFactorTree)
has_children(tau) ? vcat(all_children(tau.children[1]), all_children(tau.children[2])) : [tau.fg]
end
"""
Algo 15.17 multifactor Hensel lifting
"""
function hensel_lift(f, facs, m::T, a0, l) where {T}
tau = make_factor_tree_over_Zp(f, facs, m)
d = ceil(Int, log2(l))
for j = 1:d
a0 = mod(2*a0 - leading_coefficient(f) * a0^2, m^2^j)
tau.fg = a0 * f
hensel_step_update_factor_tree!(tau, m^2^(j-1))
end
tau
end
# factor square free poly in Z[x] using hensel lifting techique
# can resolve factors of p^l using brute force or LLL algorith (which is
# not as competitive here)
# Could rewrite latter to use floating point numbers (http://perso.ens-lyon.fr/damien.stehle/downloads/LLL25.pdf)
function factor_Zx_prime_power_squarefree(f,lll=false)
n = degree(f)
n == 1 && return (f,)
A = big(maxnorm(f))
b = abs(value(leading_coefficient(f)))
B = sqrt(n+1)*big(2)^n * A * b
C = big(n+1)^(2n) * A^(2n-1)
gamma = 2*log2(C) + 1
# hack to try and factor_Zp over small prime if possible
#
gb = 2 * gamma*log(gamma)
if gb < (typemax(Int))^(1/10)
gamma_bound = floor(Int, gb)
else
gamma_bound = floor(BigInt, gb)
end
gamma_bound_lower = floor(BigInt, sqrt(gb))
fs = poly_coeffs(f)
## find p to factor over.
## for lower degree polynomials we choose more than 1 p, and select
## that with the fewest factors over Zp.
## This trades of more time factoring for less time resolving the factors
p, l = zero(gamma_bound), 0
fbar = f # not type stable, but can't be, as cycle through GF(p)["x"]
hs = nothing
P, M = 0, Inf
for k in 1:(max(0,3-div(n,15)) + 1)
while true
P = Primes.prevprime(rand(gamma_bound_lower:gamma_bound))
iszero(mod(b, P)) && continue
fbar = as_poly_Zp(fs, P, "x")
isone(gcd(fbar, derivative(fbar))) && break
end
L = floor(Int, log(P, 2B+1))
d = factor_Zp(fbar, P)
# modular factorization
ds = collect(keys(d))
nfacs = length(ds)
if nfacs < M
p = P
l = L
hs = ds
M = nfacs
end
end
# hensel lifting
a = invmod(b, p)
# set up factor tree
tau = make_factor_tree_over_Zp(f, hs, p)
# use 15.17 to lift f = b * g1 ... gr mod p^l, gi = hi mod p
d = ceil(Int, log2(1+l))
for j = 1:d
a = mod(2*a - leading_coefficient(f) * a^2, p^2^j)
tau.fg = a * f
hensel_step_update_factor_tree!(tau, p^2^(j-1))
end
hs = all_children(tau)
if lll
# slower, and not quite right
identify_factors_lll(f, hs, p, 2^d, b, B)
else
x = variable(hs[1])
_factor_combinations(f, hs, p, 2^d, x, b, B)
end
end
"""
Division algorithm for Z[x]
returns q,r with
* `a = q*b + r`
* `degree(r) < degree(b)`
If no such q and r can be found, then both `q` and `r` are 0.
"""
function exact_divrem(a, b)
f,g = a, b
x = variable(g)
q, r = zero(f), f
while degree(r) >= degree(g)
u, v = divrem(leading_coefficient(r), leading_coefficient(g))
v != 0 && return zero(a), zero(a)
term = u * x^(degree(r) - degree(g))
q = q + term
r = r - term * g
end
(q, r)
end
# a = b^k c, return (c, k)
function deflate(a, b)
k = 0
while degree(a) >= degree(b)
c, r = exact_divrem(a, b)
iszero(c) && return(a, k)
!iszero(r) && return (a, k)
k += 1
a = c
end
return (a, k)
end
## f in Z[x]
## find square free
## return fsq, g where fsq * g = f
function square_free(f)
degree(f) <= 1 && return f
g = gcd(f, derivative(f))
d = degree(g)
if d > 0
fsq = divexact(f, g) #faster than exact_divrem if r=0 is known
else
fsq = f
end
fsq, g
end
##################################################
### Resolve factors over F_p^l
# Brute force method
# f has factors G over Fp^l
function _factor_combinations(f, Gs, p, l, x, b, B)
r = length(Gs)
q = p^l
r == 1 && return (as_poly(as_poly_modp(b*Gs[1],q,x)), )
for s in 1:(r ÷ 2)
for inds in Combinatorics.combinations(1:r, s)
_inds = setdiff(1:r, inds)
_gstar, _hstar = one(x), one(x)
for i in inds
_gstar *= Gs[i]
end
for j in _inds
_hstar *= Gs[j]
end
gstar, hstar = as_poly.(as_poly_modp.((b*_gstar, b*_hstar), q))
if onenorm(gstar) * onenorm(hstar) <= B
Gs = Gs[_inds]
f = as_poly(primpart(hstar))
b = value(leading_coefficient(f))
return (primpart(gstar), _factor_combinations(f, Gs, p, l, x, b, B)...)
end
end
end
return (as_poly(as_poly_modp(b*prod(Gs),p)), )
end
### Interfaces
function poly_factor(f::AbstractAlgebra.Generic.Poly{Rational{T}}) where {T <: Integer}
x, qs = variable(f), poly_coeffs(f)
common_denom = lcm(denominator.(qs))
fs = numerator.(common_denom * qs)
fz = as_poly(fs)
U = poly_factor(fz)
V = Dict{typeof(f), Int}()
for (k,v) in U
j = as_poly(poly_coeffs(k), x)
V[j] = v
end
a = 1//common_denom * one(f)
if !isone(a)
d = filter(kv -> degree(kv[1]) == 0, V)
if length(d) == 0
V[a] = 1
else
k,v = first(d)
V[k*a] = 1
delete!(V, k)
end
end
V
end
function poly_factor(f::AbstractAlgebra.Generic.Poly{T}) where {T <: Integer}
# want content free poly with positive lead coefficient
degree(f) < 0 && return Dict(f=>1)
c, pp = content(f), primpart(f)
if sign(leading_coefficient(f)) < 0
c,f,pp = -c, -f, -pp
end
if degree(f) == 1
isone(c) && return Dict(f=>1)
return Dict(c * one(f)=>1, pp=>1)
end
fsq, g = square_free(pp)
fs = factor_Zx_prime_power_squarefree(fsq)
# get factors
U = Dict(u=>1 for u in fs)
if !isone(c)
U[c*one(f)] = 1
end
# get multiplicities
for u in fs
g, k = deflate(g, u)
if k > 0
U[u] += k
end
degree(g) <= 0 && break
end
U
end
# an iterable yielding a0,a1, ..., an
# ? How wide a type signature do we want here
function poly_factor(f::Function)
z = f(0)
if isa(z, Rational)
R,x = QQ["x"]
elseif isa(z, Integer)
R,x = ZZ["x"]
else
error("f(x) is not in ZZ[x] or QQ[x]")
end
poly_factor(f(x))
end
poly_factor(as) = poly_factor(as_poly(as))
| PolynomialFactors | https://github.com/jverzani/PolynomialFactors.jl.git |
|
[
"MIT"
] | 0.3.2 | 3d6d7432a5fba335d09e704ae387be3c15146bc6 | code | 4438 | ### LLL method
### f = prod(fs) over Zp, find factors over Z
function mu(i,j,B,Bs)
dot(B[i,:], Bs[j,:]) // dot(Bs[j,:], Bs[j,:] )
end
function swaprows!(A, i, j, tmp)
tmp[:] = A[i,:]
A[i,:] = A[j,:]
A[j,:] = tmp
nothing
end
function _reduce(i, T, B, U)
j = i - 1
while j > 0
rij = round(T, digits=U[i,j])
B[i,:] -= rij * B[j, :]
U[i,:] -= rij * U[j, :]
j -= 1
end
end
# Find a short vector for B = [f1;f2;...;fn]
# short vector if f1 after the work is done
# http://algo.epfl.ch/_media/en/projects/bachelor_semester/rapportetiennehelfer.pdf .
# Algo 2
function LLL_basis_reduction!(B::Matrix{T}, c=4//3) where {T <: Integer} # c > 4/3
m, n = size(B)
Bstar = Matrix{Rational{T}}(I, m, m)
U = Matrix{Rational{T}}(I, m, m)
tmpZ = zeros(T, 1, m)
tmpQ = zeros(Rational{T}, 1, m)
ONE, ZERO = one(Rational{T}), zero(Rational{T})
## initialize Bstar, U
Bstar[1,:] = B[1,:] # b^*_1 = b_1
for i in 2:n
Bstar[i,:] = B[i,:]
for j in 1:(i-1)
U[i,j] = mu(i,j,B,Bstar) #vecdot(bi, bstar_j) // vecdot(bstar_j, bstar_j)
Bstar[i,:] -= U[i,j] * Bstar[j,:]
end
_reduce(i, T, B, U)
end
i = 1
while i < m
if norm(B[i,:],2) < c * norm(B[i+1,:],2)
i += 1
else
# Modify Q and R in order to keep the relation B = QR after the swapping
Bstar[i+1, :] += U[i+1,i] * Bstar[i, :]
U[i, i] = mu(i, i+1, B, Bstar)
U[i, i+1] = U[i+1, i] = ONE
U[i+1, i+1] = ZERO
Bstar[i, :] -= U[i,i] * Bstar[i+1, :]
swaprows!(U, i, i+1, tmpQ)
swaprows!(Bstar, i, i+1, tmpQ)
swaprows!(B, i, i+1, tmpZ)
for k in (i+2):m
U[k,i] = mu(k, i, B, Bstar)
U[k,i+1] = mu(k, i+1, B, Bstar)
end
if abs(U[i+1,i]) > 1//2
_reduce(i+1, T, B, U)
end
i = max(i-1, 1)
end
end
end
## For a polynomial p, create a lattice of p, xp, x^2p, ... then find a short vector.
## This will be a potential factor of f
function short_vector(u::AbstractAlgebra.Generic.Poly, m, j, d)
us = poly_coeffs(u)
T = eltype(us)
F = zeros(T, j, j)
# coefficients of us*x^i
for i in 0:(j-d-1)
F[1 + i, (1 + i):(1+i+d)] = us
end
# coefficients of mx^i
for i in 0:(d-1)
F[1 + j - d + i, 1 + i] = m
end
LLL_basis_reduction!(F)
x = variable(u)
# short vector is first row
as_poly(vec(F[1,:]), x)
end
## u is a factor over Zp
## we identify irreducible gstar of f
## return gstar, fstar = f / gstar (basically), and reduced Ts
function identify_factor(u::AbstractAlgebra.Generic.Poly, fstar::AbstractAlgebra.Generic.Poly, Ts::Vector, p::T, l, b, B) where {T}
d, nstar = degree(u), degree(fstar)
d < nstar || throw(DomainError())
m = p^l
j = d + 1
gstar = u
Tsp = as_poly_Zp.(Ts, p)
while j <= nstar+1
gstar = short_vector(u,m,j,d)
gstarp = as_poly_Zp(gstar, p)
inds = Int[]
for (i,t) in enumerate(Tsp)
divides(gstarp, Tsp[i])[1] && push!(inds, i) # allocates
end
notinds = setdiff(1:length(Ts), inds)
Ssp = Tsp[notinds]
# find hstar = prod(Ts)
hstar = as_poly(mod(b, m) * (isempty(Ssp) ? one(gstarp) : prod(Ssp)))
pd = onenorm(primpart(gstar)) * onenorm(primpart(hstar))
if pd < B
gstar, hstar = primpart(gstar), primpart(hstar)
Ts = Ts[notinds] # modify Ts (Ts[:])or make a copy?
fstar = primpart(hstar)
break
end
j = j + 1
end
primpart(gstar), fstar, Ts
end
"""
Use LLL basis reduction to identify factors of square free f from its factors over Zp
"""
function identify_factors_lll(f, facs, p, l, b, B)
Ts = sort(facs, by=degree, rev=true)
Gs = similar(Ts, 0)
fstar = primpart(f)
m = p^l
while length(Ts) > 0
u = popfirst!(Ts)
if length(Ts) == 0
push!(Gs, fstar)
break
end
if degree(fstar) == degree(u)
push!(Gs, fstar)
break
end
# return (u, fstar, Ts, p, l, b, B)
gstar, fstar, Ts = identify_factor(u, fstar, Ts, p, l, b, B)
push!(Gs, gstar)
end
Gs
end
| PolynomialFactors | https://github.com/jverzani/PolynomialFactors.jl.git |
|
[
"MIT"
] | 0.3.2 | 3d6d7432a5fba335d09e704ae387be3c15146bc6 | code | 2514 | ## Some Polynomial utilities
## conveniences for AbstractAlgebra.jl
# get value of GF(p) in (-p/2, p/2)
#function value(x::AbstractAlgebra.gfelem)
function value(x)
# reach in to get a, q
if hasfield(typeof(parent(x)), :p)
q = parent(x).p
a = x.d
a <= q ÷ 2 ? a : a - q
else
x
end
end
#value(x) = x
function poly_coeffs(f::AbstractAlgebra.Generic.Poly)
# println("poly coef f=$f d=$(degree(f))")
d = degree(f)
d < 0 && return [value(coeff(f, 0))]
[value(coeff(f, i)) for i in 0:degree(f)]
end
poly_coeffs(as) = as
variable(f::AbstractAlgebra.Generic.Poly) = gen(parent(f))
function maxnorm(f::AbstractAlgebra.Generic.Poly)
norm(poly_coeffs(f), Inf)
end
function onenorm(f::AbstractAlgebra.Generic.Poly)
norm(poly_coeffs(f), 1)
end
## Conversion to Generic.Poly
# If f = a0 + a1*y + ... an*y^n then compute
# a0*x + ... an*x^n for x a poly. (Could be different ring, ...)
function as_poly(f::AbstractAlgebra.Generic.Poly, x::AbstractAlgebra.Generic.Poly)
degree(f) < 0 && return zero(x)
sum(value(coeff(f, i)) * x^i for i in 0:degree(f))
end
function as_poly(as, x::AbstractAlgebra.Generic.Poly)
sum( ai * x^(i-1) for (i,ai) in enumerate(as))
end
# make poly over Z?
function as_poly(f::AbstractAlgebra.Generic.Poly{T}, x::String="x") where {T}
R,y = ZZ[x]
sum(value(coeff(f, i)) * y^i for i in 0:degree(f))
end
function as_poly(as, x0::String="x")
R, x = ZZ[x0]
as_poly(as, x)
end
# Z[x] with coefficients in (-p/2, p/2)
function _modp(x, p)
a = mod(x,p)
a > p ÷ 2 ? a - p : a
end
# make poly over x with coefficients in (-p/2...p/2)
function as_poly_modp(f, p, x::AbstractAlgebra.Generic.Poly)
as = poly_coeffs(f)
as_poly(_modp.(as, p), x)
end
# make poly in GP from coefficiens of x
# !!! NOTE
# ?GF When check == false, no check is made, but the behaviour of the
# resulting object is undefined if p is composite.
function as_poly_modp(f, p, x0::String="x")
R, x = GF(p, check=false)[x0]
as = poly_coeffs(f)
as_poly(_modp.(as, p), x)
end
# Create a polynomial over Zp[x] from the coefficients
# as is (a0,a1, ..., an) as an interable
function as_poly_Zp(f::AbstractAlgebra.Generic.Poly, p, x)
as_poly_Zp(poly_coeffs(f), p, x)
end
function as_poly_Zp(as, p::S, var="x") where {S}
T = eltype(as)
R = promote_type(T, S)
q = convert(R, p)
F = GF(q)
R,x = PolynomialRing(F, var)
sum(ai*x^(i-1) for (i,ai) in enumerate(as))
end
| PolynomialFactors | https://github.com/jverzani/PolynomialFactors.jl.git |
|
[
"MIT"
] | 0.3.2 | 3d6d7432a5fba335d09e704ae387be3c15146bc6 | code | 750 | ## utility functions
## https://discourse.julialang.org/t/efficient-tuple-concatenation/5398/7
@inline tuplejoin(x) = x
@inline tuplejoin(x, y) = (x..., y...)
@inline tuplejoin(x, y, z...) = (x..., tuplejoin(y, z...)...)
# powmod(g, q, f) but q can be BigInt,,,
# compute a^n mod m
function _powermod(a, n::S, m) where {S<:Integer}
## basically powermod in intfuncs.jl with wider type signatures
n < 0 && throw(DomainError())
n == 0 && return one(m)
_,b = divrem(a,m)
iszero(b) && return b
t = prevpow(2,n)::S
local r = one(a)
while true
if n >= t
_,r = divrem(r * b, m)
n -= t
end
t >>>= 1
t <= 0 && break
_,r = divrem(r * r, m)
end
r
end
| PolynomialFactors | https://github.com/jverzani/PolynomialFactors.jl.git |
|
[
"MIT"
] | 0.3.2 | 3d6d7432a5fba335d09e704ae387be3c15146bc6 | code | 87 | using PolynomialFactors
using Test
include("test-utils.jl")
include("test-factor.jl")
| PolynomialFactors | https://github.com/jverzani/PolynomialFactors.jl.git |
|
[
"MIT"
] | 0.3.2 | 3d6d7432a5fba335d09e704ae387be3c15146bc6 | code | 3219 | using PolynomialFactors
using AbstractAlgebra
P = PolynomialFactors
## Wilkinson (good out to 50 or so, then issues)
@testset "Test factor over Poly{Int}" begin
## test of factoring over Z[x]
R, x = ZZ["x"]
f = (x-1)*(x-2)*(x-3)
U = P.poly_factor(f)
@test prod(collect(keys(U))) - f == zero(x)
f = (x-1)*(x-2)^2*(x-3)^3
U = P.poly_factor(f)
@test U[x-3] == 3
@test f - prod([k^v for (k,v) in U]) == zero(f)
f = (x-2)*(3x-4)^2*(6x-7)^2
U = P.poly_factor(f)
@test U[6x-7] == 2
f = (x^5 - x - 1)
U = P.poly_factor(f)
@test U[f] == 1
f = x^4
U = P.poly_factor(f)
@test U[x] == 4
d = Dict(x-1 => 3, 2x-3=>4, x^2+x+1=>3)
f = prod([k^v for (k,v) in d])
U = P.poly_factor(f)
for (k,val) in d
@test U[k] == val
end
end
@testset "Test factor over Poly{BigInt}" begin
## BigInt
## issue #40 in Roots.jl
R,x = ZZ["x"]
f = x^2 - big(2)^256
U = P.poly_factor(f)
@test U[x - big(2)^128] == 1
p = x^15 - 1
@test length(P.poly_factor(p)) == 4
p = 1 + x^3 + x^6 + x^9 + x^12
@test length(P.poly_factor(p)) == 2
@test p - prod([k^v for (k,v) in P.poly_factor(p)]) == zero(p)
W(n) = prod([x-i for i in 1:20])
U = P.poly_factor(W(20))
@test U[x-5] == 1
## Swinnerton-Dyer Polys are slow to resolve, as over `p` they factor into linears, but over Z are irreducible.
## so the "fish out" step exhausts all possibilities.
S1 = x^2 - 2
U = P.poly_factor(S1)
@test U[S1] == 1
S2 = x^4 - 10*x^2 + 1
U = P.poly_factor(S2)
@test U[S2] == 1
S3 = x^8 - 40x^6 + 352x^4 - 960x^2 + 576
U = P.poly_factor(S3)
@test length(U) == 1
## Cyclotomic polys are irreducible over Z[x] too (https://en.wikipedia.org/wiki/Cyclotomic_polynomial)
C5 = x^4 + x^3 + x^2 + x + 1
U = P.poly_factor(C5)
@test U[C5] == 1
C10 = x^4 - x^3 + x^2 -x + 1
U = P.poly_factor(C10)
@test U[C10] == 1
C15 = x^8 - x^7 + x^5 - x^4 + x^3 - x + 1
U = P.poly_factor(C15)
@test U[C15] == 1
C25 = x^20 + x^15 + x^10 + x^5 + 1
U = P.poly_factor(C25)
@test U[C25] == 1
println("Test factor over Poly{Rational{BigInt}}")
## Rational
R,x = QQ["x"]
f = -17 * (x - 1//2)^3 * (x-3//4)^4
U = P.poly_factor(f)
@test U[-1 + 2x] == 3
@test f - prod([k^v for (k,v) in P.poly_factor(f)]) == zero(f)
end
# @testset "Test rational_roots" begin
# ### Rational roots
# R,x = ZZ["x"]
# W(n) = prod([x-i for i in 1:20])
# V = rational_roots(W(20))
# @test all(V .== 1:20)
# f = (2x-3)^4 * (5x-6)^7
# V = rational_roots(f)
# @test 3//2 in V
# @test 6//5 in V
# end
@testset "Test factormod" begin
## factormod
R,x = ZZ["x"]
# factormod has elements in GF(q)
C10 = x^4 - x^3 + x^2 -x + 1
U = P.factormod(C10, 5)
# (1+x)^4
@test length(U) == 1
C25 = x^20 + x^15 + x^10 + x^5 + 1
U = P.factormod(C25, 5)
# (x+4)^20
@test length(U) == 1
U = P.factormod(x^4 + 1, 5)
# (x^2+2)*(x^2+3)
@test length(U) == 2
U = P.factormod(x^4 + 1, 2)
# (x+1)^4
@test length(U) == 1
p = 5x^5 - x^4 - 1
U = P.factormod(p, 7)
# 5 * (x^4+3*x^3+4*x^2+3*x+4) * (x + 1)
V = 5 * (x^4+3*x^3+4*x^2+3*x+4) * (x + 1)
vs = PolynomialFactors.poly_coeffs(V)
ps = PolynomialFactors.poly_coeffs(p)
## v-p is not zero, v-pmod 7 should be:
@test !all(iszero(vs - ps))
@test all(iszero.(mod.(vs-ps,7)))
end
| PolynomialFactors | https://github.com/jverzani/PolynomialFactors.jl.git |
|
[
"MIT"
] | 0.3.2 | 3d6d7432a5fba335d09e704ae387be3c15146bc6 | code | 111 | using PolynomialFactors
## utils
@testset "Testing utils.jl" begin
## XXX TODO: add more tests here
end
| PolynomialFactors | https://github.com/jverzani/PolynomialFactors.jl.git |
|
[
"MIT"
] | 0.3.2 | 3d6d7432a5fba335d09e704ae387be3c15146bc6 | docs | 4233 | # PolynomialFactors
**This package needs updating**. It currently only passes tests on `v0.10` of `AbstractAlgebra`.
----
A package for factoring polynomials with integer or rational coefficients over the integers.
For polynomials over the integers or rational numbers, this package provides
* a `factor` command to factor into irreducible factors over the integers;
* a `rational_roots` function to return the rational roots;
* a `powermod` function to factor the polynomial over Z/pZ.
The implementation is based on the Cantor-Zassenhaus approach, as
detailed in Chapters 14 and 15 of the excellent text *Modern Computer Algebra* by von zer
Gathen and Gerhard and a paper by Beauzamy, Trevisan, and Wang.
The factoring solutions in `SymPy.jl` or `Nemo.jl` would be preferred,
in general, especially for larger problems (degree 30 or more, say) where the performance here is not good. However, this package
requires no additional external libraries. (PRs improving performance are most welcome.)
Examples:
```
julia> using AbstractAlgebra, PolynomialFactors;
julia> R, x = ZZ["x"];
julia> p = prod(x .-[1,1,3,3,3,3,5,5,5,5,5,5])
x^12-44*x^11+874*x^10-10348*x^9+81191*x^8-443800*x^7+1728556*x^6-4818680*x^5+9505375*x^4-12877500*x^3+11306250*x^2-5737500*x+1265625
julia> poly_factor(p)
Dict{AbstractAlgebra.Generic.Poly{BigInt},Int64} with 3 entries:
x-5 => 6
x-1 => 2
x-3 => 4
```
As can be seen `factor` returns a dictionary whose keys are
irreducible factors of the polynomial `p` as `Polynomial` objects, the
values being their multiplicity. If the polynomial is non-monic, a
degree $0$ polynomial is there so that the original polynomial can be
recovered as the product `prod(k^v for (k,v) in poly_factor(p))`.
Here we construct the polynomial in terms of a variable `x`:
```
julia> poly_factor((x-1)^2 * (x-3)^4 * (x-5)^6)
Dict{AbstractAlgebra.Generic.Poly{BigInt},Int64} with 3 entries:
x-5 => 6
x-1 => 2
x-3 => 4
```
Factoring over the rationals is really done over the integers, The
first step is to find a common denominator for the coefficients. The
constant polynomial term reflects this.
```
julia> R, x = QQ["x"]
(Univariate Polynomial Ring in x over Rationals, x)
julia> poly_factor( (1//2 - x)^2 * (1//3 - 1//4 * x)^5 )
Dict{AbstractAlgebra.Generic.Poly{Rational{BigInt}},Int64} with 3 entries:
2//1*x-1//1 => 2
3//1*x-4//1 => 5
-1//995328 => 1
```
For some problems big integers are necessary to express the problem:
```
julia> p = prod(x .- collect(1:20))
x^20-210*x^19+20615*x^18-1256850*x^17+53327946*x^16-1672280820*x^15+40171771630*x^14-756111184500*x^13+11310276995381*x^12-135585182899530*x^11+1307535010540395*x^10-10142299865511450*x^9+63030812099294896*x^8-311333643161390640*x^7+1206647803780373360*x^6-3599979517947607200*x^5+8037811822645051776*x^4-12870931245150988800*x^3+13803759753640704000*x^2-8752948036761600000*x+2432902008176640000
julia> poly_factor(p)
Dict{AbstractAlgebra.Generic.Poly{BigInt},Int64} with 20 entries:
x-15 => 1
x-18 => 1
x-17 => 1
x-9 => 1
x-5 => 1
x-14 => 1
x-7 => 1
x-13 => 1
x-11 => 1
x-2 => 1
x-12 => 1
x-1 => 1
x-3 => 1
x-8 => 1
x-10 => 1
x-4 => 1
x-19 => 1
x-16 => 1
x-6 => 1
x-20 => 1
```
```
julia> poly_factor(x^2 - big(2)^256)
Dict{AbstractAlgebra.Generic.Poly{BigInt},Int64} with 2 entries:
x+340282366920938463463374607431768211456 => 1
x-340282366920938463463374607431768211456 => 1
```
Factoring polynomials over a finite field of coefficients, `Z_p[x]` with `p` a prime, is also provided by `factormod`:
```
julia> factormod(x^4 + 1, 2)
Dict{AbstractAlgebra.Generic.Poly{AbstractAlgebra.gfelem{BigInt}},Int64} with 1 entry:
x+1 => 4
julia> factormod(x^4 + 1, 5)
Dict{AbstractAlgebra.Generic.Poly{AbstractAlgebra.gfelem{BigInt}},Int64} with 2 entries:
x^2+3 => 1
x^2+2 => 1
julia> factormod(x^4 + 1, 3)
Dict{AbstractAlgebra.Generic.Poly{AbstractAlgebra.gfelem{BigInt}},Int64} with 2 entries:
x^2+x+2 => 1
x^2+2*x+2 => 1
julia> factormod(x^4 + 1, 7)
Dict{AbstractAlgebra.Generic.Poly{AbstractAlgebra.gfelem{BigInt}},Int64} with 2 entries:
x^2+3*x+1 => 1
x^2+4*x+1 => 1
```
The keys are polynomials a finite group, not over the integers.
| PolynomialFactors | https://github.com/jverzani/PolynomialFactors.jl.git |
|
[
"MIT"
] | 0.1.7 | f133fab380933d042f6796eda4e130272ba520ca | code | 409 | using Documenter, TerminalLoggers
makedocs(;
modules=[TerminalLoggers],
format=Documenter.HTML(),
pages=[
"Home" => "index.md",
],
repo="https://github.com/c42f/TerminalLoggers.jl/blob/{commit}{path}#L{line}",
sitename="TerminalLoggers.jl",
authors="Chris Foster <[email protected]>"
)
deploydocs(;
repo="github.com/c42f/TerminalLoggers.jl",
push_preview=true
)
| TerminalLoggers | https://github.com/JuliaLogging/TerminalLoggers.jl.git |
|
[
"MIT"
] | 0.1.7 | f133fab380933d042f6796eda4e130272ba520ca | code | 1201 | Base.@kwdef mutable struct ProgressBar
fraction::Union{Float64,Nothing}
name::String
level::Int = 0
barglyphs::BarGlyphs = BarGlyphs()
tlast::Float64 = time()
tfirst::Float64 = time()
id::UUID
parentid::UUID
end
set_fraction!(bar::ProgressBar, ::Nothing) = bar
function set_fraction!(bar::ProgressBar, fraction::Real)
bar.tlast = time()
bar.fraction = fraction
return bar
end
# This is how `ProgressMeter.printprogress` decides "ETA" vs "Time":
ensure_done!(bar::ProgressBar) = bar.fraction = 1
function eta_seconds(bar)
total = (bar.tlast - bar.tfirst) / something(bar.fraction, NaN)
return total - (time() - bar.tfirst)
end
function printprogress(io::IO, bar::ProgressBar)
if bar.name == ""
desc = "Progress: "
else
desc = bar.name
if !endswith(desc, " ")
desc *= " "
end
end
pad = " "^bar.level
print(io, pad)
lines, columns = displaysize(io)
ProgressMeter.printprogress(
IOContext(io, :displaysize => (lines, max(1, columns - length(pad)))),
bar.barglyphs,
bar.tfirst,
desc,
bar.fraction,
eta_seconds(bar),
)
end
| TerminalLoggers | https://github.com/JuliaLogging/TerminalLoggers.jl.git |
|
[
"MIT"
] | 0.1.7 | f133fab380933d042f6796eda4e130272ba520ca | code | 4983 | """
StickyMessages(io::IO; ansi_codes=io isa Base.TTY &&
(!Sys.iswindows() || VERSION >= v"1.5.3"))
A `StickyMessages` type manages the display of a set of persistent "sticky"
messages in a terminal. That is, messages which are not part of the normal
scrolling output. Each message is identified by a label and may may be added to
the set using `push!(messages, label=>msg)`, and removed using
`pop!(messages, label)`, or `empty!()`.
Only a single StickyMessages object should be associated with a given TTY, as
the object manipulates the terminal scrolling region.
"""
mutable struct StickyMessages
io::IO
# Bool for controlling TTY escape codes.
ansi_codes::Bool
# Messages is just used as a (short) OrderedDict here
messages::Vector{Pair{Any,String}}
end
function StickyMessages(io::IO; ansi_codes=io isa Base.TTY &&
# scroll region code on Windows only works with recent libuv, present in 1.5.3+
(!Sys.iswindows() || VERSION >= v"1.5.3"))
sticky = StickyMessages(io, ansi_codes, Vector{Pair{Any,String}}())
# Ensure we clean up the terminal
finalizer(sticky) do sticky
# See also empty!()
if !sticky.ansi_codes
return
end
prev_nlines = _countlines(sticky.messages)
if prev_nlines > 0
# Clean up sticky lines. Hack: must be async to do the IO outside
# of finalizer. Proper fix would be an uninstall event triggered by
# with_logger.
@async showsticky(sticky.io, prev_nlines, [])
end
end
sticky
end
# Count newlines in a message or sequence of messages
_countlines(msg::String) = sum(c->c=='\n', msg)
_countlines(messages) = length(messages) > 0 ? sum(_countlines, messages) : 0
_countlines(messages::Vector{<:Pair}) = _countlines(m[2] for m in messages)
# Selected TTY cursor and screen control via ANSI codes
# * https://en.wikipedia.org/wiki/ANSI_escape_code#CSI_sequences
# * See man terminfo on linux, eg `tput csr $row1 $row2` and `tput cup $row $col`
# * For windows see https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences
change_scroll_region!(io, rows::Pair) = write(io, "\e[$(rows[1]);$(rows[2])r")
change_cursor_line!(io, line::Integer) = write(io, "\e[$line;1H")
clear_to_end!(io) = write(io, "\e[J")
function showsticky(io, prev_nlines, messages)
height,_ = displaysize(io)
iob = IOBuffer()
if prev_nlines > 0
change_cursor_line!(iob, height + 1 - prev_nlines)
clear_to_end!(iob)
end
# Set scroll region to the first N lines.
#
# Terminal scrollback buffers seem to be populated with a heuristic which
# relies on the scrollable region starting at the first row, so to have
# normal scrollback work we have to position sticky messages at the bottom
# of the screen.
linesrequired = _countlines(messages)
if prev_nlines < linesrequired
# Scroll screen up to preserve the lines which we will overwrite
change_cursor_line!(iob, height - prev_nlines)
write(iob, "\n"^(linesrequired-prev_nlines))
end
if prev_nlines != linesrequired
change_scroll_region!(iob, 1=>height-linesrequired)
end
# Write messages. Avoid writing \n of last message to kill extra scrolling
if !isempty(messages)
change_cursor_line!(iob, height + 1 - linesrequired)
for i = 1:length(messages)-1
write(iob, messages[i][2])
end
write(iob, chop(messages[end][2]))
end
# TODO: Ideally we'd query the terminal for the line it was on before doing
# all this and restore it if it's not in the new non-scrollable region.
change_cursor_line!(iob, height - max(prev_nlines, linesrequired))
# Write in one block to make the whole operation as atomic as possible.
write(io, take!(iob))
nothing
end
function Base.push!(sticky::StickyMessages, message::Pair)
if !sticky.ansi_codes
println(sticky.io, rstrip(message[2]))
return
end
label,text = message
endswith(text, '\n') || (text *= '\n';)
prev_nlines = _countlines(sticky.messages)
idx = findfirst(m->m[1] == label, sticky.messages)
if idx === nothing
push!(sticky.messages, label=>text)
else
sticky.messages[idx] = label=>text
end
showsticky(sticky.io, prev_nlines, sticky.messages)
end
function Base.pop!(sticky::StickyMessages, label)
sticky.ansi_codes || return
idx = findfirst(m->m[1] == label, sticky.messages)
if idx !== nothing
prev_nlines = _countlines(sticky.messages)
deleteat!(sticky.messages, idx)
showsticky(sticky.io, prev_nlines, sticky.messages)
end
nothing
end
function Base.empty!(sticky::StickyMessages)
sticky.ansi_codes || return
prev_nlines = _countlines(sticky.messages)
empty!(sticky.messages)
showsticky(sticky.io, prev_nlines, sticky.messages) # Resets scroll region
nothing
end
| TerminalLoggers | https://github.com/JuliaLogging/TerminalLoggers.jl.git |
|
[
"MIT"
] | 0.1.7 | f133fab380933d042f6796eda4e130272ba520ca | code | 12683 | using Markdown
"""
TerminalLogger(stream=stderr, min_level=$ProgressLevel; meta_formatter=default_metafmt,
show_limited=true, right_justify=0)
Logger with formatting optimized for interactive readability in a text console
(for example, the Julia REPL). This is an enhanced version of the terminal
logger `Logging.ConsoleLogger` which comes installed with Julia by default.
Log levels less than `min_level` are filtered out.
Message formatting can be controlled by setting keyword arguments:
* `meta_formatter` is a function which takes the log event metadata
`(level, _module, group, id, file, line)` and returns a color (as would be
passed to printstyled), prefix and suffix for the log message. The
default is to prefix with the log level and a suffix containing the module,
file and line location.
* `show_limited` limits the printing of large data structures to something
which can fit on the screen by setting the `:limit` `IOContext` key during
formatting.
* `right_justify` is the integer column which log metadata is right justified
at. The default is zero (metadata goes on its own line).
"""
struct TerminalLogger <: AbstractLogger
stream::IO
min_level::LogLevel
meta_formatter
show_limited::Bool
right_justify::Int
always_flush::Bool
margin::Int
message_limits::Dict{Any,Int}
sticky_messages::StickyMessages
bartrees::Vector{Node{ProgressBar}}
lock::ReentrantLock
end
function TerminalLogger(stream::IO=stderr, min_level=ProgressLevel;
meta_formatter=default_metafmt, show_limited=true,
right_justify=0, always_flush=false, margin=0)
TerminalLogger(
stream,
min_level,
meta_formatter,
show_limited,
right_justify,
always_flush,
margin,
Dict{Any,Int}(),
StickyMessages(stream),
Union{}[],
ReentrantLock()
)
end
function shouldlog(logger::TerminalLogger, level, _module, group, id)
lock(logger.lock) do
get(logger.message_limits, id, 1) > 0
end
end
min_enabled_level(logger::TerminalLogger) = logger.min_level
function default_logcolor(level)
level < Info ? :blue :
level < Warn ? Base.info_color() :
level < Error ? Base.warn_color() :
Base.error_color()
end
function default_metafmt(level, _module, group, id, file, line)
color = default_logcolor(level)
prefix = (level == Warn ? "Warning" : string(level))*':'
suffix = ""
Info <= level < Warn && return color, prefix, suffix
_module !== nothing && (suffix *= "$(_module)")
if file !== nothing
_module !== nothing && (suffix *= " ")
suffix *= string(file)
if line !== nothing
suffix *= ":$(isa(line, UnitRange) ? "$(first(line))-$(last(line))" : line)"
end
end
!isempty(suffix) && (suffix = "@ " * suffix)
return color, prefix, suffix
end
# Length of a string as it will appear in the terminal (after ANSI color codes
# are removed)
function termlength(str)
N = 0
in_esc = false
for c in str
if in_esc
if c == 'm'
in_esc = false
end
else
if c == '\e'
in_esc = true
else
N += 1
end
end
end
return N
end
function format_message(message, prefix_width, io_context)
formatted = sprint(show, MIME"text/plain"(), message, context=io_context)
msglines = split(chomp(formatted), '\n')
if length(msglines) > 1
# For multi-line messages it's possible that the message was carefully
# formatted with vertical alignemnt. Therefore we play it safe by
# prepending a blank line.
pushfirst!(msglines, SubString(""))
end
msglines
end
function format_message(message::AbstractString, prefix_width, io_context)
# For strings, use Markdown to do the formatting. The markdown renderer
# isn't very composable with other text formatting so this is quite hacky.
message = Markdown.parse(message)
prepend_prefix = !isempty(message.content) &&
message.content[1] isa Markdown.Paragraph
if prepend_prefix
# Hack: We prepend the prefix here to allow the markdown renderer to be
# aware of the indenting which will result from prepending the prefix.
# Without this we will get many issues of broken vertical alignment.
# Avoid collisions: using placeholder from unicode private use area
placeholder = '\uF8FF'^prefix_width
pushfirst!(message.content[1].content, placeholder)
end
formatted = sprint(show, MIME"text/plain"(), message, context=io_context)
msglines = split(chomp(formatted), '\n')
# Hack': strip left margin which can't be configured in Markdown
# terminal rendering.
msglines = [startswith(s, " ") ? s[3:end] : s for s in msglines]
if prepend_prefix
# Hack'': Now remove the prefix from the rendered markdown.
msglines[1] = replace(msglines[1], placeholder=>""; count=1)
elseif !isempty(msglines[1])
pushfirst!(msglines, SubString(""))
end
msglines
end
# Formatting of values in key value pairs
function showvalue(io, key, msg)
if key === :exception && msg isa Vector && length(msg) > 1 && msg[1] isa Tuple{Exception,Any}
if VERSION >= v"1.2"
# Ugly code path to support passing exception=Base.catch_stack()
# `Base.ExceptionStack` was only introduced in Julia 1.7.0-DEV.1106
# https://github.com/JuliaLang/julia/pull/29901 (dispatched on below).
Base.show_exception_stack(io, msg)
else
# v1.0 and 1.1 don't have Base.show_exception_stack
show(io, MIME"text/plain"(), msg)
end
else
show(io, MIME"text/plain"(), msg)
end
end
function showvalue(io, key, e::Tuple{Exception,Any})
ex,bt = e
showerror(io, ex, bt; backtrace = bt!==nothing)
end
showvalue(io, key, ex::Exception) = showerror(io, ex)
# Generate a text representation of all key value pairs, split into lines with
# per-line indentation as an integer.
function format_key_value_pairs(kwargs, io_context)
msglines = Tuple{Int,String}[]
valbuf = IOBuffer()
dsize = displaysize(io_context)
rows_per_value = max(1, dsize[1]÷(length(kwargs)+1))
valio = IOContext(valbuf, IOContext(io_context, :displaysize=>(rows_per_value,dsize[2]-3)))
for (key,val) in kwargs
showvalue(valio, key, val)
vallines = split(String(take!(valbuf)), '\n')
if length(vallines) == 1
push!(msglines, (2,SubString("$key = $(vallines[1])")))
else
push!(msglines, (2,SubString("$key =")))
append!(msglines, ((3,line) for line in vallines))
end
end
msglines
end
function findbar(bartree, id)
if !(bartree isa AbstractArray)
bartree.data.id === id && return bartree
end
for node in bartree
found = findbar(node, id)
found === nothing || return found
end
return nothing
end
function foldtree(op, acc, tree)
for node in tree
acc = foldtree(op, acc, node)
end
if !(tree isa AbstractArray)
acc = op(acc, tree)
end
return acc
end
const BAR_MESSAGE_ID = gensym(:BAR_MESSAGE_ID)
function handle_progress(logger, progress, kwargs)
node = findbar(logger.bartrees, progress.id)
if node === nothing
# Don't do anything when it's already done:
(progress.done || something(progress.fraction, 0.0) >= 1) && return
parentnode = findbar(logger.bartrees, progress.parentid)
bar = ProgressBar(
fraction = progress.fraction,
name = progress.name,
id = progress.id,
parentid = progress.parentid,
)
if parentnode === nothing
node = Node(bar)
pushfirst!(logger.bartrees, node)
else
bar.level = parentnode.data.level + 1
node = addchild(parentnode, bar)
end
else
bar = node.data
set_fraction!(bar, progress.fraction)
if progress.name != ""
bar.name = progress.name
end
node.data = bar
end
if progress.done
if isroot(node)
deleteat!(logger.bartrees, findfirst(x -> x === node, logger.bartrees))
else
prunebranch!(node)
end
end
bartxt = sprint(context = :displaysize => displaysize(logger.stream)) do io
foldtree(true, logger.bartrees) do isfirst, node
isfirst || println(io)
printprogress(io, node.data)
false # next `isfirst`
end
end
if isempty(bartxt)
pop!(logger.sticky_messages, BAR_MESSAGE_ID)
else
bartxt = sprint(context = logger.stream) do io
printstyled(io, bartxt; color=:green)
end
push!(logger.sticky_messages, BAR_MESSAGE_ID => bartxt)
end
# "Flushing" non-sticky message should be done after the sticky
# message is re-drawn:
if progress.done
ensure_done!(bar)
donetxt = sprint(context = :displaysize => displaysize(logger.stream)) do io
printprogress(io, bar)
end
printstyled(logger.stream, donetxt; color=:light_black)
println(logger.stream)
end
if logger.always_flush
flush(logger.stream)
end
end
function handle_message(logger::TerminalLogger, level, message, _module, group, id,
filepath, line; maxlog=nothing,
sticky=nothing, kwargs...)
if maxlog !== nothing && maxlog isa Integer
remaining = 0
lock(logger.lock) do
remaining = get!(logger.message_limits, id, maxlog)
logger.message_limits[id] = remaining - 1
end
remaining > 0 || return
end
progress = asprogress(level, message, _module, group, id, filepath, line; kwargs...)
if progress !== nothing
lock(logger.lock) do
handle_progress(logger, progress, kwargs)
end
return
end
color,prefix,suffix = logger.meta_formatter(level, _module, group, id, filepath, line)
# Generate a text representation of the message
dsize = displaysize(logger.stream)
context = IOContext(logger.stream, :displaysize=>(dsize[1],dsize[2]-2))
msglines = format_message(message, textwidth(prefix), context)
# Add indentation level
msglines = [(0,l) for l in msglines]
if !isempty(kwargs)
ctx = logger.show_limited ? IOContext(context, :limit=>true) : context
append!(msglines, format_key_value_pairs(kwargs, ctx))
end
# Format lines as text with appropriate indentation and with a box
# decoration on the left.
minsuffixpad = 2
buf = IOBuffer()
iob = IOContext(buf, logger.stream)
nonpadwidth = 2 + (isempty(prefix) || length(msglines) > 1 ? 0 : length(prefix)+1) +
msglines[end][1] + termlength(msglines[end][2]) +
(isempty(suffix) ? 0 : length(suffix)+minsuffixpad)
justify_width = min(logger.right_justify, dsize[2])
if nonpadwidth > justify_width && !isempty(suffix)
push!(msglines, (0,SubString("")))
minsuffixpad = 0
nonpadwidth = 2 + length(suffix)
end
for (i,(indent,msg)) in enumerate(msglines)
boxstr = length(msglines) == 1 ? "[ " :
i == 1 ? "┌ " :
i < length(msglines) ? "│ " :
"└ "
printstyled(iob, boxstr, bold=true, color=color)
if i == 1 && !isempty(prefix)
printstyled(iob, prefix, " ", bold=true, color=color)
end
print(iob, " "^indent, msg)
if i == length(msglines) && !isempty(suffix)
npad = max(0, justify_width - nonpadwidth) + minsuffixpad
print(iob, " "^npad)
printstyled(iob, suffix, color=:light_black)
end
println(iob)
end
if sticky === nothing
for _ in 1:logger.margin
println(iob)
end
end
msg = take!(buf)
lock(logger.lock) do
if sticky !== nothing
# Ensure we see the last message, even if it's :done
push!(logger.sticky_messages, id=>String(msg))
if sticky == :done
pop!(logger.sticky_messages, id)
end
else
write(logger.stream, msg)
end
if logger.always_flush
flush(logger.stream)
end
end
nothing
end
| TerminalLoggers | https://github.com/JuliaLogging/TerminalLoggers.jl.git |
|
[
"MIT"
] | 0.1.7 | f133fab380933d042f6796eda4e130272ba520ca | code | 742 | module TerminalLoggers
@doc let path = joinpath(dirname(@__DIR__), "README.md")
include_dependency(path)
replace(read(path, String), "```julia" => "```jldoctest")
end TerminalLoggers
using Logging:
AbstractLogger,
LogLevel, BelowMinLevel, Debug, Info, Warn, Error, AboveMaxLevel
import Logging:
handle_message, shouldlog, min_enabled_level, catch_exceptions
using LeftChildRightSiblingTrees: Node, addchild, isroot, prunebranch!
using ProgressLogging: asprogress
using UUIDs: UUID
export TerminalLogger
const ProgressLevel = LogLevel(-1)
include("ProgressMeter/ProgressMeter.jl")
using .ProgressMeter:
BarGlyphs
include("StickyMessages.jl")
include("ProgressBar.jl")
include("TerminalLogger.jl")
end # module
| TerminalLoggers | https://github.com/JuliaLogging/TerminalLoggers.jl.git |
|
[
"MIT"
] | 0.1.7 | f133fab380933d042f6796eda4e130272ba520ca | code | 3535 | module ProgressMeter
using Printf: @printf, @sprintf
"""
Holds the five characters that will be used to generate the progress bar.
"""
mutable struct BarGlyphs
leftend::Char
fill::Char
front::Union{Vector{Char}, Char}
empty::Char
rightend::Char
end
BarGlyphs() = BarGlyphs(
'|',
'█',
Sys.iswindows() ? '█' : ['▏', '▎', '▍', '▌', '▋', '▊', '▉'],
' ',
'|',
)
"""
printprogress(io::IO, barglyphs::BarGlyphs, tfirst::Float64, desc, progress, eta_seconds::Real)
Print progress bar to `io`.
# Arguments
- `io::IO`
- `barglyphs::BarGlyphs`
- `tfirst::Float64`
- `desc`: description to be printed at left side of progress bar.
- `progress`: a number between 0 and 1 or `nothing`.
- `eta_seconds::Real`: ETA in seconds
"""
function printprogress(
io::IO,
barglyphs::BarGlyphs,
tfirst::Float64,
desc,
progress,
eta_seconds::Real,
)
t = time()
percentage_complete = 100.0 * (isnothing(progress) || isnan(progress) ? 0.0 : progress)
#...length of percentage and ETA string with days is 29 characters
barlen = max(0, displaysize(io)[2] - (length(desc) + 29))
if !isnothing(progress) && progress >= 1
bar = barstring(barlen, percentage_complete, barglyphs=barglyphs)
dur = durationstring(t - tfirst)
@printf io "%s%3u%%%s Time: %s" desc round(Int, percentage_complete) bar dur
return
end
bar = barstring(barlen, percentage_complete, barglyphs=barglyphs)
if 0 <= eta_seconds <= typemax(Int)
eta_sec = round(Int, eta_seconds)
eta = durationstring(eta_sec)
else
eta = "N/A"
end
@printf io "%s%3u%%%s ETA: %s" desc round(Int, percentage_complete) bar eta
return
end
function compute_front(barglyphs::BarGlyphs, frac_solid::AbstractFloat)
barglyphs.front isa Char && return barglyphs.front
idx = round(Int, frac_solid * (length(barglyphs.front) + 1))
return idx > length(barglyphs.front) ? barglyphs.fill :
idx == 0 ? barglyphs.empty :
barglyphs.front[idx]
end
function barstring(barlen, percentage_complete; barglyphs)
bar = ""
if barlen>0
if percentage_complete == 100 # if we're done, don't use the "front" character
bar = string(barglyphs.leftend, repeat(string(barglyphs.fill), barlen), barglyphs.rightend)
else
n_bars = barlen * percentage_complete / 100
nsolid = trunc(Int, n_bars)
frac_solid = n_bars - nsolid
nempty = barlen - nsolid - 1
bar = string(barglyphs.leftend,
repeat(string(barglyphs.fill), max(0,nsolid)),
compute_front(barglyphs, frac_solid),
repeat(string(barglyphs.empty), max(0, nempty)),
barglyphs.rightend)
end
end
bar
end
function durationstring(nsec)
days = div(nsec, 60*60*24)
r = nsec - 60*60*24*days
hours = div(r,60*60)
r = r - 60*60*hours
minutes = div(r, 60)
seconds = floor(r - 60*minutes)
hhmmss = @sprintf "%u:%02u:%02u" hours minutes seconds
if days>9
return @sprintf "%.2f days" nsec/(60*60*24)
elseif days>0
return @sprintf "%u days, %s" days hhmmss
end
hhmmss
end
# issue #31: isnothing require Julia 1.1
# copy-over from
# https://github.com/JuliaLang/julia/blob/0413ef0e4de83b41b637ba02cc63314da45fe56b/base/some.jl
if !isdefined(Base, :isnothing)
isnothing(::Any) = false
isnothing(::Nothing) = true
end
end
| TerminalLoggers | https://github.com/JuliaLogging/TerminalLoggers.jl.git |
|
[
"MIT"
] | 0.1.7 | f133fab380933d042f6796eda4e130272ba520ca | code | 2567 | using TerminalLoggers: StickyMessages
@testset "Sticky messages without ANSI codes" begin
buf = IOBuffer()
# Without TTY, messages are just piped through
stickies = StickyMessages(buf, ansi_codes=false)
push!(stickies, :a=>"Msg\n")
@test String(take!(buf)) == "Msg\n"
push!(stickies, :a=>"Msg\n")
@test String(take!(buf)) == "Msg\n"
pop!(stickies, :a)
@test String(take!(buf)) == ""
end
@testset "Sticky messages with ANSI codes" begin
buf = IOBuffer()
dsize = (20, 80) # Intentionally different from default of 25 rows
# In TTY mode, we generate various escape codes.
stickies = StickyMessages(IOContext(buf, :displaysize=>dsize), ansi_codes=true)
push!(stickies, :a=>"Msg\n")
@test String(take!(buf)) == #scroll #csr #pos #msg #pos
"\e[20;1H\n\e[1;19r\e[20;1HMsg\e[19;1H"
push!(stickies, :a=>"MsgMsg\n")
@test String(take!(buf)) == #clear #msgpos #msg #repos
"\e[20;1H\e[J\e[20;1HMsgMsg\e[19;1H"
push!(stickies, :b=>"BBB\n")
@test String(take!(buf)) ==
#clear #scroll #csr #pos #msgs #pos
"\e[20;1H\e[J\e[19;1H\n\e[1;18r\e[19;1HMsgMsg\nBBB\e[18;1H"
pop!(stickies, :a)
@test String(take!(buf)) == #clear #csr #pos #msg #pos
"\e[19;1H\e[J\e[1;19r\e[20;1HBBB\e[18;1H"
pop!(stickies, :b)
@test String(take!(buf)) == #clear #csr #pos
"\e[20;1H\e[J\e[1;20r\e[19;1H"
pop!(stickies, :b)
@test String(take!(buf)) == ""
push!(stickies, :a=>"αβγ\n")
@test String(take!(buf)) == #scroll #csr #pos #msg #pos
"\e[20;1H\n\e[1;19r\e[20;1Hαβγ\e[19;1H"
push!(stickies, :b=>"msg\n")
take!(buf)
# Remove all two messages
empty!(stickies)
@test String(take!(buf)) == #clear #csr #pos
"\e[19;1H\e[J\e[1;20r\e[18;1H"
end
@testset "Sticky messages with ANSI codes" begin
buf = IOBuffer()
dsize = (20, 80) # Intentionally different from default of 25 rows
stickies = StickyMessages(IOContext(buf, :displaysize=>dsize), ansi_codes=true)
push!(stickies, :a=>"a-msg\n")
push!(stickies, :b=>"b-msg\n")
take!(buf)
finalize(stickies)
# Hack to allow StickyMessages async cleanup to run
for i=1:1000
yield()
end
@test String(take!(buf)) == #clear #csr #pos
"\e[19;1H\e[J\e[1;20r\e[18;1H"
end
| TerminalLoggers | https://github.com/JuliaLogging/TerminalLoggers.jl.git |
|
[
"MIT"
] | 0.1.7 | f133fab380933d042f6796eda4e130272ba520ca | code | 15702 | using TerminalLoggers: default_metafmt, format_message
using ProgressLogging
@noinline func1() = backtrace()
function dummy_metafmt(level, _module, group, id, file, line)
:cyan,"PREFIX","SUFFIX"
end
# Log formatting
function genmsgs(events; level=Info, _module=Main,
file="some/path.jl", line=101, color=false, width=75,
meta_formatter=dummy_metafmt, show_limited=true,
right_justify=0)
buf = IOBuffer()
io = IOContext(buf, :displaysize=>(30,width), :color=>color)
logger = TerminalLogger(io, Debug,
meta_formatter=meta_formatter,
show_limited=show_limited,
right_justify=right_justify)
prev_have_color = Base.have_color
return map(events) do (message, kws)
kws = Dict(pairs(kws))
id = pop!(kws, :_id, :an_id)
# Avoid markdown formatting while testing layouting. Don't wrap
# progress messages though; ProgressLogging.asprogress() doesn't
# like that.
is_progress = message isa Progress || haskey(kws, :progress)
handle_message(logger, level, message, _module, :a_group, id,
file, line; kws...)
String(take!(buf))
end
end
function genmsg(message; kwargs...)
kws = Dict(kwargs)
logconfig = Dict(
k => pop!(kws, k)
for k in [
:level,
:_module,
:file,
:line,
:color,
:width,
:meta_formatter,
:show_limited,
:right_justify,
] if haskey(kws, k)
)
return genmsgs([(message, kws)]; logconfig...)[1]
end
@testset "TerminalLogger" begin
# First pass log limiting
@test min_enabled_level(TerminalLogger(devnull, Debug)) == Debug
@test min_enabled_level(TerminalLogger(devnull, Error)) == Error
# Second pass log limiting
logger = TerminalLogger(devnull)
@test shouldlog(logger, Info, Base, :group, :asdf) === true
handle_message(logger, Info, "msg", Base, :group, :asdf, "somefile", 1, maxlog=2)
@test shouldlog(logger, Info, Base, :group, :asdf) === true
handle_message(logger, Info, "msg", Base, :group, :asdf, "somefile", 1, maxlog=2)
@test shouldlog(logger, Info, Base, :group, :asdf) === false
@testset "Default metadata formatting" begin
@test default_metafmt(Info, Main, :g, :i, "a.jl", 1) ==
(:cyan, "Info:", "")
@test default_metafmt(Warn, Main, :g, :i, "b.jl", 2) ==
(:yellow, "Warning:", "@ Main b.jl:2")
@test default_metafmt(Error, Main, :g, :i, "", 0) ==
(:light_red, "Error:", "@ Main :0")
# formatting of nothing
@test default_metafmt(Warn, nothing, :g, :i, "b.jl", 2) ==
(:yellow, "Warning:", "@ b.jl:2")
@test default_metafmt(Warn, Main, :g, :i, nothing, 2) ==
(:yellow, "Warning:", "@ Main")
@test default_metafmt(Warn, Main, :g, :i, "b.jl", nothing) ==
(:yellow, "Warning:", "@ Main b.jl")
@test default_metafmt(Warn, nothing, :g, :i, nothing, 2) ==
(:yellow, "Warning:", "")
@test default_metafmt(Warn, Main, :g, :i, "b.jl", 2:5) ==
(:yellow, "Warning:", "@ Main b.jl:2-5")
end
# Basic tests for the default setup
@test genmsg("msg", level=Info, meta_formatter=default_metafmt) ==
"""
[ Info: msg
"""
@test genmsg("msg", level=Warn, _module=Base,
file="other.jl", line=42, meta_formatter=default_metafmt) ==
"""
┌ Warning: msg
└ @ Base other.jl:42
"""
# Full metadata formatting
@test genmsg("msg", level=Debug,
meta_formatter=(level, _module, group, id, file, line)->
(:white,"Foo!", "$level $_module $group $id $file $line")) ==
"""
┌ Foo! msg
└ Debug Main a_group an_id some/path.jl 101
"""
@testset "Prefix and suffix layout" begin
@test genmsg("") ==
replace("""
┌ PREFIX EOL
└ SUFFIX
""", "EOL"=>"")
@test genmsg("msg") ==
"""
┌ PREFIX msg
└ SUFFIX
"""
# Behavior with empty prefix / suffix
@test genmsg("msg", meta_formatter=(args...)->(:white, "PREFIX", "")) ==
"""
[ PREFIX msg
"""
@test genmsg("msg", meta_formatter=(args...)->(:white, "", "SUFFIX")) ==
"""
┌ msg
└ SUFFIX
"""
end
@testset "Metadata suffix, right justification" begin
@test genmsg("xxx", width=20, right_justify=200) ==
"""
[ PREFIX xxx SUFFIX
"""
@test genmsg("xxxxxxxx xxxxxxxx", width=20, right_justify=200) ==
"""
┌ PREFIX xxxxxxxx
└ xxxxxxxx SUFFIX
"""
# When adding the suffix would overflow the display width, add it on
# the next line:
@test genmsg("xxxx", width=20, right_justify=200) ==
"""
┌ PREFIX xxxx
└ SUFFIX
"""
# Same for multiline messages
@test genmsg("""xxx
xxxxxxxxxx""", width=20, right_justify=200) ==
"""
┌ PREFIX xxx
└ xxxxxxxxxx SUFFIX
"""
@test genmsg("""xxx
xxxxxxxxxxx""", width=20, right_justify=200) ==
"""
┌ PREFIX xxx
│ xxxxxxxxxxx
└ SUFFIX
"""
# min(right_justify,width) is used
@test genmsg("xxx", width=200, right_justify=20) ==
"""
[ PREFIX xxx SUFFIX
"""
@test genmsg("xxxx", width=200, right_justify=20) ==
"""
┌ PREFIX xxxx
└ SUFFIX
"""
end
# Keywords
@test genmsg("msg", a=1, b="asdf") ==
"""
┌ PREFIX msg
│ a = 1
│ b = "asdf"
└ SUFFIX
"""
# Exceptions shown with showerror
@test genmsg("msg", exception=DivideError()) ==
"""
┌ PREFIX msg
│ exception = DivideError: integer division error
└ SUFFIX
"""
# Attaching backtraces
bt = func1()
@test startswith(genmsg("msg", exception=(DivideError(),bt)),
"""
┌ PREFIX msg
│ exception =
│ DivideError: integer division error
│ Stacktrace:""")
@test occursin("[1] func1", genmsg("msg", exception=(DivideError(),bt)))
# Exception stacks
if VERSION >= v"1.2"
excstack = try
error("Root cause")
catch
try
error("An exception")
catch
if VERSION >= v"1.7.0-DEV.1106"
current_exceptions()
else
Base.catch_stack()
end
end
end
@test occursin(r"An exception.*Stacktrace.*caused by.*Root cause.*Stacktrace"s,
genmsg("msg", exception=excstack))
end
@testset "Limiting large data structures" begin
a = fill(1.00001, 10,10)
b = fill(2.00002, 10,10)
@test genmsg("msg", a=a, b=b) ==
replace("""
┌ PREFIX msg
│ a =
│ $(summary(a)):
│ 1.00001 1.00001 1.00001 1.00001 … 1.00001 1.00001 1.00001
│ 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001
│ 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001
│ ⋮ ⋱ EOL
│ 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001
│ 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001
│ b =
│ $(summary(b)):
│ 2.00002 2.00002 2.00002 2.00002 … 2.00002 2.00002 2.00002
│ 2.00002 2.00002 2.00002 2.00002 2.00002 2.00002 2.00002
│ 2.00002 2.00002 2.00002 2.00002 2.00002 2.00002 2.00002
│ ⋮ ⋱ EOL
│ 2.00002 2.00002 2.00002 2.00002 2.00002 2.00002 2.00002
│ 2.00002 2.00002 2.00002 2.00002 2.00002 2.00002 2.00002
└ SUFFIX
""",
# EOL hack to work around git whitespace errors
# VERSION dependence due to JuliaLang/julia#33339
(VERSION < v"1.4-" ? "EOL" : " EOL")=>""
)
# Limiting the amount which is printed
@test genmsg("msg", a=a, show_limited=false) ==
"""
┌ PREFIX msg
│ a =
│ $(summary(a)):
│ 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001
│ 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001
│ 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001
│ 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001
│ 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001
│ 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001
│ 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001
│ 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001
│ 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001
│ 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001 1.00001
└ SUFFIX
"""
end
# Basic colorization test.
@test genmsg("line1\n\nline2", color=true) ==
"""
\e[36m\e[1m┌ \e[22m\e[39m\e[36m\e[1mPREFIX \e[22m\e[39mline1
\e[36m\e[1m│ \e[22m\e[39m
\e[36m\e[1m│ \e[22m\e[39mline2
\e[36m\e[1m└ \e[22m\e[39m\e[90mSUFFIX\e[39m
"""
# Using infix operator so that `@test` prints lhs and rhs when failed:
⊏(s, re) = match(re, s) !== nothing
@test genmsg("", progress=0.1, width=60) ⊏
r"Progress: 10%\|█+.* +\| ETA: .*"
@test genmsg("", progress=NaN, width=60) ⊏
r"Progress: 0%\|. +\| ETA: .*"
@test genmsg("", progress=1.0, width=60) == ""
@test genmsg("", progress="done", width=60) == ""
@test genmsgs([("", (progress = 0.1,)), ("", (progress = 1.0,))], width = 60)[end] ⊏
r"Progress: 100%\|█+\| Time: .*"
@test genmsgs([("", (progress = 0.1,)), ("", (progress = "done",))], width = 60)[end] ⊏
r"Progress: 100%\|█+\| Time: .*"
@testset "Message formatting" begin
io_ctx = IOContext(IOBuffer(), :displaysize=>(20,20))
# Short paragraph on a single line
@test format_message("Hi `code`", 6, io_ctx) ==
["Hi code"]
# Longer paragraphs wrap around the prefix
@test format_message("x x x x x x x x x x x x x x x x x x x x x", 6, io_ctx) ==
["x x x x x"
"x x x x x x x x"
"x x x x x x x x"]
# Markdown block elements get their own lines
@test format_message("# Hi", 6, io_ctx) ==
["",
"Hi",
VERSION < v"1.10-DEV" ? "≡≡≡≡" : "≡≡"]
# For non-strings a blank line is added so that any formatting for
# vertical alignment isn't broken
@test format_message(Text(" 1 2\n 3 4"), 6, io_ctx) ==
["",
" 1 2",
" 3 4"]
end
@testset "Independent progress bars" begin
msgs = genmsgs([
("Bar1", (progress = 0.0, _id = 1111)), # 1
("Bar2", (progress = 0.5, _id = 2222)),
("Bar2", (progress = 1.0, _id = 2222)), # 3
("", (progress = "done", _id = 2222)), # 4
("Bar1", (progress = 0.2, _id = 1111)), # 5
("Bar2", (progress = 0.5, _id = 2222)),
("Bar2", (progress = 1.0, _id = 2222)), # 7
("", (progress = "done", _id = 2222)), # 8
("Bar1", (progress = 0.4, _id = 1111)),
("", (progress = "done", _id = 1111)),
]; width=60)
@test msgs[1] ⊏ r"""
Bar1 0%\|. +\| ETA: N/A
"""
@test msgs[3] ⊏ r"""
Bar2 100%\|█+\| Time: .*
Bar1 0%\|. +\| ETA: .*
"""
@test msgs[4] ⊏ r"""
Bar1 0%\|. +\| ETA: .*
Bar2 100%\|█+\| Time: .*
"""
@test msgs[5] ⊏ r"""
Bar1 20%\|█+.* +\| ETA: .*
"""
@test msgs[7] ⊏ r"""
Bar2 100%\|█+\| Time: .*
Bar1 20%\|█+.* +\| ETA: .*
"""
@test msgs[8] ⊏ r"""
Bar1 20%\|█+.* +\| ETA: .*
Bar2 100%\|█+\| Time: .*
"""
@test msgs[end] ⊏ r"""
Bar1 100%\|█+\| Time: .*
"""
end
@testset "Nested progress bars" begin
id_outer = UUID(100)
id_inner_1 = UUID(201)
id_inner_2 = UUID(202)
outermsg(fraction; kw...) =
(Progress(id_outer, fraction; name = "Outer", kw...), Dict())
innermsg(id, fraction; kw...) =
(Progress(id, fraction; name = "Inner", parentid = id_outer, kw...), Dict())
msgs = genmsgs([
outermsg(0.0), # 1
innermsg(id_inner_1, 0.5),
innermsg(id_inner_1, 1.0), # 3
innermsg(id_inner_1, nothing; done = true), # 4
outermsg(0.2), # 5
innermsg(id_inner_2, 0.5),
innermsg(id_inner_2, 1.0), # 7
innermsg(id_inner_2, nothing; done = true), # 8
outermsg(0.4),
outermsg(nothing; done = true),
]; width=60)
@test msgs[1] ⊏ r"""
Outer 0%\|. +\| ETA: N/A
"""
@test msgs[3] ⊏ r"""
Inner 100%\|█+\| Time: .*
Outer 0%\|. +\| ETA: .*
"""
@test msgs[4] ⊏ r"""
Outer 0%\|. +\| ETA: .*
Inner 100%\|█+\| Time: .*
"""
@test msgs[5] ⊏ r"""
Outer 20%\|█+.* +\| ETA: .*
"""
@test msgs[7] ⊏ r"""
Inner 100%\|█+\| Time: .*
Outer 20%\|█+.* +\| ETA: .*
"""
@test msgs[8] ⊏ r"""
Outer 20%\|█+.* +\| ETA: .*
Inner 100%\|█+\| Time: .*
"""
@test msgs[end] ⊏ r"""
Outer 100%\|█+\| Time: .*
"""
end
@static if VERSION >= v"1.3.0"
@testset "Parallel progress" begin
buf = IOBuffer()
io = IOContext(buf, :displaysize=>(30,75), :color=>false)
logger = TerminalLogger(io, Debug)
# Crude multithreading test: generate some contention.
#
# Generate some contention in multi-threaded cases
ntasks = 8
@sync begin
with_logger(logger) do
for i=1:ntasks
Threads.@spawn for j=1:100
@info "XXXX <$i,$j>" maxlog=100
#sleep(0.001)
end
end
end
end
log_str = String(take!(buf))
@test length(findall("XXXX", log_str)) == 100
# Fun test of parallel progress logging to watch interactively:
#=
using ProgressLogging
@sync begin
for i=1:8
Threads.@spawn @progress name="task $i" threshold=0.00005 for j=1:10000
#sleep(0.001)
end
end
end
=#
end
end
end
| TerminalLoggers | https://github.com/JuliaLogging/TerminalLoggers.jl.git |
|
[
"MIT"
] | 0.1.7 | f133fab380933d042f6796eda4e130272ba520ca | code | 313 | using TerminalLoggers
using Test
using Logging:
LogLevel, BelowMinLevel, Debug, Info, Warn, Error, AboveMaxLevel,
shouldlog, handle_message, min_enabled_level, catch_exceptions,
with_logger
using ProgressLogging: Progress
using UUIDs: UUID
include("TerminalLogger.jl")
include("StickyMessages.jl")
| TerminalLoggers | https://github.com/JuliaLogging/TerminalLoggers.jl.git |
|
[
"MIT"
] | 0.1.7 | f133fab380933d042f6796eda4e130272ba520ca | docs | 880 | # TerminalLoggers
[](https://JuliaLogging.github.io/TerminalLoggers.jl/stable)
[](https://JuliaLogging.github.io/TerminalLoggers.jl/dev)
[](https://github.com/JuliaLogging/TerminalLoggers.jl/actions?query=workflow%3ACI)
[](https://codecov.io/gh/JuliaLogging/TerminalLoggers.jl)
TerminalLoggers provides a logger type `TerminalLogger` which can format your
log messages in a richer way than the default `ConsoleLogger` which comes with
the julia standard `Logging` library.
Read the [documentation](https://JuliaLogging.github.io/TerminalLoggers.jl/stable) for
more information.
| TerminalLoggers | https://github.com/JuliaLogging/TerminalLoggers.jl.git |
|
[
"MIT"
] | 0.1.7 | f133fab380933d042f6796eda4e130272ba520ca | docs | 2124 | # TerminalLoggers.jl
TerminalLoggers provides a logger type [`TerminalLogger`](@ref) which can
format your log messages in a richer way than the default `ConsoleLogger` which
comes with the julia standard `Logging` library.
## Installation and setup
```julia-repl
pkg> add TerminalLoggers
```
To use `TerminalLogger` in all your REPL sessions by default, you may add a
snippet such as the following to your startup file (in `.julia/config/startup.jl`)
```julia
atreplinit() do repl
try
@eval begin
using Logging: global_logger
using TerminalLoggers: TerminalLogger
global_logger(TerminalLogger())
end
catch
end
end
```
## Markdown
`TerminalLogger` interprets all `AbstractString` log messages as markdown so
you can use markdown formatting to display readable formatted messages. For
example,
```
@info """
# A heading
About to do the following
* A list
* Of actions
* To take
"""
```
## Progress bars
`TerminalLogger` displays progress logging as a set of progress bars which are
cleanly separated from the rest of the program output at the bottom of the
terminal.
For robust progress logging, `TerminalLoggers` recognizes the `Progress` type
from the [`ProgressLogging` package](https://github.com/JuliaLogging/ProgressLogging.jl).
For easy to use progress reporting you can therefore use the `@progress` macro:
```julia
using Logging: global_logger
global_logger(TerminalLogger(right_justify=120))
using ProgressLogging
@progress for i=1:100
if i == 50
@info "Middle of computation" i
elseif i == 70
println("Normal output does not interfere with progress bars")
end
sleep(0.01)
end
@info "Done"
```
!!! note
On Windows, rendering progress bars requires julia 1.5.3 or later,
and scrolling works best on a modern terminal like Windows Terminal.
You can also use the older progress logging API with the `progress=fraction`
key value pair. This is simpler but has some downsides such as not interacting
correctly with exceptions.
## API Reference
```@docs
TerminalLogger
```
| TerminalLoggers | https://github.com/JuliaLogging/TerminalLoggers.jl.git |
|
[
"MIT"
] | 0.1.0 | 9fea4f6f5748b809c481ac3b85d2ed81a6778c89 | code | 7672 | module PolySignedDistance
include("ray_tracing/ray_tracing.jl") # change as necessary
include("simplex/simplex.jl")
using AdaptiveKDTrees: KNN, RangeSearch
using LinearAlgebra
# using StaticArrays
# using AdaptiveDistanceFields
# using AdaptiveDistanceFields.RegionTrees
export SDFTree # , adaptive_distance_field
"""
```
struct SDFTree
range_tree::RangeSearch.RangeTree
nn_tree::KNN.KDTree
surface::RayTracing.Surface
points::AbstractMatrix
simplices::AbstractMatrix
function SDFTree(
points::AbstractMatrix, # (ndims, npts)
simplices::AbstractMatrix; # (ndims, nsimplices)
leaf_size::Int = 10, # for search trees
is_open::Bool = false, # if true, an open domain (distance is positive in the outside. Defs. to false)
)
# ...
end
end
```
Struct to hold a signed distance function evaluation tree
"""
struct SDFTree
range_tree::RangeSearch.RangeTree
nn_tree::KNN.KDTree
surface::RayTracing.Surface
points::AbstractMatrix
simplices::AbstractMatrix
function SDFTree(
points::AbstractMatrix, # (ndims, npts)
simplices::AbstractMatrix; # (ndims, nsimplices)
leaf_size::Int = 10, # for search trees
is_open::Bool = false, # if true, an open domain (distance is positive in the outside. Defs. to false)
)
simp_centers = mapslices(
s -> vec(
sum(
points[:, s];
dims = 2,
)
) ./ length(s),
simplices;
dims = 1,
)
simp_maxdists = map(
(s, c) -> maximum(
map(
norm,
eachcol(points[:, s] .- c)
)
),
eachcol(simplices),
eachcol(simp_centers)
)
range_tree = RangeSearch.RangeTree(
simp_centers, simp_maxdists;
leaf_size = leaf_size,
)
nn_tree = KNN.KDTree(
points; leaf_size = leaf_size,
)
surface = RayTracing.Surface(
points, simplices;
leaf_size = leaf_size,
reference_isin = is_open,
)
new(
range_tree,
nn_tree,
surface,
copy(points),
copy(simplices)
)
end
end
"""
```
SDFTree(points::AbstractMatrix; kwargs...)
```
Alternative constructor for an SDFTree in two dimensions,
which recieves a series of points in 2D space to be joined in a surface.
Only works for two dimensions!!
"""
function SDFTree(points::AbstractMatrix; kwargs...)
@assert size(points, 1) == 2 "SDFTree constructor must receive simplex matrix for 3 or higher-dimensional spaces"
simplices = let inds = collect(1:size(points, 2))
permutedims(
[
inds (circshift(inds, -1))
]
)
end
SDFTree(points, simplices; kwargs...)
end
"""
```
function (sdft::SDFTree)(
x::AbstractVector
)
```
Obtain signed distance to the surface of a triangulation, as represented by the SDF tree.
Also returns the projection of the point upon the surface.
"""
function (sdft::SDFTree)(
x::AbstractVector
)
p, d = projection_and_distance(sdft, x)
if RayTracing.isin(sdft.surface, x)
return (d, p)
end
(
- d,
p
)
end
export projection_and_distance
"""
Get projection and (unsigned) distance to a surface. Not necessarily a closed surface
"""
function projection_and_distance(
sdft::SDFTree,
x::AbstractVector
)
_, dmin = KNN.nn(sdft.nn_tree, x)
possible_simps = RangeSearch.find_in_range(
sdft.range_tree, x, dmin + eps(typeof(dmin))
)
simps = sdft.simplices[:, possible_simps]
p, d = let pd = map(
s -> Simplex.proj_and_dist(
sdft.points[:, s],
x;
ϵ = eps(typeof(dmin))
),
eachcol(simps)
)
_, ind = findmin(
t -> t[2],
pd
)
pd[ind]
end
(p, d)
end
#=
"""
```
function adaptive_distance_field(
tree::SDFTree,
origin::AbstractVector,
widths::AbstractVector; # for containing hypercube
center::Bool = false, # whether the origin is in the center of the domain
atol::Real = 1e-2, # absolute tolerance
rtol::Real = 1e-2, # relative tolerance
)
```
Generate adaptive distance field from an SDFTree.
Results in an object from AdaptiveDistanceFields.jl.
"""
function adaptive_distance_field(
tree::SDFTree,
origin::AbstractVector,
widths::AbstractVector; # for containing hypercube
center::Bool = false, # whether the origin is in the center of the domain
atol::Real = 1e-2, # absolute tolerance
rtol::Real = 1e-2, # relative tolerance
)
if center
origin = origin .- widths ./ 2
end
origin = SVector(origin...)
widths = SVector(widths...)
AdaptiveDistanceField(
x -> tree(x)[1],
origin, widths,
rtol, atol,
)
end
"""
```
adaptive_distance_field(
points::AbstractMatrix,
simplices::AbstractMatrix,
origin::AbstractVector,
widths::AbstractVector; # for containing hypercube
leaf_size::Int = 10, # for search trees
is_open::Bool = false, # if true, an open domain (distance is positive in the outside. Defs. to false)
center::Bool = false, # whether the origin is in the center of the domain
atol::Real = 1e-2, # absolute tolerance
rtol::Real = 1e-2, # relative tolerance
) = adaptive_distance_field(
SDFTree(
points, simplices; leaf_size = leaf_size, is_open = is_open,
),
origin, widths;
center = center,
atol = atol,
rtol = rtol,
)
```
Shortcut to create an adaptive distance field straight from points and simplices when the tree
is not necessary
"""
adaptive_distance_field(
points::AbstractMatrix,
simplices::AbstractMatrix,
origin::AbstractVector,
widths::AbstractVector; # for containing hypercube
leaf_size::Int = 10, # for search trees
is_open::Bool = false, # if true, an open domain (distance is positive in the outside. Defs. to false)
center::Bool = false, # whether the origin is in the center of the domain
atol::Real = 1e-2, # absolute tolerance
rtol::Real = 1e-2, # relative tolerance
) = adaptive_distance_field(
SDFTree(
points, simplices; leaf_size = leaf_size, is_open = is_open,
),
origin, widths;
center = center,
atol = atol,
rtol = rtol,
)
=#
end
| PolySignedDistance | https://github.com/pedrosecchi67/PolySignedDistance.jl.git |
|
[
"MIT"
] | 0.1.0 | 9fea4f6f5748b809c481ac3b85d2ed81a6778c89 | code | 8763 | module BoundingBox
using LinearAlgebra
using Statistics
export Box, find_potential_intersections
"""
```
mutable struct Box
```
Struct defining a Box
"""
mutable struct Box
boxes::Union{Vector{Box}, Nothing}
indices::Union{AbstractVector, Nothing} # of indices
center::AbstractVector
width::AbstractVector
sub_boxes::AbstractVector # vector of boxes
end
"""
```
function Box(
points::AbstractMatrix
)
```
Create a bounding box encapsulating a set of points (matrix, `(ndims, npoints)`)
"""
function Box(
points::AbstractMatrix
)
axmin = map(
minimum,
eachrow(points)
)
axmax = map(
maximum,
eachrow(points)
)
center = @. (axmin + axmax) / 2
width = @. (axmax - axmin)
Box(nothing, nothing, center, width, [])
end
"""
```
function Box(
boxes::Vector{Box}, indices = nothing;
max_size::Int = 10,
)
```
Create a bounding box tree encapsulating a set of
elementary bounding boxes and defining them hierarchically in space.
If indices aren't provided, the boxes are numbered as in the input vector.
`max_size` specifies a leaf maximum size for queries
"""
function Box(
boxes::Vector{Box}, indices = nothing;
max_size::Int = 10,
)
indices = (
isnothing(indices) ?
collect(1:length(boxes)) :
indices
)
ndim = length(boxes[1].center)
pmin = map(
i -> minimum(
bb -> bb.center[i] - bb.width[i] / 2,
boxes
),
1:ndim
)
pmax = map(
i -> maximum(
bb -> bb.center[i] + bb.width[i] / 2,
boxes
),
1:ndim
)
center = @. (pmin + pmax) / 2
width = pmax .- pmin
b = Box(
boxes, indices, center, width, []
)
split!(b, max_size)
b
end
# split box in two sub-boxes by the median of the most broadly variating dimension of the
# sub-box centers
function split!(
b::Box, max_size::Int,
)
if length(b.boxes) <= max_size
return
end
points = mapreduce(
bb -> bb.center,
hcat,
b.boxes,
)
_, dim = findmax(
r -> maximum(r) - minimum(r),
eachrow(points)
)
r = @view points[dim, :]
med = median(r)
isleft = @. r <= med
isright = @. !isleft
if all(isleft) || all(isright)
return
end
boxes = b.boxes
b.boxes = nothing
indices = b.indices
b.indices = nothing
b.sub_boxes = [
Box(
boxes[isleft], indices[isleft];
max_size = max_size,
),
Box(
boxes[isright], indices[isright];
max_size = max_size,
),
]; # return nothing
end
# minimum distance between boxes
mindist(b1::Box, b2::Box) = norm(
(
@. max(
0.0,
abs(b1.center - b2.center) - abs(b1.width + b2.width) / 2
)
)
)
# center of the hypothetical box encapsulating a line
function line_data(line::AbstractMatrix)
dmin = map(minimum, eachrow(line))
dmax = map(maximum, eachrow(line))
center = @. (dmin + dmax) / 2
width = @. (dmax - dmin)
(center, width)
end
# projection of point upon line
function line_projection(line::AbstractMatrix, point::AbstractVector)
p1 = line[:, 1]
p2 = line[:, 2]
v = p2 .- p1
ksi = v \ (point .- p1)
p1 .+ v .* ksi
end
# minimum distance estimate between box and line
mindist(b1::Box, line::AbstractMatrix) = let (center, width) = line_data(line)
proj = line_projection(line, b1.center)
R = norm(b1.width) / 2
max(
norm(
(
@. max(
0.0,
abs(b1.center - center) - abs(b1.width + width) / 2
)
)
),
norm(b1.center .- proj) - R,
0.0,
)
end
# is the box a leaf?
isleaf(b::Box) = (length(b.sub_boxes) == 0)
# I'm not sure I'm even using this but I'm now afraid to erase it
split_line(
btarg::AbstractMatrix,
) = let (p1, p2) = (btarg[:, 1], btarg[:, 2])
mid = @. (p1 + p2) / 2
(
[p1 mid],
[mid p2],
)
end
#=
function simplify_closest(
b::Box,
btarg::AbstractMatrix,
)
if size(btarg, 2) != 2
return (false, btarg)
end
p1 = btarg[:, 1]
p2 = btarg[:, 2]
mid = @. (p1 + p2) / 2
t1 = [p1 mid]
t2 = [mid p2]
epsilon = eps(eltype(btarg))
i1 = mindist(b, t1) <= epsilon
i2 = mindist(b, t2) <= epsilon
if i1
if i2
return (false, btarg)
else
return (true, t1)
end
end
if i2
return (true, t2)
end
(false, btarg) # will conclude the iteration anyway
end
simplify_closest(
b::Box,
btarg::Box,
) = (false, btarg)
=#
# visit a box and store its indices if potentially within range
function visit(
b::Box,
btarg, # ::Box,
inds::AbstractVector = Int64[],
)
epsilon = eps(eltype(b.center))
db = mindist(b, btarg)
if db > epsilon
return inds
end
if isleaf(b)
if db <= epsilon
inds = [inds; b.indices]
end
return inds
end
for sb in b.sub_boxes
inds = visit(sb, btarg, inds)
end
inds
end
#=
function visit(
b::Box,
btarg::AbstractMatrix,
inds::AbstractVector = Int64[],
)
epsilon = eps(eltype(b.center))
db = mindist(b, btarg)
if db > epsilon
return inds
end
if isleaf(b)
if db <= epsilon
inds = [inds; b.indices]
end
return inds
end
l1, l2 = split_line(btarg)
for sb in b.sub_boxes
inds = visit(sb, l1, inds)
inds = visit(sb, l2, inds)
end
inds
end
=#
"""
```
find_potential_intersections(
b::Box,
btarg,
)
```
Find a vector with indices of bounding boxes that potentially intersect with object `btarg`.
`btarg` may be:
* A line (matrix shape `(ndims, 2)`); or
* Another bounding box.
"""
function find_potential_intersections(
b::Box,
btarg,
)
if isnothing(b.indices) && length(b.sub_boxes) == 0
throw(
error(
"The provided bounding box is not hierarchically defined. See constructors for Box for more information"
)
)
end
if isa(btarg, AbstractMatrix)
if size(btarg, 2) != 2
btarg = Box(btarg)
end
end
visit(b, btarg)
end
end
#=
using .BoundingBox
θs = collect(LinRange(0.0, 2 * π, 100000))
simplices = [
begin
[
cos(θ) cos(θp1);
sin(θ) sin(θp1)
]
end for (θ, θp1) in zip(
θs[1:(end - 1)], θs[2:end]
)
]
boxes = map(
Box,
simplices
)
b = Box(boxes)
=#
#=
@time b = Box(boxes)
@time b = Box(boxes)
@time b = Box(boxes)
@time b = Box(boxes)
using ProfileView
@profview b = Box(boxes)
@profview b = Box(boxes)
=#
#=
h = 1.0 / length(simplices)
L = 100.0
line = [
(L + h) (- L - h);
(L + h) (- L - h)
]
pot = find_potential_intersections(b, line)
@time pot = find_potential_intersections(b, line)
@time pot = find_potential_intersections(b, line)
@time pot = find_potential_intersections(b, line)
@time pot = find_potential_intersections(b, line)
@show length(pot)
@show simplices[pot]
using ProfileView
@profview for i = 1:100
pot = find_potential_intersections(b, line)
end
@profview for i = 1:100
pot = find_potential_intersections(b, line)
end
@profview for i = 1:100
pot = find_potential_intersections(b, line)
end
=#
| PolySignedDistance | https://github.com/pedrosecchi67/PolySignedDistance.jl.git |
|
[
"MIT"
] | 0.1.0 | 9fea4f6f5748b809c481ac3b85d2ed81a6778c89 | code | 4172 | module PointHashing
export PointHash
"""
```
struct PointHash
point_dict::AbstractDict
digits::Int
end
```
Struct containing a hashmap of points
"""
struct PointHash
point_dict::AbstractDict
index_dict::AbstractDict
digits::Int
PointHash(
;
digits::Int = 7,
) = new(
Dict{Tuple, Int64}(),
Dict{Int64, Tuple}(),
digits
)
end
"""
```
function Base.push!(
hsh::PointHash,
pt::AbstractVector
)
```
Add point to hash, return index and hash (tuple of coordinates)
"""
function Base.push!(
hsh::PointHash,
pt::AbstractVector
)
pthash = tuple(
map(
x -> round(x; digits = hsh.digits),
pt,
)...
)
if haskey(hsh.point_dict, pthash)
return (hsh.point_dict[pthash], pthash)
end
ind = hsh.point_dict.count + 1
hsh.point_dict[pthash] = ind
hsh.index_dict[ind] = pthash
(ind, pthash)
end
"""
```
Base.getindex(
hsh::PointHash,
pt::AbstractVector
)
```
Find index for point
"""
Base.getindex(
hsh::PointHash,
pt::AbstractVector
) = let pthash = map(
x -> round(x; digits = hsh.digits),
pt,
)
hsh.point_dict[pthash]
end
"""
```
Base.getindex(
hsh::PointHash,
i::Int,
)
```
Find point of index i
"""
Base.getindex(
hsh::PointHash,
i::Int,
) = collect(
hsh.index_dict[i]
)
"""
```
function points(hsh::PointHash)
```
Get all points in the hashmap using an `(ndim, npoints)` matrix
"""
function points(hsh::PointHash)
X = hcat(
map(collect, collect(keys(hsh.point_dict)))...
)
i = collect(values(hsh.point_dict))
i = invperm(i)
X[:, i]
end
"""
```
function PointHash(
points::AbstractMatrix;
digits::Int = 7,
)
```
Construct a point hash from a set of points in an `(ndim, npoints)` matrix
"""
function PointHash(
points::AbstractMatrix;
digits::Int = 7,
)
hsh = PointHash(; digits = digits,)
for pt in eachcol(points)
push!(hsh, pt)
end
hsh
end
"""
```
function filter_cloud(
pts::AbstractMatrix;
digits::Int = 7,
)
```
Filter a cloud of points and merge points with the same representation up to
`digits`.
Returns a vector of indices for the original points, and a matrix with the new ones
"""
function filter_cloud(
pts::AbstractMatrix;
digits::Int = 7,
)
hsh = PointHash(; digits = digits,)
inds = Vector{Int64}(undef, size(pts, 2))
for (ipt, pt) in enumerate(eachcol(pts))
i, _ = push!(hsh, pt)
inds[ipt] = i
end
(
inds, points(hsh)
)
end
"""
```
@inline npoints(hsh::PointHash) = hsh.point_dict.count
```
Get number of points in hash
"""
@inline npoints(hsh::PointHash) = hsh.point_dict.count
end
#=
hsh = PointHashing.PointHash()
@show push!(hsh, [1.0, 1e-3, 1.0 + 1e-8])
@show push!(hsh, [1.0 + 1e-6, 1e-3, 1.0 + 1e-8])
@show push!(hsh, [1.0, 1e-3, 1.0 + 1e-8])
@show PointHashing.points(hsh)
hsh = PointHashing.PointHash(
[
1.0 (1.0 + 1e-6) 1.0;
1e-3 1e-3 1e-3;
(1.0 + 1e-8) (1.0 + 1e-8) (1.0 + 1e-8)
]
)
@show PointHashing.points(hsh)
@show hsh[[1.0, 1e-3, 1.0 + 1e-8]]
@show hsh[2]
@show PointHashing.filter_cloud(
[
1.0 (1.0 + 1e-6) 1.0;
1e-3 1e-3 1e-3;
(1.0 + 1e-8) (1.0 + 1e-8) (1.0 + 1e-8)
]
)
@info "Performance test"
for i = 1:10
pts = rand(3, 3)
@time PointHashing.filter_cloud(pts; digits = 7,)
end
=#
| PolySignedDistance | https://github.com/pedrosecchi67/PolySignedDistance.jl.git |
|
[
"MIT"
] | 0.1.0 | 9fea4f6f5748b809c481ac3b85d2ed81a6778c89 | code | 7520 | module RayTracing
using LinearAlgebra
include("../bounding_box/bounding_boxes.jl") # adjust as necessary
using .BoundingBox
include("../point_merging/point_hashing.jl") # adjust as necessary
using .PointHashing
export Surface, isin, crossed_faces
"""
Get simplex normal
"""
function normal(simplex::AbstractMatrix)
ϵ = eps(eltype(simplex))
if size(simplex, 1) == 2
v = simplex[:, 2] .- simplex[:, 1]
return [
- v[2], v[1]
] ./ (norm(v) + ϵ)
end
p0 = simplex[:, 1]
n = cross(simplex[:, 2] .- p0, simplex[:, 3] .- p0)
n ./ (norm(v) + ϵ)
end
"""
Find if a line connecting two points crosses a simplex
"""
function crosses_simplex(
simplex::AbstractMatrix,
p1::AbstractVector,
p2::AbstractVector,
ϵ::Real = 0.0,
)
p0 = simplex[:, 1]
nϵ = sqrt(eps(eltype(p0)))
dp = (p2 .- p1)
n = normal(simplex)
dp .+= let p = n ⋅ dp
n .* (
p < 0.0 ?
- nϵ :
nϵ
)
end
M = [(simplex[:, 2:end] .- p0) dp]
M = pinv(M)
ξ1 = M * (p1 .- p0)
ξ2 = M * (p2 .- p0)
if ξ1[end] * ξ2[end] > - ϵ
return false
end
ξ1 = ξ1[1:(end - 1)]
if any(
x -> x < - ϵ,
ξ1
)
return false
end
if sum(ξ1) > 1.0 + ϵ
return false
end
true
end
"""
```
struct Surface
points::AbstractMatrix
simplices::AbstractMatrix
bbox::Box
ray_reference::AbstractVector
reference_isin::Bool
Surface(
points::AbstractMatrix, # matrix (ndims, npts)
simplices::AbstractMatrix; # matrix (ndims, nsimps)
leaf_size::Int = 10, # leaf size for bounding box tree
ray_reference = nothing, # default ray origin point
reference_isin::Bool = false, # whether said origin is within the surface
digits::Int = 0, # digits of precision for point merging. Not merged if zero
)
end
```
Struct defining a surface
"""
struct Surface
points::AbstractMatrix
simplices::AbstractMatrix
bbox::Box
ray_reference::AbstractVector
reference_isin::Bool
digits::Int
function Surface(
points::AbstractMatrix, # matrix (ndims, npts)
simplices::AbstractMatrix; # matrix (ndims, nsimps)
leaf_size::Int = 10, # leaf size for bounding box tree
ray_reference = nothing, # default ray origin point
reference_isin::Bool = false, # whether said origin is within the surface
digits::Int = 12, # digits of precision for point merging. Not merged if zero
)
if digits > 0
(inds, points) = PointHashing.filter_cloud(
points; digits = digits,
)
simplices = inds[simplices]
simplices = hcat(
filter(
c -> length(unique(c)) == length(c),
collect(eachcol(simplices),),
)...
)
end
let boxes = map(
simp -> Box(points[:, simp]),
eachcol(simplices)
)
if isnothing(ray_reference)
ray_reference = zeros(eltype(points), size(points, 1))
Lmax = maximum(
r -> maximum(abs.(r)),
eachrow(points)
) * 2.0
ray_reference[1] = Lmax
end
new(
points, simplices,
Box(boxes; max_size = leaf_size,),
ray_reference,
reference_isin,
digits,
)
end
end
end
"""
```
Surface(points::AbstractMatrix; kwargs...)
```
Alternative constructor for a surface in two dimensions,
which recieves a series of points in 2D space to be joined in a manifold.
Only works for two dimensions!!
"""
function Surface(points::AbstractMatrix; kwargs...)
@assert size(points, 1) == 2 "Surface constructor must receive simplex matrix for 3 or higher-dimensional spaces"
simplices = let inds = collect(1:size(points, 2))
permutedims(
[
inds (circshift(inds, -1))
]
)
end
Surface(points, simplices; kwargs...)
end
"""
```
function isin(
surf::Surface,
point::AbstractVector,
origin = nothing, # reference point. Defaults to the surface default (surf.ray_reference)
origin_isin::Bool = false, # is reference within?
)
```
Get whether a point is within the surface using ray tracing
"""
function isin(
surf::Surface,
point::AbstractVector,
origin = nothing,
origin_isin::Bool = false,
)
if isnothing(origin)
origin = surf.ray_reference
origin_isin = surf.reference_isin
end
fcs, _ = crossed_faces(
surf, point, origin,
)
(length(fcs) % 2) != origin_isin
end
"""
Get intersection of line and simplex
"""
function crossing_point(
simplex::AbstractMatrix, p1::AbstractVector, p2::AbstractVector,
)
ϵ = eps(eltype(simplex))
n = normal(simplex)
p0 = simplex[:, 1]
np1 = abs(n ⋅ (p1 .- p0)) + ϵ
np2 = abs(n ⋅ (p2 .- p0)) + ϵ
η = np1 / (np1 + np2)
@. η * p2 + (1.0 - η) * p1
end
"""
```
function crossed_faces(
surf::Surface,
p1::AbstractVector,
p2::AbstractVector,
)
```
Get a list of faces crossed by a line connecting two points.
Returns vector of face indices and matrix of crossing points
"""
function crossed_faces(
surf::Surface,
p1::AbstractVector,
p2::AbstractVector,
)
line = [p1 p2]
potential = find_potential_intersections(surf.bbox, line,)
if length(potential) == 0
return (potential, Matrix{Float64}(undef, length(p1), 0))
end
crossed = filter(
s -> crosses_simplex(
surf.points[:, surf.simplices[:, s]],
p1, p2,
sqrt(eps(eltype(p1)))
),
potential
)
if length(crossed) == 0
return (crossed, Matrix{Float64}(undef, length(p1), 0))
end
crossing_points = hcat(
map(
c -> let simp = surf.points[:, surf.simplices[:, c]]
crossing_point(simp, p1, p2)
end, crossed,
)...
)
inds, crossing_points = PointHashing.filter_cloud(crossing_points; digits = surf.digits,)
ncrossed = Vector{Int64}(undef, size(crossing_points, 2))
for (i, cr) in zip(inds, crossed)
ncrossed[i] = cr
end
(ncrossed, crossing_points)
end
end
| PolySignedDistance | https://github.com/pedrosecchi67/PolySignedDistance.jl.git |
|
[
"MIT"
] | 0.1.0 | 9fea4f6f5748b809c481ac3b85d2ed81a6778c89 | code | 5145 | module Simplex
using LinearAlgebra
export simplex_volume, normal, simplex_faces, crosses_simplex, crossing_point, proj_and_dist
"""
```
function simplex_volume(
simplex::AbstractMatrix,
)
```
Get the volume of a simplex.
If the passed matrix has fewer dimensions than expected (being a boundary face),
its area is computed instead. In this case, it is always positive
"""
function simplex_volume(
simplex::AbstractMatrix,
)
p0 = simplex[:, 1]
M = simplex[:, 2:end] .- p0
if size(M, 1) != size(M, 2)
return sqrt(det(M' * M)) / factorial(size(M, 2))
end
det(M) / factorial(length(p0))
end
"""
```
function normal(face::AbstractMatrix; normalize::Bool = false,)
```
Get the normal of a face
"""
function normal(face::AbstractMatrix; normalize::Bool = false,)
p0 = face[:, 1]
M = face[:, 2:end] .- p0
N = length(p0)
v = map(
i -> let v = 1:N .== i
det([M v])
end,
1:N,
)
v ./ (
normalize ?
norm(v) :
factorial(N - 1)
)
end
"""
```
simplex_faces(simplex::AbstractVector)
```
Get faces from simplex (vector/index version)
"""
simplex_faces(simplex::AbstractVector) = map(
i -> let isnot = 1:length(simplex) .!= i
simplex[isnot]
end,
1:length(simplex),
)
"""
```
simplex_faces(simplex::AbstractMatrix)
```
Get faces from simplex (matrix/point version)
"""
simplex_faces(simplex::AbstractMatrix) = map(
i -> let isnot = 1:size(simplex, 2) .!= i
simplex[:, isnot]
end,
1:size(simplex, 2),
)
"""
```
function crossing_point(
simplex::AbstractMatrix, p1::AbstractVector, p2::AbstractVector,
)
```
Get intersection of line and simplex
"""
function crossing_point(
simplex::AbstractMatrix, p1::AbstractVector, p2::AbstractVector,
)
ϵ = eps(eltype(simplex))
n = normal(simplex)
p0 = simplex[:, 1]
np1 = abs(n ⋅ (p1 .- p0)) + ϵ
np2 = abs(n ⋅ (p2 .- p0)) + ϵ
η = np1 / (np1 + np2)
@. η * p2 + (1.0 - η) * p1
end
"""
```
function crosses_simplex(
simplex::AbstractMatrix,
p1::AbstractVector,
p2::AbstractVector,
ϵ::Real = 0.0,
)
```
Find if a line connecting two points crosses a simplex
"""
function crosses_simplex(
simplex::AbstractMatrix,
p1::AbstractVector,
p2::AbstractVector,
ϵ::Real = 0.0,
)
p0 = simplex[:, 1]
nϵ = sqrt(eps(eltype(p0)))
dp = (p2 .- p1)
n = normal(simplex)
dp .+= let p = n ⋅ dp
n .* (
p < 0.0 ?
- nϵ :
nϵ
)
end
M = [(simplex[:, 2:end] .- p0) dp]
M = pinv(M)
ξ1 = M * (p1 .- p0)
ξ2 = M * (p2 .- p0)
if ξ1[end] * ξ2[end] > - ϵ
return false
end
ξ1 = ξ1[1:(end - 1)]
if any(
x -> x < - ϵ,
ξ1
)
return false
end
if sum(ξ1) > 1.0 + ϵ
return false
end
true
end
"""
Get projection upon simplex and find whether the point at hand is within the simplex
"""
function proj_and_dist(
simplex::AbstractMatrix,
pt::AbstractVector;
ϵ::Real = 0.0,
)
p0 = simplex[:, 1]
p = pt .- p0
if size(simplex, 2) == 1
return (p0, norm(p))
end
M = simplex[:, 2:end] .- p0
ξ = M \ p
if any(
x -> x < - ϵ,
ξ
) || sum(ξ) > 1.0 + ϵ
rets = map(
f -> proj_and_dist(
f, pt; ϵ = ϵ,
),
simplex_faces(simplex),
)
_, ind = findmin(
r -> r[2],
rets
)
return rets[ind]
end
proj = p0 .+ M * ξ
(
proj, norm(proj .- pt)
)
end
end
#=
@show Simplex.simplex_faces(
[1, 2, 3, 4]
)
@show Simplex.simplex_faces(
[
0.0 1.0 0.0 0.0;
0.0 0.0 1.0 0.0;
0.0 0.0 0.0 1.0
]
)
@show Simplex.simplex_volume(
[
0.0 1.0 0.0;
0.0 0.0 1.0;
0.0 0.0 0.0
]
)
@show Simplex.simplex_volume(
[
0.0 1.0 0.0 0.0;
0.0 0.0 1.0 0.0;
0.0 0.0 0.0 1.0
]
)
@show Simplex.normal(
[
0.0 1.0 0.0;
0.0 0.0 1.0;
0.0 0.0 0.0
],
)
@show Simplex.normal(
[
0.0 1.0 0.0;
0.0 0.0 1.0;
0.0 0.0 0.0
]; normalize = true,
)
@show Simplex.proj_and_dist(
[
0.0 1.0 0.0;
0.0 0.0 1.0;
0.0 0.0 0.0
],
[0.5, -1.0, 1.0]
)
=#
| PolySignedDistance | https://github.com/pedrosecchi67/PolySignedDistance.jl.git |
|
[
"MIT"
] | 0.1.0 | 9fea4f6f5748b809c481ac3b85d2ed81a6778c89 | code | 1512 | begin
using .RayTracing
using LinearAlgebra
points = [
0.0 1.0 1.0 0.0;
0.0 0.0 1.0 1.0
] .* 0.5
#=
simplices = [
1 2 3 4;
2 3 4 1
]
=#
surf = Surface(points) # , simplices) # now the two-dimensional version!
@assert !RayTracing.crosses_simplex([0.5 0.0; 0.5 0.5], [-0.1, 0.2], [1.1, 0.2])
@assert isin(surf, [0.2, 0.2])
@assert !isin(surf, [1.2, 0.2])
@assert !isin(surf, [0.25, 0.60])
inds, pts = crossed_faces(surf, [-0.2, 0.2], [1.2, 0.2])
@assert Set(inds) == Set([2, 4])
@info "Performance test"
θ = collect(LinRange(0.0, 2 * π, 10000))[1:(end - 1)]
points = [
cos.(θ)';
sin.(θ)'
]
#=
simplices = let i = collect(1:(length(θ) - 1))
[
i';
(i .+ 1)'
]
end
=#
surf = Surface(points; digits = 7,)
for nit = 1:10
x = randn(2)
@time isin(surf, x)
end
@info "Performance test without intersection"
for nit = 1:10
x = randn(2) .* 0.01 .+ 0.9
@time isin(surf, x)
end
pts = rand(2, 300) .* 2 .- 1.0
pts = [pts zeros(2)]
@assert isin(surf, zeros(2))
isincirc = map(
pt -> isin(surf, pt),
eachcol(pts)
)
exact_isincirc = map(
pt -> norm(pt) < 1,
eachcol(pts)
)
isval = map(
pt -> abs(norm(pt) - 1) > 1e-2,
eachcol(pts)
)
@assert isincirc[isval] ≈ exact_isincirc[isval]
end
| PolySignedDistance | https://github.com/pedrosecchi67/PolySignedDistance.jl.git |
|
[
"MIT"
] | 0.1.0 | 9fea4f6f5748b809c481ac3b85d2ed81a6778c89 | code | 136 | using PolySignedDistance
using PolySignedDistance: RayTracing
using Random: seed!
seed!(42)
include("ray_trace.jl")
include("sdf.jl")
| PolySignedDistance | https://github.com/pedrosecchi67/PolySignedDistance.jl.git |
|
[
"MIT"
] | 0.1.0 | 9fea4f6f5748b809c481ac3b85d2ed81a6778c89 | code | 2319 | begin
using .PolySignedDistance
using LinearAlgebra
θ = collect(LinRange(0.0, 2 * π, 10000))[1:(end - 1)]
points = [
cos.(θ)';
sin.(θ)'
]
simplices = let i = collect(1:length(θ))
[
i';
(circshift(i, -1))'
]
end
tree = SDFTree(points) # , simplices)
@info "Tree creation - $(length(θ)) simplices on circumpherence"
@time tree = SDFTree(points) # , simplices)
@time tree = SDFTree(points) # , simplices)
@time tree = SDFTree(points) # , simplices)
@time tree = SDFTree(points) # , simplices)
X = rand(2, 10)
h = 0.01
@info "Performance test - single point query"
for x in eachcol(X)
@time d, p = tree(x)
ad = 1.0 - norm(x)
if abs(d) > h
@assert abs(d - ad) < h
end
end
#=
origin = fill(-2.0, 2)
widths = fill(4.0, 2)
tols = (
rtol = 0.2,
atol = 1e-6,
)
@info "Adaptive distance field with $tols"
@time adf = adaptive_distance_field(
tree,
origin, widths;
tols...
)
@time adf = adaptive_distance_field(
tree,
origin, widths;
tols...
)
@time adf = adaptive_distance_field(
tree,
origin, widths;
tols...
)
@time adf = adaptive_distance_field(
tree,
origin, widths;
tols...
)
@info "Adaptive distance field with $tols - shortcut"
@time adf = adaptive_distance_field(
points, simplices,
origin, widths;
tols...
)
@time adf = adaptive_distance_field(
points, simplices,
origin, widths;
tols...
)
@time adf = adaptive_distance_field(
points, simplices,
origin, widths;
tols...
)
@time adf = adaptive_distance_field(
points, simplices,
origin, widths;
tols...
)
_test_in_tol = (a, b; atol = 1e-2, rtol = 1e-2,) -> abs(
a - b
) < atol + rtol * max(abs(a), abs(b))
@info "Testing ASDF values"
for x in eachcol(X)
@time d, p = tree(x)
ad = adf(x)
if abs(d) > h
@assert _test_in_tol(
ad, d;
tols...
)
end
end
=#
end
| PolySignedDistance | https://github.com/pedrosecchi67/PolySignedDistance.jl.git |
|
[
"MIT"
] | 0.1.0 | 9fea4f6f5748b809c481ac3b85d2ed81a6778c89 | docs | 2297 | # PolySignedDistance.jl
A package for ray tracing/point-in-polygon queries and SDF/Approximate-SDF computation in Julia using N-dimensional triangulated surfaces.
## Ray Tracing
To build a surface for ray tracing, one may use:
```
using PolySignedDistance: RayTracing
surf = RayTracing.Surface(
points, # matrix (ndims, npts)
simplices; # matrix (ndims, nsimps)
leaf_size = 10,
ray_reference = nothing,
reference_isin = false,
digits = 12
)
```
* `points` indicates surface points;
* `simplices` indicates simplices in the triangulated surface;
* `leaf_size` indicates a max. leaf size for the bounding box tree;
* `ray_reference` indicates a standard reference (origin) point for the ray tracing. Defaults to a point far away from the surface if `nothing`;
* `reference_isin`: whether said ray reference is within the surface;
* `digits`: number of digits for point merging precision. We advise the user not to change this.
For a point-in-polygon query, you can use `RayTracing.isin`:
```
flag = isin(
surf, point
) # true if within solid
```
To optimize the queries, one may use a custom ray tracing origin closer to the query point as:
```
flag = isin(
surf, point;
origin = [-1, 2, 0], # example
origin_isin = true # for reference
)
```
To find a list of intersected simplex indices and the corresponding intersection points, you may also use:
```
face_inds, int_points = crossed_faces(surf, p1, p2)
@show size(int_points)
# (ndims, npoints)
```
## SDFs and Approximate SDFs
For a signed distance function calculation, one may use:
```
using PolySignedDistance
tree = SDFTree(
points,
simplices;
leaf_size = 10, # for search trees
is_open = false, # if true, an open domain (distance is positive in the outside. Defs. to false)
)
x = rand(size(points, 1)) # random point
dist, proj = tree(x)
# dist: distance to surface (signed)
# proj: projection upon surface
# or, for open manifolds without spending time with the point in polygon query
dist, proj = projection_and_distance(tree, x)
```
## WARNING!
The SDF estimation algorithms hereby implemented do not yield correct results if zero-area simplices or repeated points are provided. Checking and fixing their existence in the input geometry is up to the user.
| PolySignedDistance | https://github.com/pedrosecchi67/PolySignedDistance.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 645 | using SuperLUDIST
using Documenter
DocMeta.setdocmeta!(SuperLUDIST, :DocTestSetup, :(using SuperLUDIST); recursive=true)
makedocs(;
modules=[SuperLUDIST],
authors="Aadesh Deshmukh",
repo="https://github.com/JuliaSparse/SuperLUDIST.jl/blob/{commit}{path}#{line}",
sitename="SuperLUDIST.jl",
format=Documenter.HTML(;
prettyurls=get(ENV, "CI", "false") == "true",
canonical="https://superludist.juliasparse.org",
edit_link="main",
assets=String[],
),
pages=[
"Home" => "index.md",
],
)
deploydocs(;
repo="github.com/JuliaSparse/SuperLUDIST.jl",
devbranch="main",
)
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 2447 | # ENV["OMP_NUM_THREADS"] = 1
using MPI
using SuperLUDIST: Grid, DistributedSuperMatrix,
pgssvx!
using SuperLUDIST
using SparseBase.Communication
using SparseBase.Communication: distribute_evenly, localsize
using MatrixMarket
using SparseBase
using LinearAlgebra
MPI.Init()
nprow, npcol, nrhs = 2, 2, 4
root = 0
comm = MPI.COMM_WORLD
grid = Grid{Int64}(nprow, npcol, comm)
iam = grid.iam
isroot = iam == root
# Utility function for reading a .mtx file and generating suitable
# rhs and x for testing.
# coo is held only on root, b and xtrue are replicated on each rank.
coo, b, xtrue = SuperLUDIST.mmread_and_generatesolution(
Float64, Int64, nrhs, joinpath(@__DIR__, "add32.mtx"), grid; root
)
# A second rhs and xtrue for testing different sized b.
b2 = [b;; b]
x2 = [xtrue;; xtrue]
csr = isroot ? convert(SparseBase.CSRStore, coo) : nothing
chunksizes = isroot ? distribute_evenly(size(csr, 1), nprow * npcol) : nothing
# on single nodes this will help prevent oversubscription of threads.
# SuperLUDIST.superlu_set_num_threads(Int64, 1)
# If constructing from existing per-node data the following constructors will help:
# store = CSRStore(ptrs, indices, values, localsize::NTuple{2, Int})
# A = DistributedSuperMatrix(store::CSRStore, firstrow, globalsize::NTuple{2, Int})
# @show iam csr
A = Communication.scatterstore!(
DistributedSuperMatrix{Float64, Int64}(grid), csr, chunksizes; root);
b_local = b[A.first_row : A.first_row + localsize(A, 1) - 1, :] # shrink b
xtrue_local = xtrue[A.first_row : A.first_row + localsize(A, 1) - 1, :] # shrink xtrue
# Form a factorization object.
# Alternatively, to solve and factor simultaneously call:
# b_local, F = pgssvx!(A, b_local)
F = lu!(A);
# Out of place solve
# Alternatively for in-place call: for in-place.
# ldiv!(A, b_local)
b_local = F \ b_local
if !(iam == root) || (nprow * npcol == 1)
SuperLUDIST.inf_norm_error_dist(b_local, xtrue_local, grid)
SuperLUDIST.PStatPrint(F) # printing may be messy.
end
b2_local = b2[A.first_row : A.first_row + localsize(A, 1) - 1, :] # shrink b2
xtrue2_local = x2[A.first_row : A.first_row + localsize(A, 1) - 1, :] # shrink xtrue2
# Solve again, reusing the initial facctorization:
b2_local = F \ b2_local
if !(iam == root) || (nprow * npcol == 1)
SuperLUDIST.inf_norm_error_dist(b2_local, xtrue2_local, grid)
SuperLUDIST.PStatPrint(F) #printing may be messy.
end
# @show iam b_local xtrue_local
MPI.Finalize()
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 3358 | using MPI
using SuperLUDIST
using SparseBase
using SparseBase: CoordinateStore, CSRStore
using SparseBase.Communication
using SparseBase.Communication: DistributedSparseStore
using CIndices
MPI.Init()
comm = MPI.COMM_WORLD
println("Hello world, I am $(MPI.Comm_rank(comm)) of $(MPI.Comm_size(comm))")
MPI.Barrier(comm)
rank = MPI.Comm_rank(comm)
comm_size = MPI.Comm_size(comm)
x = rank == 0 ?
CoordinateStore((rand(1:10, 12), rand(1:10, 12)), collect(1:12)) :
CoordinateStore{Int64, Int64, 2}()
Communication.bcaststore!(x, 0, comm)
if rank == 0
println("Bcast COO - Original: ")
println("================")
@show x
println()
println("Each rank")
println("================")
end
MPI.Barrier(comm)
for i = 0:comm_size-1
if rank == i
@show rank x
end
MPI.Barrier(comm)
end
x = rank == 0 ?
SparseBase.sortcoalesce(CoordinateStore((rand(1:10, 12), rand(1:10, 12)), collect(1:12), (10, 10); sortorder = RowMajor())) :
nothing
if rank == 0
println("\n================")
println("Scatter COO - Original: ")
println("================")
@show x
println()
println("================")
end
MPI.Barrier(comm)
y = DistributedSparseStore(CoordinateStore{Int64, Int64, 2}(), ([6, 4], 10), comm)
if rank == 1
println("\n================")
println("Scatter COO - Original y: ")
println("================")
@show y
println()
println("Each rank")
println("================")
end
y = Communication.scatterstore!(y, x)
for i = 0:comm_size-1
if rank == i
@show rank y
end
MPI.Barrier(comm)
end
x = rank == 0 ?
convert(SparseBase.CSRStore, SparseBase.CoordinateStore((rand(1:5, 10), rand(1:5, 10)), collect(1:10), (10, 10))) :
SparseBase.CSRStore{Int, Int}()
Communication.bcaststore!(x, 0, comm)
if rank == 0
println("\n================")
println("Bcast CSR - Original: ")
println("================")
@show x
println()
println("Each rank")
println("================")
end
MPI.Barrier(comm)
for i = 0:comm_size-1
if rank == i
@show rank x
end
MPI.Barrier(comm)
end
x = rank == 0 ?
convert(SparseBase.CSRStore, SparseBase.CoordinateStore((CIndex.(rand(1:5, 10)), CIndex.(rand(1:5, 10))), collect(1:10), (5, 5))) :
nothing
y = SparseBase.CSRStore{Int, CIndex{Int}}()
if rank == 0
println("\n================")
println("Scatter CSR - Original: ")
println("================")
@show x
println()
println("Each rank")
println("================")
end
MPI.Barrier(comm)
y, globalnrows, first_row = Communication.scatterstore!(y, x, [3, 2])
for i = 0:comm_size-1
if rank == i
@show rank globalnrows first_row y
end
MPI.Barrier(comm)
end
x = rank == 0 ?
convert(SparseBase.CSRStore, SparseBase.CoordinateStore((CIndex.(rand(1:5, 10)), CIndex.(rand(1:5, 10))), rand(10), (5, 5))) :
nothing
y = SuperLUDIST.DistributedSuperMatrix{Float64, Int}()
if rank == 0
println("\n================")
println("Scatter CSR - Original: ")
println("================")
@show x
println()
println("Each rank")
println("================")
end
MPI.Barrier(comm)
y = Communication.scatterstore!(y, x, [3, 2])
for i = 0:comm_size-1
if rank == i
@show rank
dump(y)
end
MPI.Barrier(comm)
end | SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 738 | using MPI
using SuperLUDIST
using MatrixMarket
MPI.Init()
comm = MPI.COMM_WORLD
println("Hello world, I am $(MPI.Comm_rank(comm)) of $(MPI.Comm_size(comm))")
MPI.Barrier(comm)
rank = MPI.Comm_rank(comm)
comm_size = MPI.Comm_size(comm)
x = MatrixMarket.mmread(
SuperLUDIST.GlobalSuperMatrix{Float64, Int32},
joinpath(@__DIR__, "add32.mtx")
)
if rank == 0
println("Original array")
println("================")
@show getindex.(x.indices, lastindex(x.indices[1])) => x.v[end]
println()
println("Each rank")
println("================")
end
MPI.Barrier(comm)
for i = 0:comm_size-1
if rank == i
@show rank getindex.(x.indices, lastindex(x.indices[1])) => x.v[end]
end
MPI.Barrier(comm)
end | SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 167 | # examples/01-hello.jl
using MPI
MPI.Init()
comm = MPI.COMM_WORLD
print("Hello world, I am rank $(MPI.Comm_rank(comm)) of $(MPI.Comm_size(comm))\n")
MPI.Barrier(comm) | SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 2061 | # ENV["OMP_NUM_THREADS"] = 1
using MPI
using SuperLUDIST: Grid, DistributedSuperMatrix,
pgssvx!, pgssvx_ABdist!, pgstrs_prep!, pgstrs_init!
using SuperLUDIST
using SparseBase.Communication
using SparseBase.Communication: distribute_evenly, localsize
using MatrixMarket
using SparseBase
using LinearAlgebra
MPI.Init()
nprow, npcol, nrhs = 1, 1, 3
root = 0
comm = MPI.COMM_WORLD
grid = Grid{Int32}(nprow, npcol, comm)
iam = grid.iam
isroot = iam == root
# Utility function for reading a .mtx file and generating suitable
# rhs and x for testing.
# coo is held only on root, b and xtrue are replicated on each rank.
coo, b, xtrue = SuperLUDIST.mmread_and_generatesolution(
Float64, Int32, nrhs, joinpath(@__DIR__, "add32.mtx"), grid; root
)
csr = isroot ? convert(SparseBase.CSRStore, coo) : nothing
chunksizes = isroot ? distribute_evenly(size(csr, 1), nprow * npcol) : nothing
# on single nodes this will help prevent oversubscription of threads.
SuperLUDIST.superlu_set_num_threads(Int64, 2)
# If constructing from existing per-node data the following constructors will help:
# A = DistributedSuperMatrix(store::CSRStore, firstrow, globalsize::NTuple{2, Int})
# store = CSRStore(ptrs, indices, values, localsize::NTuple{2, Int})
# @show iam csr
A = Communication.scatterstore!(
DistributedSuperMatrix{Float64, Int32}(grid), csr, chunksizes; root)
b_local = b[A.first_row : A.first_row + localsize(A, 1) - 1, :] # shrink b
xtrue_local = xtrue[A.first_row : A.first_row + localsize(A, 1) - 1, :] # shrink xtrue
# everything below this point will be used by all users.
# everything above simply prepares A and b which will differ
# for each user.
# creating options and stat is optional, they will be created if not provided.
# b1 = Matrix{Float64}(undef, localsize(A, 2), 2)
b1 = rand(localsize(A, 1), 0)
_, F = pgssvx!(A, b1);
b_local, F = pgssvx!(F, b_local);
if !(iam == root) || (nprow * npcol == 1)
SuperLUDIST.inf_norm_error_dist(b_local, xtrue_local, grid)
end
SuperLUDIST.PStatPrint(F)
# @show iam b_local xtrue_local
MPI.Finalize()
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 1001 | using MPI
using SuperLUDIST
using SuperLUDIST: Grid, Options, LUStat, ScalePerm,
ReplicatedSuperMatrix, pgssvx!
using SuperLUDIST.Common
using MatrixMarket
nprow, npcol, nrhs = (1, 1, 1)
root = 0
MPI.Init()
comm = MPI.COMM_WORLD
grid = Grid{Int}(nprow, npcol, comm)
iam = grid.iam
# This function handles broadcasting internally!
A = MatrixMarket.mmread(
SuperLUDIST.ReplicatedSuperMatrix{Float64, Int},
joinpath(@__DIR__, "add32.mtx"),
grid
) ;
# on single nodes this will help prevent oversubscription of threads.
SuperLUDIST.superlu_set_num_threads(Int64, 2)
m, n, = size(A)
xtrue = Matrix{Float64}(undef, n, nrhs)
b = Matrix{Float64}(undef, m, nrhs)
if iam == root
SuperLUDIST.GenXtrue_dist!(xtrue, Int64)
SuperLUDIST.FillRHS_dist!(b, A, xtrue)
end
MPI.Bcast!(b, root, comm)
MPI.Bcast!(xtrue, root, comm)
b, F = pgssvx!(A, b)
if !(iam == root) || (nprow * npcol == 1)
SuperLUDIST.inf_norm_error_dist(b, xtrue, grid)
end
SuperLUDIST.PStatPrint(F)
MPI.Finalize()
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 602 | using MPI
using SuperLUDIST
MPI.Init()
comm = MPI.COMM_WORLD
println("Hello world, I am $(MPI.Comm_rank(comm)) of $(MPI.Comm_size(comm))")
MPI.Barrier(comm)
rank = MPI.Comm_rank(comm)
comm_size = MPI.Comm_size(comm)
if rank == 0
x = rand(1:10, 20)
else
x = Int64[]
end
y = SuperLUDIST._scatterarray(x, [5, 5, 5, 5])
if rank == 0
println("Original array")
println("================")
@show x
println()
println("Each rank")
println("================")
end
MPI.Barrier(comm)
for i = 0:comm_size-1
if rank == i
@show rank y
end
MPI.Barrier(comm)
end | SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 28 | module SparseArraysExt
end
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 1300 | #! /bin/bash julia --project generator.jl
using Pkg
using Pkg.Artifacts
using Clang.Generators
using Clang.Generators.JLLEnvs
using SuperLUDIST_jll
using MPICH_jll
cd(@__DIR__)
# headers
SuperLUDIST_toml = joinpath(dirname(pathof(SuperLUDIST_jll)), "..", "Artifacts.toml")
SuperLUDIST_dir = Pkg.Artifacts.ensure_artifact_installed("SuperLUDIST", SuperLUDIST_toml)
include_dir = joinpath(SuperLUDIST_dir, "include") |> normpath
superlu_defs_h = joinpath(include_dir, "superlu_defs.h")
superlu_ddefs_h = joinpath(include_dir, "superlu_ddefs.h")
superlu_sdefs_h = joinpath(include_dir, "superlu_sdefs.h")
superlu_zdefs_h = joinpath(include_dir, "superlu_zdefs.h")
@assert isfile(superlu_defs_h)
options = load_options(joinpath(@__DIR__, "generator_32.toml"))
options["general"]["output_file_path"] = joinpath(@__DIR__, "..", "lib", "libsuperlu_dist32.jl")
mpi_header_dir = joinpath(MPICH_jll.find_artifact_dir(), "include") |> normpath
isdir(mpi_header_dir) || error("$mpi_header_dir does not exist")
args = get_default_args()
push!(args, "-isystem$mpi_header_dir")
header_files = [superlu_defs_h, superlu_sdefs_h, superlu_ddefs_h, superlu_zdefs_h]
@add_def MPI_Comm
@add_def MPI_Request
@add_def MPI_Datatype
@add_def MPI_Errhandler
ctx = create_context(header_files, args, options)
build!(ctx)
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 1301 | #! /bin/bash julia --project generator.jl
using Pkg
using Pkg.Artifacts
using Clang.Generators
using Clang.Generators.JLLEnvs
using SuperLUDIST_jll
using MPICH_jll
cd(@__DIR__)
# headers
SuperLUDIST_toml = joinpath(dirname(pathof(SuperLUDIST_jll)), "..", "Artifacts.toml")
SuperLUDIST_dir = Pkg.Artifacts.ensure_artifact_installed("SuperLUDIST", SuperLUDIST_toml)
include_dir = joinpath(SuperLUDIST_dir, "include") |> normpath
superlu_defs_h = joinpath(include_dir, "superlu_defs.h")
superlu_ddefs_h = joinpath(include_dir, "superlu_ddefs.h")
superlu_sdefs_h = joinpath(include_dir, "superlu_sdefs.h")
superlu_zdefs_h = joinpath(include_dir, "superlu_zdefs.h")
@assert isfile(superlu_defs_h)
options = load_options(joinpath(@__DIR__, "generator_64.toml"))
options["general"]["output_file_path"] = joinpath(@__DIR__, "..", "lib", "libsuperlu_dist64.jl")
mpi_header_dir = joinpath(MPICH_jll.find_artifact_dir(), "include") |> normpath
isdir(mpi_header_dir) || error("$mpi_header_dir does not exist")
args = get_default_args()
push!(args, "-isystem$mpi_header_dir")
header_files = [superlu_ddefs_h, superlu_defs_h, superlu_sdefs_h, superlu_zdefs_h]
@add_def MPI_Comm
@add_def MPI_Request
@add_def MPI_Datatype
@add_def MPI_Errhandler
ctx = create_context(header_files, args, options)
build!(ctx)
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 64 | import MPI: MPI_Comm, MPI_Request, MPI_Datatype, MPI_Errhandler
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 1250 | # common structs between int32 and int64:
module SuperLUDIST_Common
import MPI: MPI_Comm, MPI_Request, MPI_Datatype, MPI_Errhandler
using SuperLUBase.Common
export gridinfo_t, gridinfo3d_t, C_Tree, superlu_scope_t, commRequests_t
struct commRequests_t
L_diag_blk_recv_req::Ptr{MPI_Request}
L_diag_blk_send_req::Ptr{MPI_Request}
U_diag_blk_recv_req::Ptr{MPI_Request}
U_diag_blk_send_req::Ptr{MPI_Request}
recv_req::Ptr{MPI_Request}
recv_requ::Ptr{MPI_Request}
send_req::Ptr{MPI_Request}
send_requ::Ptr{MPI_Request}
end
struct C_Tree
sendRequests_::NTuple{2, MPI_Request}
comm_::MPI_Comm
myRoot_::Cint
destCnt_::Cint
myDests_::NTuple{2, Cint}
myRank_::Cint
msgSize_::Cint
tag_::Cint
empty_::yes_no_t
type_::MPI_Datatype
end
struct superlu_scope_t
comm::MPI_Comm
Np::Cint
Iam::Cint
end
mutable struct gridinfo_t{I}
comm::MPI_Comm
rscp::superlu_scope_t
cscp::superlu_scope_t
iam::Cint
nprow::I
npcol::I
end
mutable struct gridinfo3d_t{I}
comm::MPI_Comm
rscp::superlu_scope_t
cscp::superlu_scope_t
zscp::superlu_scope_t
grid2d::gridinfo_t{I}
iam::Cint
nprow::I
npcol::I
npdep::I
rankorder::Cint
end
end
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 209976 | module SuperLU_Int32
import MPI: MPI_Comm, MPI_Request, MPI_Datatype, MPI_Errhandler
using ..SuperLUDIST_Common
import ..SuperLUDIST: libsuperlu_dist_Int32
using SuperLUBase.Common
function superlu_abort_and_exit_dist(arg1)
@ccall libsuperlu_dist_Int32.superlu_abort_and_exit_dist(arg1::Ptr{Cchar})::Cvoid
end
function superlu_malloc_dist(arg1)
@ccall libsuperlu_dist_Int32.superlu_malloc_dist(arg1::Csize_t)::Ptr{Cvoid}
end
function superlu_free_dist(arg1)
@ccall libsuperlu_dist_Int32.superlu_free_dist(arg1::Ptr{Cvoid})::Cvoid
end
const int_t = Int32
# no prototype is found for this function at superlu_defs.h:1122:15, please use with caution
function SuperLU_timer_dist_()
@ccall libsuperlu_dist_Int32.SuperLU_timer_dist_()::Cdouble
end
function superlu_gridinit(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.superlu_gridinit(arg1::MPI_Comm, arg2::Cint, arg3::Cint, arg4::Ptr{gridinfo_t{Int32}})::Cvoid
end
function superlu_gridmap(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.superlu_gridmap(arg1::MPI_Comm, arg2::Cint, arg3::Cint, arg4::Ptr{Cint}, arg5::Cint, arg6::Ptr{gridinfo_t{Int32}})::Cvoid
end
function superlu_gridexit(arg1)
@ccall libsuperlu_dist_Int32.superlu_gridexit(arg1::Ptr{gridinfo_t{Int32}})::Cvoid
end
function superlu_gridinit3d(Bcomm, nprow, npcol, npdep, grid)
@ccall libsuperlu_dist_Int32.superlu_gridinit3d(Bcomm::MPI_Comm, nprow::Cint, npcol::Cint, npdep::Cint, grid::Ptr{gridinfo3d_t{Int32}})::Cvoid
end
function superlu_gridmap3d(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.superlu_gridmap3d(arg1::MPI_Comm, arg2::Cint, arg3::Cint, arg4::Cint, arg5::Ptr{Cint}, arg6::Ptr{gridinfo3d_t{Int32}})::Cvoid
end
function superlu_gridexit3d(grid)
@ccall libsuperlu_dist_Int32.superlu_gridexit3d(grid::Ptr{gridinfo3d_t{Int32}})::Cvoid
end
function set_default_options_dist(arg1)
@ccall libsuperlu_dist_Int32.set_default_options_dist(arg1::Ptr{superlu_dist_options_t})::Cvoid
end
function print_options_dist(arg1)
@ccall libsuperlu_dist_Int32.print_options_dist(arg1::Ptr{superlu_dist_options_t})::Cvoid
end
function print_sp_ienv_dist(arg1)
@ccall libsuperlu_dist_Int32.print_sp_ienv_dist(arg1::Ptr{superlu_dist_options_t})::Cvoid
end
function Destroy_CompCol_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int32.Destroy_CompCol_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}})::Cvoid
end
function Destroy_SuperNode_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int32.Destroy_SuperNode_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}})::Cvoid
end
function Destroy_SuperMatrix_Store_dist(arg1)
@ccall libsuperlu_dist_Int32.Destroy_SuperMatrix_Store_dist(arg1::Ptr{SuperMatrix{Int32}})::Cvoid
end
function Destroy_CompCol_Permuted_dist(arg1)
@ccall libsuperlu_dist_Int32.Destroy_CompCol_Permuted_dist(arg1::Ptr{SuperMatrix{Int32}})::Cvoid
end
function Destroy_CompRowLoc_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int32.Destroy_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}})::Cvoid
end
function Destroy_CompRow_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int32.Destroy_CompRow_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}})::Cvoid
end
function sp_colorder(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int32.sp_colorder(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{SuperMatrix{Int32}})::Cvoid
end
function sp_symetree_dist(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int32.sp_symetree_dist(arg1::Ptr{int_t}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::int_t, arg5::Ptr{int_t})::Cint
end
function sp_coletree_dist(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.sp_coletree_dist(arg1::Ptr{int_t}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::int_t, arg5::int_t, arg6::Ptr{int_t})::Cint
end
function get_perm_c_dist(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.get_perm_c_dist(arg1::int_t, arg2::int_t, arg3::Ptr{SuperMatrix{Int32}}, arg4::Ptr{int_t})::Cvoid
end
function at_plus_a_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.at_plus_a_dist(arg1::int_t, arg2::int_t, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cvoid
end
function genmmd_dist_(arg1, arg2, a, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int32.genmmd_dist_(arg1::Ptr{int_t}, arg2::Ptr{int_t}, a::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{int_t}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{int_t}, arg10::Ptr{int_t}, arg11::Ptr{int_t}, arg12::Ptr{int_t})::Cint
end
function bcast_tree(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.bcast_tree(arg1::Ptr{Cvoid}, arg2::Cint, arg3::MPI_Datatype, arg4::Cint, arg5::Cint, arg6::Ptr{gridinfo_t{Int32}}, arg7::Cint, arg8::Ptr{Cint})::Cvoid
end
function symbfact(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.symbfact(arg1::Ptr{superlu_dist_options_t}, arg2::Cint, arg3::Ptr{SuperMatrix{Int32}}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{Glu_persist_t}, arg7::Ptr{Glu_freeable_t{Int32}})::int_t
end
function symbfact_SubInit(options, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.symbfact_SubInit(options::Ptr{superlu_dist_options_t}, arg2::fact_t, arg3::Ptr{Cvoid}, arg4::int_t, arg5::int_t, arg6::int_t, arg7::int_t, arg8::Ptr{Glu_persist_t}, arg9::Ptr{Glu_freeable_t{Int32}})::int_t
end
function symbfact_SubXpand(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.symbfact_SubXpand(arg1::int_t, arg2::int_t, arg3::int_t, arg4::MemType, arg5::Ptr{int_t}, arg6::Ptr{Glu_freeable_t{Int32}})::int_t
end
function symbfact_SubFree(arg1)
@ccall libsuperlu_dist_Int32.symbfact_SubFree(arg1::Ptr{Glu_freeable_t{Int32}})::int_t
end
function countnz_dist(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.countnz_dist(arg1::int_t, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Glu_persist_t}, arg6::Ptr{Glu_freeable_t{Int32}})::Cvoid
end
function fixupL_dist(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.fixupL_dist(arg1::int_t, arg2::Ptr{int_t}, arg3::Ptr{Glu_persist_t}, arg4::Ptr{Glu_freeable_t{Int32}})::Int64
end
function TreePostorder_dist(arg1, arg2)
@ccall libsuperlu_dist_Int32.TreePostorder_dist(arg1::int_t, arg2::Ptr{int_t})::Ptr{int_t}
end
function smach_dist(arg1)
@ccall libsuperlu_dist_Int32.smach_dist(arg1::Ptr{Cchar})::Cfloat
end
function dmach_dist(arg1)
@ccall libsuperlu_dist_Int32.dmach_dist(arg1::Ptr{Cchar})::Cdouble
end
function int32Malloc_dist(arg1)
@ccall libsuperlu_dist_Int32.int32Malloc_dist(arg1::Cint)::Ptr{Cint}
end
function int32Calloc_dist(arg1)
@ccall libsuperlu_dist_Int32.int32Calloc_dist(arg1::Cint)::Ptr{Cint}
end
function intMalloc_dist(arg1)
@ccall libsuperlu_dist_Int32.intMalloc_dist(arg1::int_t)::Ptr{int_t}
end
function intCalloc_dist(arg1)
@ccall libsuperlu_dist_Int32.intCalloc_dist(arg1::int_t)::Ptr{int_t}
end
function mc64id_dist(arg1)
@ccall libsuperlu_dist_Int32.mc64id_dist(arg1::Ptr{Cint})::Cint
end
function arrive_at_ublock(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int32.arrive_at_ublock(arg1::int_t, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{int_t}, arg7::int_t, arg8::int_t, arg9::Ptr{int_t}, arg10::Ptr{int_t}, arg11::Ptr{int_t}, arg12::Ptr{gridinfo_t{Int32}})::Cvoid
end
function estimate_bigu_size(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.estimate_bigu_size(arg1::int_t, arg2::Ptr{Ptr{int_t}}, arg3::Ptr{Glu_persist_t}, arg4::Ptr{gridinfo_t{Int32}}, arg5::Ptr{int_t}, arg6::Ptr{int_t})::int_t
end
function sp_ienv_dist(arg1, arg2)
@ccall libsuperlu_dist_Int32.sp_ienv_dist(arg1::Cint, arg2::Ptr{superlu_dist_options_t})::Cint
end
function ifill_dist(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.ifill_dist(arg1::Ptr{int_t}, arg2::int_t, arg3::int_t)::Cvoid
end
function super_stats_dist(arg1, arg2)
@ccall libsuperlu_dist_Int32.super_stats_dist(arg1::int_t, arg2::Ptr{int_t})::Cvoid
end
function get_diag_procs(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.get_diag_procs(arg1::int_t, arg2::Ptr{Glu_persist_t}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{int_t}}, arg6::Ptr{Ptr{int_t}})::Cvoid
end
function QuerySpace_dist(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.QuerySpace_dist(arg1::int_t, arg2::int_t, arg3::Ptr{Glu_freeable_t{Int32}}, arg4::Ptr{superlu_dist_mem_usage_t})::int_t
end
function xerr_dist(arg1, arg2)
@ccall libsuperlu_dist_Int32.xerr_dist(arg1::Ptr{Cchar}, arg2::Ptr{Cint})::Cint
end
function pxerr_dist(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.pxerr_dist(arg1::Ptr{Cchar}, arg2::Ptr{gridinfo_t{Int32}}, arg3::int_t)::Cvoid
end
function PStatInit(arg1)
@ccall libsuperlu_dist_Int32.PStatInit(arg1::Ptr{SuperLUStat_t{Int32}})::Cvoid
end
function PStatFree(arg1)
@ccall libsuperlu_dist_Int32.PStatFree(arg1::Ptr{SuperLUStat_t{Int32}})::Cvoid
end
function PStatPrint(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.PStatPrint(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperLUStat_t{Int32}}, arg3::Ptr{gridinfo_t{Int32}})::Cvoid
end
function log_memory(arg1, arg2)
@ccall libsuperlu_dist_Int32.log_memory(arg1::Int64, arg2::Ptr{SuperLUStat_t{Int32}})::Cvoid
end
function print_memorylog(arg1, arg2)
@ccall libsuperlu_dist_Int32.print_memorylog(arg1::Ptr{SuperLUStat_t{Int32}}, arg2::Ptr{Cchar})::Cvoid
end
function superlu_dist_GetVersionNumber(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.superlu_dist_GetVersionNumber(arg1::Ptr{Cint}, arg2::Ptr{Cint}, arg3::Ptr{Cint})::Cint
end
function quickSort(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.quickSort(arg1::Ptr{int_t}, arg2::int_t, arg3::int_t, arg4::int_t)::Cvoid
end
function quickSortM(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.quickSortM(arg1::Ptr{int_t}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::int_t, arg6::int_t)::Cvoid
end
function partition(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.partition(arg1::Ptr{int_t}, arg2::int_t, arg3::int_t, arg4::int_t)::int_t
end
function partitionM(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.partitionM(arg1::Ptr{int_t}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::int_t, arg6::int_t)::int_t
end
function symbfact_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int32.symbfact_dist(arg1::Ptr{superlu_dist_options_t}, arg2::Cint, arg3::Cint, arg4::Ptr{SuperMatrix{Int32}}, arg5::Ptr{int_t}, arg6::Ptr{int_t}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{Pslu_freeable_t}, arg10::Ptr{MPI_Comm}, arg11::Ptr{MPI_Comm}, arg12::Ptr{superlu_dist_mem_usage_t})::Cfloat
end
function get_perm_c_parmetis(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.get_perm_c_parmetis(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Cint, arg5::Cint, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{gridinfo_t{Int32}}, arg9::Ptr{MPI_Comm})::Cfloat
end
function psymbfact_LUXpandMem(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int32.psymbfact_LUXpandMem(arg1::Cint, arg2::int_t, arg3::int_t, arg4::int_t, arg5::int_t, arg6::Cint, arg7::Cint, arg8::Cint, arg9::Ptr{Pslu_freeable_t}, arg10::Ptr{Llu_symbfact_t}, arg11::Ptr{vtcsInfo_symbfact_t}, arg12::Ptr{psymbfact_stat_t})::int_t
end
function psymbfact_LUXpand(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13)
@ccall libsuperlu_dist_Int32.psymbfact_LUXpand(arg1::int_t, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{int_t}, arg6::int_t, arg7::int_t, arg8::int_t, arg9::int_t, arg10::Ptr{Pslu_freeable_t}, arg11::Ptr{Llu_symbfact_t}, arg12::Ptr{vtcsInfo_symbfact_t}, arg13::Ptr{psymbfact_stat_t})::int_t
end
function psymbfact_LUXpand_RL(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int32.psymbfact_LUXpand_RL(arg1::int_t, arg2::int_t, arg3::int_t, arg4::int_t, arg5::int_t, arg6::int_t, arg7::Ptr{Pslu_freeable_t}, arg8::Ptr{Llu_symbfact_t}, arg9::Ptr{vtcsInfo_symbfact_t}, arg10::Ptr{psymbfact_stat_t})::int_t
end
function psymbfact_prLUXpand(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int32.psymbfact_prLUXpand(arg1::int_t, arg2::int_t, arg3::Cint, arg4::Ptr{Llu_symbfact_t}, arg5::Ptr{psymbfact_stat_t})::int_t
end
function isort(N, ARRAY1, ARRAY2)
@ccall libsuperlu_dist_Int32.isort(N::int_t, ARRAY1::Ptr{int_t}, ARRAY2::Ptr{int_t})::Cvoid
end
function isort1(N, ARRAY)
@ccall libsuperlu_dist_Int32.isort1(N::int_t, ARRAY::Ptr{int_t})::Cvoid
end
function estimate_cpu_time(m, n, k)
@ccall libsuperlu_dist_Int32.estimate_cpu_time(m::Cint, n::Cint, k::Cint)::Cdouble
end
# no prototype is found for this function at superlu_defs.h:1198:12, please use with caution
function get_thread_per_process()
@ccall libsuperlu_dist_Int32.get_thread_per_process()::Cint
end
# no prototype is found for this function at superlu_defs.h:1199:14, please use with caution
function get_max_buffer_size()
@ccall libsuperlu_dist_Int32.get_max_buffer_size()::int_t
end
function get_min(arg1, arg2)
@ccall libsuperlu_dist_Int32.get_min(arg1::Ptr{int_t}, arg2::int_t)::int_t
end
function compare_pair(arg1, arg2)
@ccall libsuperlu_dist_Int32.compare_pair(arg1::Ptr{Cvoid}, arg2::Ptr{Cvoid})::Cint
end
function static_partition(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.static_partition(arg1::Ptr{superlu_pair}, arg2::int_t, arg3::Ptr{int_t}, arg4::int_t, arg5::Ptr{int_t}, arg6::Ptr{int_t}, arg7::Cint)::int_t
end
# no prototype is found for this function at superlu_defs.h:1204:12, please use with caution
function get_acc_offload()
@ccall libsuperlu_dist_Int32.get_acc_offload()::Cint
end
function print_panel_seg_dist(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.print_panel_seg_dist(arg1::int_t, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{int_t}, arg6::Ptr{int_t})::Cvoid
end
function check_repfnz_dist(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.check_repfnz_dist(arg1::int_t, arg2::int_t, arg3::int_t, arg4::Ptr{int_t})::Cvoid
end
function CheckZeroDiagonal(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.CheckZeroDiagonal(arg1::int_t, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t})::int_t
end
function check_perm_dist(what, n, perm)
@ccall libsuperlu_dist_Int32.check_perm_dist(what::Ptr{Cchar}, n::int_t, perm::Ptr{int_t})::Cint
end
function PrintDouble5(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.PrintDouble5(arg1::Ptr{Cchar}, arg2::int_t, arg3::Ptr{Cdouble})::Cvoid
end
function PrintInt10(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.PrintInt10(arg1::Ptr{Cchar}, arg2::int_t, arg3::Ptr{int_t})::Cvoid
end
function PrintInt32(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.PrintInt32(arg1::Ptr{Cchar}, arg2::Cint, arg3::Ptr{Cint})::Cvoid
end
function file_PrintInt10(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.file_PrintInt10(arg1::Ptr{Libc.FILE}, arg2::Ptr{Cchar}, arg3::int_t, arg4::Ptr{int_t})::Cint
end
function file_PrintInt32(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.file_PrintInt32(arg1::Ptr{Libc.FILE}, arg2::Ptr{Cchar}, arg3::Cint, arg4::Ptr{Cint})::Cint
end
function file_PrintLong10(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.file_PrintLong10(arg1::Ptr{Libc.FILE}, arg2::Ptr{Cchar}, arg3::int_t, arg4::Ptr{int_t})::Cint
end
function C_RdTree_Create(tree, comm, ranks, rank_cnt, msgSize, precision)
@ccall libsuperlu_dist_Int32.C_RdTree_Create(tree::Ptr{C_Tree}, comm::MPI_Comm, ranks::Ptr{Cint}, rank_cnt::Cint, msgSize::Cint, precision::Cchar)::Cvoid
end
function C_RdTree_Nullify(tree)
@ccall libsuperlu_dist_Int32.C_RdTree_Nullify(tree::Ptr{C_Tree})::Cvoid
end
function C_RdTree_IsRoot(tree)
@ccall libsuperlu_dist_Int32.C_RdTree_IsRoot(tree::Ptr{C_Tree})::yes_no_t
end
function C_RdTree_forwardMessageSimple(Tree, localBuffer, msgSize)
@ccall libsuperlu_dist_Int32.C_RdTree_forwardMessageSimple(Tree::Ptr{C_Tree}, localBuffer::Ptr{Cvoid}, msgSize::Cint)::Cvoid
end
function C_RdTree_waitSendRequest(Tree)
@ccall libsuperlu_dist_Int32.C_RdTree_waitSendRequest(Tree::Ptr{C_Tree})::Cvoid
end
function C_BcTree_Create(tree, comm, ranks, rank_cnt, msgSize, precision)
@ccall libsuperlu_dist_Int32.C_BcTree_Create(tree::Ptr{C_Tree}, comm::MPI_Comm, ranks::Ptr{Cint}, rank_cnt::Cint, msgSize::Cint, precision::Cchar)::Cvoid
end
function C_BcTree_Nullify(tree)
@ccall libsuperlu_dist_Int32.C_BcTree_Nullify(tree::Ptr{C_Tree})::Cvoid
end
function C_BcTree_IsRoot(tree)
@ccall libsuperlu_dist_Int32.C_BcTree_IsRoot(tree::Ptr{C_Tree})::yes_no_t
end
function C_BcTree_forwardMessageSimple(tree, localBuffer, msgSize)
@ccall libsuperlu_dist_Int32.C_BcTree_forwardMessageSimple(tree::Ptr{C_Tree}, localBuffer::Ptr{Cvoid}, msgSize::Cint)::Cvoid
end
function C_BcTree_waitSendRequest(tree)
@ccall libsuperlu_dist_Int32.C_BcTree_waitSendRequest(tree::Ptr{C_Tree})::Cvoid
end
function DistPrint(function_name, value, Units, grid)
@ccall libsuperlu_dist_Int32.DistPrint(function_name::Ptr{Cchar}, value::Cdouble, Units::Ptr{Cchar}, grid::Ptr{gridinfo_t{Int32}})::Cvoid
end
function DistPrint3D(function_name, value, Units, grid3d)
@ccall libsuperlu_dist_Int32.DistPrint3D(function_name::Ptr{Cchar}, value::Cdouble, Units::Ptr{Cchar}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cvoid
end
function treeImbalance3D(grid3d, SCT)
@ccall libsuperlu_dist_Int32.treeImbalance3D(grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::Cvoid
end
function SCT_printComm3D(grid3d, SCT)
@ccall libsuperlu_dist_Int32.SCT_printComm3D(grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::Cvoid
end
function getPerm_c_supno(nsupers, arg2, etree, Glu_persist, Lrowind_bc_ptr, Ufstnz_br_ptr, arg7)
@ccall libsuperlu_dist_Int32.getPerm_c_supno(nsupers::int_t, arg2::Ptr{superlu_dist_options_t}, etree::Ptr{int_t}, Glu_persist::Ptr{Glu_persist_t}, Lrowind_bc_ptr::Ptr{Ptr{int_t}}, Ufstnz_br_ptr::Ptr{Ptr{int_t}}, arg7::Ptr{gridinfo_t{Int32}})::Ptr{int_t}
end
function SCT_init(arg1)
@ccall libsuperlu_dist_Int32.SCT_init(arg1::Ptr{SCT_t})::Cvoid
end
function SCT_print(grid, SCT)
@ccall libsuperlu_dist_Int32.SCT_print(grid::Ptr{gridinfo_t{Int32}}, SCT::Ptr{SCT_t})::Cvoid
end
function SCT_print3D(grid3d, SCT)
@ccall libsuperlu_dist_Int32.SCT_print3D(grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::Cvoid
end
function SCT_free(arg1)
@ccall libsuperlu_dist_Int32.SCT_free(arg1::Ptr{SCT_t})::Cvoid
end
function setree2list(nsuper, setree)
@ccall libsuperlu_dist_Int32.setree2list(nsuper::int_t, setree::Ptr{int_t})::Ptr{treeList_t{Int32}}
end
function free_treelist(nsuper, treeList)
@ccall libsuperlu_dist_Int32.free_treelist(nsuper::int_t, treeList::Ptr{treeList_t{Int32}})::Cint
end
function calcTreeWeight(nsupers, setree, treeList, xsup)
@ccall libsuperlu_dist_Int32.calcTreeWeight(nsupers::int_t, setree::Ptr{int_t}, treeList::Ptr{treeList_t{Int32}}, xsup::Ptr{int_t})::int_t
end
function getDescendList(k, dlist, treeList)
@ccall libsuperlu_dist_Int32.getDescendList(k::int_t, dlist::Ptr{int_t}, treeList::Ptr{treeList_t{Int32}})::int_t
end
function getCommonAncestorList(k, alist, seTree, treeList)
@ccall libsuperlu_dist_Int32.getCommonAncestorList(k::int_t, alist::Ptr{int_t}, seTree::Ptr{int_t}, treeList::Ptr{treeList_t{Int32}})::int_t
end
function getCommonAncsCount(k, treeList)
@ccall libsuperlu_dist_Int32.getCommonAncsCount(k::int_t, treeList::Ptr{treeList_t{Int32}})::int_t
end
function getPermNodeList(nnode, nlist, perm_c_sup, iperm_c_sup)
@ccall libsuperlu_dist_Int32.getPermNodeList(nnode::int_t, nlist::Ptr{int_t}, perm_c_sup::Ptr{int_t}, iperm_c_sup::Ptr{int_t})::Ptr{int_t}
end
function getEtreeLB(nnodes, perm_l, gTopOrder)
@ccall libsuperlu_dist_Int32.getEtreeLB(nnodes::int_t, perm_l::Ptr{int_t}, gTopOrder::Ptr{int_t})::Ptr{int_t}
end
function getSubTreeRoots(k, treeList)
@ccall libsuperlu_dist_Int32.getSubTreeRoots(k::int_t, treeList::Ptr{treeList_t{Int32}})::Ptr{int_t}
end
function merg_perms(nperms, nnodes, perms)
@ccall libsuperlu_dist_Int32.merg_perms(nperms::int_t, nnodes::Ptr{int_t}, perms::Ptr{Ptr{int_t}})::Ptr{int_t}
end
function getGlobal_iperm(nsupers, nperms, perms, nnodes)
@ccall libsuperlu_dist_Int32.getGlobal_iperm(nsupers::int_t, nperms::int_t, perms::Ptr{Ptr{int_t}}, nnodes::Ptr{int_t})::Ptr{int_t}
end
function log2i(index)
@ccall libsuperlu_dist_Int32.log2i(index::int_t)::int_t
end
function supernodal_etree(nsuper, etree, supno, xsup)
@ccall libsuperlu_dist_Int32.supernodal_etree(nsuper::int_t, etree::Ptr{int_t}, supno::Ptr{int_t}, xsup::Ptr{int_t})::Ptr{int_t}
end
function testSubtreeNodelist(nsupers, numList, nodeList, nodeCount)
@ccall libsuperlu_dist_Int32.testSubtreeNodelist(nsupers::int_t, numList::int_t, nodeList::Ptr{Ptr{int_t}}, nodeCount::Ptr{int_t})::int_t
end
function testListPerm(nodeCount, nodeList, permList, gTopLevel)
@ccall libsuperlu_dist_Int32.testListPerm(nodeCount::int_t, nodeList::Ptr{int_t}, permList::Ptr{int_t}, gTopLevel::Ptr{int_t})::int_t
end
function topological_ordering(nsuper, setree)
@ccall libsuperlu_dist_Int32.topological_ordering(nsuper::int_t, setree::Ptr{int_t})::Ptr{int_t}
end
function Etree_LevelBoundry(perm, tsort_etree, nsuper)
@ccall libsuperlu_dist_Int32.Etree_LevelBoundry(perm::Ptr{int_t}, tsort_etree::Ptr{int_t}, nsuper::int_t)::Ptr{int_t}
end
function calculate_num_children(nsuper, setree)
@ccall libsuperlu_dist_Int32.calculate_num_children(nsuper::int_t, setree::Ptr{int_t})::Ptr{int_t}
end
function Print_EtreeLevelBoundry(Etree_LvlBdry, max_level, nsuper)
@ccall libsuperlu_dist_Int32.Print_EtreeLevelBoundry(Etree_LvlBdry::Ptr{int_t}, max_level::int_t, nsuper::int_t)::Cvoid
end
function print_etree_leveled(setree, tsort_etree, nsuper)
@ccall libsuperlu_dist_Int32.print_etree_leveled(setree::Ptr{int_t}, tsort_etree::Ptr{int_t}, nsuper::int_t)::Cvoid
end
function print_etree(setree, iperm, nsuper)
@ccall libsuperlu_dist_Int32.print_etree(setree::Ptr{int_t}, iperm::Ptr{int_t}, nsuper::int_t)::Cvoid
end
function printFileList(sname, nnodes, dlist, setree)
@ccall libsuperlu_dist_Int32.printFileList(sname::Ptr{Cchar}, nnodes::int_t, dlist::Ptr{int_t}, setree::Ptr{int_t})::int_t
end
function getLastDepBtree(nsupers, treeList)
@ccall libsuperlu_dist_Int32.getLastDepBtree(nsupers::int_t, treeList::Ptr{treeList_t{Int32}})::Ptr{Cint}
end
function getReplicatedTrees(grid3d)
@ccall libsuperlu_dist_Int32.getReplicatedTrees(grid3d::Ptr{gridinfo3d_t{Int32}})::Ptr{int_t}
end
function getGridTrees(grid3d)
@ccall libsuperlu_dist_Int32.getGridTrees(grid3d::Ptr{gridinfo3d_t{Int32}})::Ptr{int_t}
end
function getNodeList(maxLvl, setree, nnodes, treeHeads, treeList)
@ccall libsuperlu_dist_Int32.getNodeList(maxLvl::int_t, setree::Ptr{int_t}, nnodes::Ptr{int_t}, treeHeads::Ptr{int_t}, treeList::Ptr{treeList_t{Int32}})::Ptr{Ptr{int_t}}
end
function calcNumNodes(maxLvl, treeHeads, treeList)
@ccall libsuperlu_dist_Int32.calcNumNodes(maxLvl::int_t, treeHeads::Ptr{int_t}, treeList::Ptr{treeList_t{Int32}})::Ptr{int_t}
end
function getTreeHeads(maxLvl, nsupers, treeList)
@ccall libsuperlu_dist_Int32.getTreeHeads(maxLvl::int_t, nsupers::int_t, treeList::Ptr{treeList_t{Int32}})::Ptr{int_t}
end
function getMyIperm(nnodes, nsupers, myPerm)
@ccall libsuperlu_dist_Int32.getMyIperm(nnodes::int_t, nsupers::int_t, myPerm::Ptr{int_t})::Ptr{int_t}
end
function getMyTopOrder(nnodes, myPerm, myIperm, setree)
@ccall libsuperlu_dist_Int32.getMyTopOrder(nnodes::int_t, myPerm::Ptr{int_t}, myIperm::Ptr{int_t}, setree::Ptr{int_t})::Ptr{int_t}
end
function getMyEtLims(nnodes, myTopOrder)
@ccall libsuperlu_dist_Int32.getMyEtLims(nnodes::int_t, myTopOrder::Ptr{int_t})::Ptr{int_t}
end
function getMyTreeTopoInfo(nnodes, nsupers, myPerm, setree)
@ccall libsuperlu_dist_Int32.getMyTreeTopoInfo(nnodes::int_t, nsupers::int_t, myPerm::Ptr{int_t}, setree::Ptr{int_t})::treeTopoInfo_t{Int32}
end
function getNestDissForests(maxLvl, nsupers, setree, treeList)
@ccall libsuperlu_dist_Int32.getNestDissForests(maxLvl::int_t, nsupers::int_t, setree::Ptr{int_t}, treeList::Ptr{treeList_t{Int32}})::Ptr{Ptr{sForest_t{Int32}}}
end
function getTreePermForest(myTreeIdxs, myZeroTrIdxs, sForests, perm_c_supno, iperm_c_supno, grid3d)
@ccall libsuperlu_dist_Int32.getTreePermForest(myTreeIdxs::Ptr{int_t}, myZeroTrIdxs::Ptr{int_t}, sForests::Ptr{sForest_t{Int32}}, perm_c_supno::Ptr{int_t}, iperm_c_supno::Ptr{int_t}, grid3d::Ptr{gridinfo3d_t{Int32}})::Ptr{Ptr{int_t}}
end
function getTreePermFr(myTreeIdxs, sForests, grid3d)
@ccall libsuperlu_dist_Int32.getTreePermFr(myTreeIdxs::Ptr{int_t}, sForests::Ptr{Ptr{sForest_t{Int32}}}, grid3d::Ptr{gridinfo3d_t{Int32}})::Ptr{Ptr{int_t}}
end
function getMyNodeCountsFr(maxLvl, myTreeIdxs, sForests)
@ccall libsuperlu_dist_Int32.getMyNodeCountsFr(maxLvl::int_t, myTreeIdxs::Ptr{int_t}, sForests::Ptr{Ptr{sForest_t{Int32}}})::Ptr{int_t}
end
function getNodeListFr(maxLvl, sForests)
@ccall libsuperlu_dist_Int32.getNodeListFr(maxLvl::int_t, sForests::Ptr{Ptr{sForest_t{Int32}}})::Ptr{Ptr{int_t}}
end
function getNodeCountsFr(maxLvl, sForests)
@ccall libsuperlu_dist_Int32.getNodeCountsFr(maxLvl::int_t, sForests::Ptr{Ptr{sForest_t{Int32}}})::Ptr{int_t}
end
function getIsNodeInMyGrid(nsupers, maxLvl, myNodeCount, treePerm)
@ccall libsuperlu_dist_Int32.getIsNodeInMyGrid(nsupers::int_t, maxLvl::int_t, myNodeCount::Ptr{int_t}, treePerm::Ptr{Ptr{int_t}})::Ptr{Cint}
end
function printForestWeightCost(sForests, SCT, grid3d)
@ccall libsuperlu_dist_Int32.printForestWeightCost(sForests::Ptr{Ptr{sForest_t{Int32}}}, SCT::Ptr{SCT_t}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cvoid
end
function getGreedyLoadBalForests(maxLvl, nsupers, setree, treeList)
@ccall libsuperlu_dist_Int32.getGreedyLoadBalForests(maxLvl::int_t, nsupers::int_t, setree::Ptr{int_t}, treeList::Ptr{treeList_t{Int32}})::Ptr{Ptr{sForest_t{Int32}}}
end
function getForests(maxLvl, nsupers, setree, treeList)
@ccall libsuperlu_dist_Int32.getForests(maxLvl::int_t, nsupers::int_t, setree::Ptr{int_t}, treeList::Ptr{treeList_t{Int32}})::Ptr{Ptr{sForest_t{Int32}}}
end
function getBigUSize(arg1, nsupers, grid, Lrowind_bc_ptr)
@ccall libsuperlu_dist_Int32.getBigUSize(arg1::Ptr{superlu_dist_options_t}, nsupers::int_t, grid::Ptr{gridinfo_t{Int32}}, Lrowind_bc_ptr::Ptr{Ptr{int_t}})::int_t
end
function getSCUweight(nsupers, treeList, xsup, Lrowind_bc_ptr, Ufstnz_br_ptr, grid3d)
@ccall libsuperlu_dist_Int32.getSCUweight(nsupers::int_t, treeList::Ptr{treeList_t{Int32}}, xsup::Ptr{int_t}, Lrowind_bc_ptr::Ptr{Ptr{int_t}}, Ufstnz_br_ptr::Ptr{Ptr{int_t}}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cvoid
end
function Wait_LUDiagSend(k, U_diag_blk_send_req, L_diag_blk_send_req, grid, SCT)
@ccall libsuperlu_dist_Int32.Wait_LUDiagSend(k::int_t, U_diag_blk_send_req::Ptr{MPI_Request}, L_diag_blk_send_req::Ptr{MPI_Request}, grid::Ptr{gridinfo_t{Int32}}, SCT::Ptr{SCT_t})::Cint
end
function getNsupers(n, Glu_persist)
@ccall libsuperlu_dist_Int32.getNsupers(n::Cint, Glu_persist::Ptr{Glu_persist_t})::Cint
end
# no prototype is found for this function at superlu_defs.h:1368:12, please use with caution
function set_tag_ub()
@ccall libsuperlu_dist_Int32.set_tag_ub()::Cint
end
function getNumThreads(arg1)
@ccall libsuperlu_dist_Int32.getNumThreads(arg1::Cint)::Cint
end
function num_full_cols_U(kk, Ufstnz_br_ptr, xsup, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.num_full_cols_U(kk::int_t, Ufstnz_br_ptr::Ptr{Ptr{int_t}}, xsup::Ptr{int_t}, arg4::Ptr{gridinfo_t{Int32}}, arg5::Ptr{int_t}, arg6::Ptr{int_t})::int_t
end
function getFactPerm(arg1)
@ccall libsuperlu_dist_Int32.getFactPerm(arg1::int_t)::Ptr{int_t}
end
function getFactIperm(arg1, arg2)
@ccall libsuperlu_dist_Int32.getFactIperm(arg1::Ptr{int_t}, arg2::int_t)::Ptr{int_t}
end
function initCommRequests(comReqs, grid)
@ccall libsuperlu_dist_Int32.initCommRequests(comReqs::Ptr{commRequests_t}, grid::Ptr{gridinfo_t{Int32}})::int_t
end
function initFactStat(nsupers, factStat)
@ccall libsuperlu_dist_Int32.initFactStat(nsupers::int_t, factStat::Ptr{factStat_t{Int32}})::int_t
end
function freeFactStat(factStat)
@ccall libsuperlu_dist_Int32.freeFactStat(factStat::Ptr{factStat_t{Int32}})::Cint
end
function initFactNodelists(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.initFactNodelists(arg1::int_t, arg2::int_t, arg3::int_t, arg4::Ptr{factNodelists_t{Int32}})::int_t
end
function freeFactNodelists(fNlists)
@ccall libsuperlu_dist_Int32.freeFactNodelists(fNlists::Ptr{factNodelists_t{Int32}})::Cint
end
function initMsgs(msgs)
@ccall libsuperlu_dist_Int32.initMsgs(msgs::Ptr{msgs_t})::int_t
end
function getNumLookAhead(arg1)
@ccall libsuperlu_dist_Int32.getNumLookAhead(arg1::Ptr{superlu_dist_options_t})::int_t
end
function initCommRequestsArr(mxLeafNode, ldt, grid)
@ccall libsuperlu_dist_Int32.initCommRequestsArr(mxLeafNode::int_t, ldt::int_t, grid::Ptr{gridinfo_t{Int32}})::Ptr{Ptr{commRequests_t}}
end
function freeCommRequestsArr(mxLeafNode, comReqss)
@ccall libsuperlu_dist_Int32.freeCommRequestsArr(mxLeafNode::int_t, comReqss::Ptr{Ptr{commRequests_t}})::Cint
end
function initMsgsArr(numLA)
@ccall libsuperlu_dist_Int32.initMsgsArr(numLA::int_t)::Ptr{Ptr{msgs_t}}
end
function freeMsgsArr(numLA, msgss)
@ccall libsuperlu_dist_Int32.freeMsgsArr(numLA::int_t, msgss::Ptr{Ptr{msgs_t}})::Cint
end
function Trs2_InitUblock_info(klst, nb, arg3, usub, arg5, arg6)
@ccall libsuperlu_dist_Int32.Trs2_InitUblock_info(klst::int_t, nb::int_t, arg3::Ptr{Ublock_info_t}, usub::Ptr{int_t}, arg5::Ptr{Glu_persist_t}, arg6::Ptr{SuperLUStat_t{Int32}})::int_t
end
function Cmpfunc_R_info(a, b)
@ccall libsuperlu_dist_Int32.Cmpfunc_R_info(a::Ptr{Cvoid}, b::Ptr{Cvoid})::Cint
end
function Cmpfunc_U_info(a, b)
@ccall libsuperlu_dist_Int32.Cmpfunc_U_info(a::Ptr{Cvoid}, b::Ptr{Cvoid})::Cint
end
function sort_R_info(Remain_info, n)
@ccall libsuperlu_dist_Int32.sort_R_info(Remain_info::Ptr{Remain_info_t}, n::Cint)::Cint
end
function sort_U_info(Ublock_info, n)
@ccall libsuperlu_dist_Int32.sort_U_info(Ublock_info::Ptr{Ublock_info_t}, n::Cint)::Cint
end
function sort_R_info_elm(Remain_info, n)
@ccall libsuperlu_dist_Int32.sort_R_info_elm(Remain_info::Ptr{Remain_info_t}, n::Cint)::Cint
end
function sort_U_info_elm(Ublock_info, n)
@ccall libsuperlu_dist_Int32.sort_U_info_elm(Ublock_info::Ptr{Ublock_info_t}, n::Cint)::Cint
end
function printTRStimer(xtrsTimer, grid3d)
@ccall libsuperlu_dist_Int32.printTRStimer(xtrsTimer::Ptr{xtrsTimer_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cvoid
end
function initTRStimer(xtrsTimer, grid)
@ccall libsuperlu_dist_Int32.initTRStimer(xtrsTimer::Ptr{xtrsTimer_t{Int32}}, grid::Ptr{gridinfo_t{Int32}})::Cvoid
end
function getTreePerm(myTreeIdxs, myZeroTrIdxs, nodeCount, nodeList, perm_c_supno, iperm_c_supno, grid3d)
@ccall libsuperlu_dist_Int32.getTreePerm(myTreeIdxs::Ptr{int_t}, myZeroTrIdxs::Ptr{int_t}, nodeCount::Ptr{int_t}, nodeList::Ptr{Ptr{int_t}}, perm_c_supno::Ptr{int_t}, iperm_c_supno::Ptr{int_t}, grid3d::Ptr{gridinfo3d_t{Int32}})::Ptr{Ptr{int_t}}
end
function getMyNodeCounts(maxLvl, myTreeIdxs, gNodeCount)
@ccall libsuperlu_dist_Int32.getMyNodeCounts(maxLvl::int_t, myTreeIdxs::Ptr{int_t}, gNodeCount::Ptr{int_t})::Ptr{int_t}
end
function checkIntVector3d(vec, len, grid3d)
@ccall libsuperlu_dist_Int32.checkIntVector3d(vec::Ptr{int_t}, len::int_t, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function reduceStat(PHASE, stat, grid3d)
@ccall libsuperlu_dist_Int32.reduceStat(PHASE::PhaseType, stat::Ptr{SuperLUStat_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function Wait_LSend(k, grid, ToSendR, s, arg5)
@ccall libsuperlu_dist_Int32.Wait_LSend(k::int_t, grid::Ptr{gridinfo_t{Int32}}, ToSendR::Ptr{Ptr{Cint}}, s::Ptr{MPI_Request}, arg5::Ptr{SCT_t})::int_t
end
function Wait_USend(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.Wait_USend(arg1::Ptr{MPI_Request}, arg2::Ptr{gridinfo_t{Int32}}, arg3::Ptr{SCT_t})::int_t
end
function Check_LRecv(arg1, msgcnt)
@ccall libsuperlu_dist_Int32.Check_LRecv(arg1::Ptr{MPI_Request}, msgcnt::Ptr{Cint})::int_t
end
function Wait_UDiagBlockSend(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.Wait_UDiagBlockSend(arg1::Ptr{MPI_Request}, arg2::Ptr{gridinfo_t{Int32}}, arg3::Ptr{SCT_t})::int_t
end
function Wait_LDiagBlockSend(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.Wait_LDiagBlockSend(arg1::Ptr{MPI_Request}, arg2::Ptr{gridinfo_t{Int32}}, arg3::Ptr{SCT_t})::int_t
end
function Wait_UDiagBlock_Recv(arg1, arg2)
@ccall libsuperlu_dist_Int32.Wait_UDiagBlock_Recv(arg1::Ptr{MPI_Request}, arg2::Ptr{SCT_t})::int_t
end
function Test_UDiagBlock_Recv(arg1, arg2)
@ccall libsuperlu_dist_Int32.Test_UDiagBlock_Recv(arg1::Ptr{MPI_Request}, arg2::Ptr{SCT_t})::int_t
end
function Wait_LDiagBlock_Recv(arg1, arg2)
@ccall libsuperlu_dist_Int32.Wait_LDiagBlock_Recv(arg1::Ptr{MPI_Request}, arg2::Ptr{SCT_t})::int_t
end
function Test_LDiagBlock_Recv(arg1, arg2)
@ccall libsuperlu_dist_Int32.Test_LDiagBlock_Recv(arg1::Ptr{MPI_Request}, arg2::Ptr{SCT_t})::int_t
end
function LDiagBlockRecvWait(k, factored_U, arg3, arg4)
@ccall libsuperlu_dist_Int32.LDiagBlockRecvWait(k::int_t, factored_U::Ptr{int_t}, arg3::Ptr{MPI_Request}, arg4::Ptr{gridinfo_t{Int32}})::int_t
end
function scuStatUpdate(knsupc, HyP, SCT, stat)
@ccall libsuperlu_dist_Int32.scuStatUpdate(knsupc::int_t, HyP::Ptr{HyP_t}, SCT::Ptr{SCT_t}, stat::Ptr{SuperLUStat_t{Int32}})::int_t
end
function sCreate_CompCol_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int32.sCreate_CompCol_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{Cfloat}, arg6::Ptr{int_t}, arg7::Ptr{int_t}, arg8::Stype_t, arg9::Dtype_t, arg10::Mtype_t)::Cvoid
end
function sCreate_CompRowLoc_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int32.sCreate_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::int_t, arg6::int_t, arg7::Ptr{Cfloat}, arg8::Ptr{int_t}, arg9::Ptr{int_t}, arg10::Stype_t, arg11::Dtype_t, arg12::Mtype_t)::Cvoid
end
function sCompRow_to_CompCol_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.sCompRow_to_CompCol_dist(arg1::int_t, arg2::int_t, arg3::int_t, arg4::Ptr{Cfloat}, arg5::Ptr{int_t}, arg6::Ptr{int_t}, arg7::Ptr{Ptr{Cfloat}}, arg8::Ptr{Ptr{int_t}}, arg9::Ptr{Ptr{int_t}})::Cvoid
end
function psCompRow_loc_to_CompCol_global(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.psCompRow_loc_to_CompCol_global(arg1::int_t, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{SuperMatrix{Int32}})::Cint
end
function sCopy_CompCol_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int32.sCopy_CompCol_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{SuperMatrix{Int32}})::Cvoid
end
function sCreate_Dense_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.sCreate_Dense_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::int_t, arg3::int_t, arg4::Ptr{Cfloat}, arg5::int_t, arg6::Stype_t, arg7::Dtype_t, arg8::Mtype_t)::Cvoid
end
function sCreate_SuperNode_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13)
@ccall libsuperlu_dist_Int32.sCreate_SuperNode_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{Cfloat}, arg6::Ptr{int_t}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{int_t}, arg10::Ptr{int_t}, arg11::Stype_t, arg12::Dtype_t, arg13::Mtype_t)::Cvoid
end
function sCopy_Dense_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.sCopy_Dense_Matrix_dist(arg1::int_t, arg2::int_t, arg3::Ptr{Cfloat}, arg4::int_t, arg5::Ptr{Cfloat}, arg6::int_t)::Cvoid
end
function sallocateA_dist(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int32.sallocateA_dist(arg1::int_t, arg2::int_t, arg3::Ptr{Ptr{Cfloat}}, arg4::Ptr{Ptr{int_t}}, arg5::Ptr{Ptr{int_t}})::Cvoid
end
function sGenXtrue_dist(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.sGenXtrue_dist(arg1::int_t, arg2::int_t, arg3::Ptr{Cfloat}, arg4::int_t)::Cvoid
end
function sFillRHS_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.sFillRHS_dist(arg1::Ptr{Cchar}, arg2::int_t, arg3::Ptr{Cfloat}, arg4::int_t, arg5::Ptr{SuperMatrix{Int32}}, arg6::Ptr{Cfloat}, arg7::int_t)::Cvoid
end
function screate_matrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.screate_matrix(arg1::Ptr{SuperMatrix{Int32}}, arg2::Cint, arg3::Ptr{Ptr{Cfloat}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{Cfloat}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{gridinfo_t{Int32}})::Cint
end
function screate_matrix_rb(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.screate_matrix_rb(arg1::Ptr{SuperMatrix{Int32}}, arg2::Cint, arg3::Ptr{Ptr{Cfloat}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{Cfloat}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{gridinfo_t{Int32}})::Cint
end
function screate_matrix_dat(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.screate_matrix_dat(arg1::Ptr{SuperMatrix{Int32}}, arg2::Cint, arg3::Ptr{Ptr{Cfloat}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{Cfloat}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{gridinfo_t{Int32}})::Cint
end
function screate_matrix_postfix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.screate_matrix_postfix(arg1::Ptr{SuperMatrix{Int32}}, arg2::Cint, arg3::Ptr{Ptr{Cfloat}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{Cfloat}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{Cchar}, arg9::Ptr{gridinfo_t{Int32}})::Cint
end
function sScalePermstructInit(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.sScalePermstructInit(arg1::int_t, arg2::int_t, arg3::Ptr{sScalePermstruct_t{Int32}})::Cvoid
end
function sScalePermstructFree(arg1)
@ccall libsuperlu_dist_Int32.sScalePermstructFree(arg1::Ptr{sScalePermstruct_t{Int32}})::Cvoid
end
function sgsequ_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.sgsequ_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{Cfloat}, arg3::Ptr{Cfloat}, arg4::Ptr{Cfloat}, arg5::Ptr{Cfloat}, arg6::Ptr{Cfloat}, arg7::Ptr{int_t})::Cvoid
end
function slangs_dist(arg1, arg2)
@ccall libsuperlu_dist_Int32.slangs_dist(arg1::Ptr{Cchar}, arg2::Ptr{SuperMatrix{Int32}})::Cfloat
end
function slaqgs_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.slaqgs_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{Cfloat}, arg3::Ptr{Cfloat}, arg4::Cfloat, arg5::Cfloat, arg6::Cfloat, arg7::Ptr{Cchar})::Cvoid
end
function psgsequ(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.psgsequ(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{Cfloat}, arg3::Ptr{Cfloat}, arg4::Ptr{Cfloat}, arg5::Ptr{Cfloat}, arg6::Ptr{Cfloat}, arg7::Ptr{int_t}, arg8::Ptr{gridinfo_t{Int32}})::Cvoid
end
function pslangs(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.pslangs(arg1::Ptr{Cchar}, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{gridinfo_t{Int32}})::Cfloat
end
function pslaqgs(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.pslaqgs(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{Cfloat}, arg3::Ptr{Cfloat}, arg4::Cfloat, arg5::Cfloat, arg6::Cfloat, arg7::Ptr{Cchar})::Cvoid
end
function psPermute_Dense_Matrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int32.psPermute_Dense_Matrix(arg1::int_t, arg2::int_t, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Cfloat}, arg6::Cint, arg7::Ptr{Cfloat}, arg8::Cint, arg9::Cint, arg10::Ptr{gridinfo_t{Int32}})::Cint
end
function sp_strsv_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.sp_strsv_dist(arg1::Ptr{Cchar}, arg2::Ptr{Cchar}, arg3::Ptr{Cchar}, arg4::Ptr{SuperMatrix{Int32}}, arg5::Ptr{SuperMatrix{Int32}}, arg6::Ptr{Cfloat}, arg7::Ptr{Cint})::Cint
end
function sp_sgemv_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.sp_sgemv_dist(arg1::Ptr{Cchar}, arg2::Cfloat, arg3::Ptr{SuperMatrix{Int32}}, arg4::Ptr{Cfloat}, arg5::Cint, arg6::Cfloat, arg7::Ptr{Cfloat}, arg8::Cint)::Cint
end
function sp_sgemm_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.sp_sgemm_dist(arg1::Ptr{Cchar}, arg2::Cint, arg3::Cfloat, arg4::Ptr{SuperMatrix{Int32}}, arg5::Ptr{Cfloat}, arg6::Cint, arg7::Cfloat, arg8::Ptr{Cfloat}, arg9::Cint)::Cint
end
function sdistribute(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.sdistribute(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int32}}, arg4::Ptr{Glu_freeable_t{Int32}}, arg5::Ptr{sLUstruct_t{Int32}}, arg6::Ptr{gridinfo_t{Int32}})::Cfloat
end
function psgssvx_ABglobal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
@ccall libsuperlu_dist_Int32.psgssvx_ABglobal(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{sScalePermstruct_t{Int32}}, arg4::Ptr{Cfloat}, arg5::Cint, arg6::Cint, arg7::Ptr{gridinfo_t{Int32}}, arg8::Ptr{sLUstruct_t{Int32}}, arg9::Ptr{Cfloat}, arg10::Ptr{SuperLUStat_t{Int32}}, arg11::Ptr{Cint})::Cvoid
end
function psdistribute(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.psdistribute(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int32}}, arg4::Ptr{sScalePermstruct_t{Int32}}, arg5::Ptr{Glu_freeable_t{Int32}}, arg6::Ptr{sLUstruct_t{Int32}}, arg7::Ptr{gridinfo_t{Int32}})::Cfloat
end
function psgssvx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int32.psgssvx(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{sScalePermstruct_t{Int32}}, arg4::Ptr{Cfloat}, arg5::Cint, arg6::Cint, arg7::Ptr{gridinfo_t{Int32}}, arg8::Ptr{sLUstruct_t{Int32}}, arg9::Ptr{sSOLVEstruct_t{Int32}}, arg10::Ptr{Cfloat}, arg11::Ptr{SuperLUStat_t{Int32}}, arg12::Ptr{Cint})::Cvoid
end
function psCompute_Diag_Inv(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int32.psCompute_Diag_Inv(arg1::int_t, arg2::Ptr{sLUstruct_t{Int32}}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{SuperLUStat_t{Int32}}, arg5::Ptr{Cint})::Cvoid
end
function sSolveInit(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.sSolveInit(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::int_t, arg6::Ptr{sLUstruct_t{Int32}}, arg7::Ptr{gridinfo_t{Int32}}, arg8::Ptr{sSOLVEstruct_t{Int32}})::Cint
end
function sSolveFinalize(arg1, arg2)
@ccall libsuperlu_dist_Int32.sSolveFinalize(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{sSOLVEstruct_t{Int32}})::Cvoid
end
function sDestroy_A3d_gathered_on_2d(arg1, arg2)
@ccall libsuperlu_dist_Int32.sDestroy_A3d_gathered_on_2d(arg1::Ptr{sSOLVEstruct_t{Int32}}, arg2::Ptr{gridinfo3d_t{Int32}})::Cvoid
end
function psgstrs_init(arg1, arg2, arg3, arg4, arg5, arg6, grid, arg8, arg9)
@ccall libsuperlu_dist_Int32.psgstrs_init(arg1::int_t, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{int_t}, arg6::Ptr{int_t}, grid::Ptr{gridinfo_t{Int32}}, arg8::Ptr{Glu_persist_t}, arg9::Ptr{sSOLVEstruct_t{Int32}})::int_t
end
function pxgstrs_finalize(arg1)
@ccall libsuperlu_dist_Int32.pxgstrs_finalize(arg1::Ptr{pxgstrs_comm_t})::Cvoid
end
function sldperm_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.sldperm_dist(arg1::Cint, arg2::Cint, arg3::int_t, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{Cfloat}, arg7::Ptr{int_t}, arg8::Ptr{Cfloat}, arg9::Ptr{Cfloat})::Cint
end
function sstatic_schedule(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.sstatic_schedule(arg1::Ptr{superlu_dist_options_t}, arg2::Cint, arg3::Cint, arg4::Ptr{sLUstruct_t{Int32}}, arg5::Ptr{gridinfo_t{Int32}}, arg6::Ptr{SuperLUStat_t{Int32}}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{Cint})::Cint
end
function sLUstructInit(arg1, arg2)
@ccall libsuperlu_dist_Int32.sLUstructInit(arg1::int_t, arg2::Ptr{sLUstruct_t{Int32}})::Cvoid
end
function sLUstructFree(arg1)
@ccall libsuperlu_dist_Int32.sLUstructFree(arg1::Ptr{sLUstruct_t{Int32}})::Cvoid
end
function sDestroy_LU(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.sDestroy_LU(arg1::int_t, arg2::Ptr{gridinfo_t{Int32}}, arg3::Ptr{sLUstruct_t{Int32}})::Cvoid
end
function sDestroy_Tree(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.sDestroy_Tree(arg1::int_t, arg2::Ptr{gridinfo_t{Int32}}, arg3::Ptr{sLUstruct_t{Int32}})::Cvoid
end
function sscatter_l(ib, ljb, nsupc, iukp, xsup, klst, nbrow, lptr, temp_nbrow, usub, lsub, tempv, indirect_thread, indirect2, Lrowind_bc_ptr, Lnzval_bc_ptr, grid)
@ccall libsuperlu_dist_Int32.sscatter_l(ib::Cint, ljb::Cint, nsupc::Cint, iukp::int_t, xsup::Ptr{int_t}, klst::Cint, nbrow::Cint, lptr::int_t, temp_nbrow::Cint, usub::Ptr{int_t}, lsub::Ptr{int_t}, tempv::Ptr{Cfloat}, indirect_thread::Ptr{Cint}, indirect2::Ptr{Cint}, Lrowind_bc_ptr::Ptr{Ptr{int_t}}, Lnzval_bc_ptr::Ptr{Ptr{Cfloat}}, grid::Ptr{gridinfo_t{Int32}})::Cvoid
end
function sscatter_u(ib, jb, nsupc, iukp, xsup, klst, nbrow, lptr, temp_nbrow, lsub, usub, tempv, Ufstnz_br_ptr, Unzval_br_ptr, grid)
@ccall libsuperlu_dist_Int32.sscatter_u(ib::Cint, jb::Cint, nsupc::Cint, iukp::int_t, xsup::Ptr{int_t}, klst::Cint, nbrow::Cint, lptr::int_t, temp_nbrow::Cint, lsub::Ptr{int_t}, usub::Ptr{int_t}, tempv::Ptr{Cfloat}, Ufstnz_br_ptr::Ptr{Ptr{int_t}}, Unzval_br_ptr::Ptr{Ptr{Cfloat}}, grid::Ptr{gridinfo_t{Int32}})::Cvoid
end
function psgstrf(arg1, arg2, arg3, anorm, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.psgstrf(arg1::Ptr{superlu_dist_options_t}, arg2::Cint, arg3::Cint, anorm::Cfloat, arg5::Ptr{sLUstruct_t{Int32}}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{SuperLUStat_t{Int32}}, arg8::Ptr{Cint})::int_t
end
function psgstrs_Bglobal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.psgstrs_Bglobal(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{sLUstruct_t{Int32}}, arg4::Ptr{gridinfo_t{Int32}}, arg5::Ptr{Cfloat}, arg6::int_t, arg7::Cint, arg8::Ptr{SuperLUStat_t{Int32}}, arg9::Ptr{Cint})::Cvoid
end
function psgstrs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13)
@ccall libsuperlu_dist_Int32.psgstrs(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{sLUstruct_t{Int32}}, arg4::Ptr{sScalePermstruct_t{Int32}}, arg5::Ptr{gridinfo_t{Int32}}, arg6::Ptr{Cfloat}, arg7::int_t, arg8::int_t, arg9::int_t, arg10::Cint, arg11::Ptr{sSOLVEstruct_t{Int32}}, arg12::Ptr{SuperLUStat_t{Int32}}, arg13::Ptr{Cint})::Cvoid
end
function psgstrf2_trsm(options, k0, k, thresh, arg5, arg6, arg7, arg8, tag_ub, arg10, info)
@ccall libsuperlu_dist_Int32.psgstrf2_trsm(options::Ptr{superlu_dist_options_t}, k0::int_t, k::int_t, thresh::Cdouble, arg5::Ptr{Glu_persist_t}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{sLocalLU_t{Int32}}, arg8::Ptr{MPI_Request}, tag_ub::Cint, arg10::Ptr{SuperLUStat_t{Int32}}, info::Ptr{Cint})::Cvoid
end
function psgstrs2_omp(k0, k, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.psgstrs2_omp(k0::int_t, k::int_t, arg3::Ptr{Glu_persist_t}, arg4::Ptr{gridinfo_t{Int32}}, arg5::Ptr{sLocalLU_t{Int32}}, arg6::Ptr{Ublock_info_t}, arg7::Ptr{SuperLUStat_t{Int32}})::Cvoid
end
function psReDistribute_B_to_X(B, m_loc, nrhs, ldb, fst_row, ilsum, x, arg8, arg9, arg10, arg11)
@ccall libsuperlu_dist_Int32.psReDistribute_B_to_X(B::Ptr{Cfloat}, m_loc::int_t, nrhs::Cint, ldb::int_t, fst_row::int_t, ilsum::Ptr{int_t}, x::Ptr{Cfloat}, arg8::Ptr{sScalePermstruct_t{Int32}}, arg9::Ptr{Glu_persist_t}, arg10::Ptr{gridinfo_t{Int32}}, arg11::Ptr{sSOLVEstruct_t{Int32}})::int_t
end
function slsum_fmod(arg1, arg2, arg3, arg4, arg5, arg6, arg7, fmod, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16)
@ccall libsuperlu_dist_Int32.slsum_fmod(arg1::Ptr{Cfloat}, arg2::Ptr{Cfloat}, arg3::Ptr{Cfloat}, arg4::Ptr{Cfloat}, arg5::Cint, arg6::Cint, arg7::int_t, fmod::Ptr{Cint}, arg9::int_t, arg10::int_t, arg11::int_t, arg12::Ptr{int_t}, arg13::Ptr{gridinfo_t{Int32}}, arg14::Ptr{sLocalLU_t{Int32}}, arg15::Ptr{MPI_Request}, arg16::Ptr{SuperLUStat_t{Int32}})::Cvoid
end
function slsum_bmod(arg1, arg2, arg3, arg4, arg5, bmod, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14)
@ccall libsuperlu_dist_Int32.slsum_bmod(arg1::Ptr{Cfloat}, arg2::Ptr{Cfloat}, arg3::Ptr{Cfloat}, arg4::Cint, arg5::int_t, bmod::Ptr{Cint}, arg7::Ptr{int_t}, arg8::Ptr{Ptr{Ucb_indptr_t}}, arg9::Ptr{Ptr{int_t}}, arg10::Ptr{int_t}, arg11::Ptr{gridinfo_t{Int32}}, arg12::Ptr{sLocalLU_t{Int32}}, arg13::Ptr{MPI_Request}, arg14::Ptr{SuperLUStat_t{Int32}})::Cvoid
end
function slsum_fmod_inv(arg1, arg2, arg3, arg4, arg5, arg6, fmod, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19)
@ccall libsuperlu_dist_Int32.slsum_fmod_inv(arg1::Ptr{Cfloat}, arg2::Ptr{Cfloat}, arg3::Ptr{Cfloat}, arg4::Ptr{Cfloat}, arg5::Cint, arg6::int_t, fmod::Ptr{Cint}, arg8::Ptr{int_t}, arg9::Ptr{gridinfo_t{Int32}}, arg10::Ptr{sLocalLU_t{Int32}}, arg11::Ptr{Ptr{SuperLUStat_t{Int32}}}, arg12::Ptr{int_t}, arg13::Ptr{int_t}, arg14::int_t, arg15::int_t, arg16::int_t, arg17::int_t, arg18::Cint, arg19::Cint)::Cvoid
end
function slsum_fmod_inv_master(arg1, arg2, arg3, arg4, arg5, arg6, arg7, fmod, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19)
@ccall libsuperlu_dist_Int32.slsum_fmod_inv_master(arg1::Ptr{Cfloat}, arg2::Ptr{Cfloat}, arg3::Ptr{Cfloat}, arg4::Ptr{Cfloat}, arg5::Cint, arg6::Cint, arg7::int_t, fmod::Ptr{Cint}, arg9::int_t, arg10::Ptr{int_t}, arg11::Ptr{gridinfo_t{Int32}}, arg12::Ptr{sLocalLU_t{Int32}}, arg13::Ptr{Ptr{SuperLUStat_t{Int32}}}, arg14::int_t, arg15::int_t, arg16::int_t, arg17::int_t, arg18::Cint, arg19::Cint)::Cvoid
end
function slsum_bmod_inv(arg1, arg2, arg3, arg4, arg5, arg6, bmod, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20)
@ccall libsuperlu_dist_Int32.slsum_bmod_inv(arg1::Ptr{Cfloat}, arg2::Ptr{Cfloat}, arg3::Ptr{Cfloat}, arg4::Ptr{Cfloat}, arg5::Cint, arg6::int_t, bmod::Ptr{Cint}, arg8::Ptr{int_t}, arg9::Ptr{Ptr{Ucb_indptr_t}}, arg10::Ptr{Ptr{int_t}}, arg11::Ptr{int_t}, arg12::Ptr{gridinfo_t{Int32}}, arg13::Ptr{sLocalLU_t{Int32}}, arg14::Ptr{Ptr{SuperLUStat_t{Int32}}}, arg15::Ptr{int_t}, arg16::Ptr{int_t}, arg17::int_t, arg18::int_t, arg19::Cint, arg20::Cint)::Cvoid
end
function slsum_bmod_inv_master(arg1, arg2, arg3, arg4, arg5, arg6, bmod, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18)
@ccall libsuperlu_dist_Int32.slsum_bmod_inv_master(arg1::Ptr{Cfloat}, arg2::Ptr{Cfloat}, arg3::Ptr{Cfloat}, arg4::Ptr{Cfloat}, arg5::Cint, arg6::int_t, bmod::Ptr{Cint}, arg8::Ptr{int_t}, arg9::Ptr{Ptr{Ucb_indptr_t}}, arg10::Ptr{Ptr{int_t}}, arg11::Ptr{int_t}, arg12::Ptr{gridinfo_t{Int32}}, arg13::Ptr{sLocalLU_t{Int32}}, arg14::Ptr{Ptr{SuperLUStat_t{Int32}}}, arg15::int_t, arg16::int_t, arg17::Cint, arg18::Cint)::Cvoid
end
function sComputeLevelsets(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.sComputeLevelsets(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{sLocalLU_t{Int32}}, arg6::Ptr{int_t})::Cvoid
end
function psgsrfs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16)
@ccall libsuperlu_dist_Int32.psgsrfs(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int32}}, arg4::Cfloat, arg5::Ptr{sLUstruct_t{Int32}}, arg6::Ptr{sScalePermstruct_t{Int32}}, arg7::Ptr{gridinfo_t{Int32}}, arg8::Ptr{Cfloat}, arg9::int_t, arg10::Ptr{Cfloat}, arg11::int_t, arg12::Cint, arg13::Ptr{sSOLVEstruct_t{Int32}}, arg14::Ptr{Cfloat}, arg15::Ptr{SuperLUStat_t{Int32}}, arg16::Ptr{Cint})::Cvoid
end
function psgsrfs_ABXglobal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14)
@ccall libsuperlu_dist_Int32.psgsrfs_ABXglobal(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int32}}, arg4::Cfloat, arg5::Ptr{sLUstruct_t{Int32}}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{Cfloat}, arg8::int_t, arg9::Ptr{Cfloat}, arg10::int_t, arg11::Cint, arg12::Ptr{Cfloat}, arg13::Ptr{SuperLUStat_t{Int32}}, arg14::Ptr{Cint})::Cvoid
end
function psgsmv_AXglobal_setup(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.psgsmv_AXglobal_setup(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{Glu_persist_t}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{int_t}}, arg6::Ptr{Ptr{Cfloat}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{int_t})::Cint
end
function psgsmv_AXglobal(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.psgsmv_AXglobal(arg1::int_t, arg2::Ptr{int_t}, arg3::Ptr{Cfloat}, arg4::Ptr{int_t}, arg5::Ptr{Cfloat}, arg6::Ptr{Cfloat})::Cint
end
function psgsmv_AXglobal_abs(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.psgsmv_AXglobal_abs(arg1::int_t, arg2::Ptr{int_t}, arg3::Ptr{Cfloat}, arg4::Ptr{int_t}, arg5::Ptr{Cfloat}, arg6::Ptr{Cfloat})::Cint
end
function psgsmv_init(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.psgsmv_init(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{int_t}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{psgsmv_comm_t{Int32}})::Cvoid
end
function psgsmv(arg1, arg2, arg3, arg4, x, ax)
@ccall libsuperlu_dist_Int32.psgsmv(arg1::int_t, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{psgsmv_comm_t{Int32}}, x::Ptr{Cfloat}, ax::Ptr{Cfloat})::Cvoid
end
function psgsmv_finalize(arg1)
@ccall libsuperlu_dist_Int32.psgsmv_finalize(arg1::Ptr{psgsmv_comm_t{Int32}})::Cvoid
end
function floatMalloc_dist(arg1)
@ccall libsuperlu_dist_Int32.floatMalloc_dist(arg1::int_t)::Ptr{Cfloat}
end
function floatCalloc_dist(arg1)
@ccall libsuperlu_dist_Int32.floatCalloc_dist(arg1::int_t)::Ptr{Cfloat}
end
function duser_malloc_dist(arg1, arg2)
@ccall libsuperlu_dist_Int32.duser_malloc_dist(arg1::int_t, arg2::int_t)::Ptr{Cvoid}
end
function duser_free_dist(arg1, arg2)
@ccall libsuperlu_dist_Int32.duser_free_dist(arg1::int_t, arg2::int_t)::Cvoid
end
function sQuerySpace_dist(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int32.sQuerySpace_dist(arg1::int_t, arg2::Ptr{sLUstruct_t{Int32}}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{SuperLUStat_t{Int32}}, arg5::Ptr{superlu_dist_mem_usage_t})::int_t
end
function sClone_CompRowLoc_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int32.sClone_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{SuperMatrix{Int32}})::Cvoid
end
function sCopy_CompRowLoc_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int32.sCopy_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{SuperMatrix{Int32}})::Cvoid
end
function sZero_CompRowLoc_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int32.sZero_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}})::Cvoid
end
function sScaleAddId_CompRowLoc_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int32.sScaleAddId_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::Cfloat)::Cvoid
end
function sScaleAdd_CompRowLoc_Matrix_dist(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.sScaleAdd_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{SuperMatrix{Int32}}, arg3::Cfloat)::Cvoid
end
function sZeroLblocks(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.sZeroLblocks(arg1::Cint, arg2::Cint, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{sLUstruct_t{Int32}})::Cvoid
end
function sZeroUblocks(iam, n, arg3, arg4)
@ccall libsuperlu_dist_Int32.sZeroUblocks(iam::Cint, n::Cint, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{sLUstruct_t{Int32}})::Cvoid
end
function sfill_dist(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.sfill_dist(arg1::Ptr{Cfloat}, arg2::int_t, arg3::Cfloat)::Cvoid
end
function sinf_norm_error_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.sinf_norm_error_dist(arg1::int_t, arg2::int_t, arg3::Ptr{Cfloat}, arg4::int_t, arg5::Ptr{Cfloat}, arg6::int_t, arg7::Ptr{gridinfo_t{Int32}})::Cvoid
end
function psinf_norm_error(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.psinf_norm_error(arg1::Cint, arg2::int_t, arg3::int_t, arg4::Ptr{Cfloat}, arg5::int_t, arg6::Ptr{Cfloat}, arg7::int_t, arg8::MPI_Comm)::Cvoid
end
function sreadhb_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.sreadhb_dist(arg1::Cint, arg2::Ptr{Libc.FILE}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{Ptr{Cfloat}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}})::Cvoid
end
function sreadtriple_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.sreadtriple_dist(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{Cfloat}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cvoid
end
function sreadtriple_noheader(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.sreadtriple_noheader(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{Cfloat}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cvoid
end
function sreadrb_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.sreadrb_dist(arg1::Cint, arg2::Ptr{Libc.FILE}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{Ptr{Cfloat}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}})::Cvoid
end
function sreadMM_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.sreadMM_dist(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{Cfloat}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cvoid
end
function sread_binary(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.sread_binary(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{Cfloat}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cint
end
function sdist_psymbtonum(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.sdist_psymbtonum(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int32}}, arg4::Ptr{sScalePermstruct_t{Int32}}, arg5::Ptr{Pslu_freeable_t}, arg6::Ptr{sLUstruct_t{Int32}}, arg7::Ptr{gridinfo_t{Int32}})::Cfloat
end
function psGetDiagU(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.psGetDiagU(arg1::int_t, arg2::Ptr{sLUstruct_t{Int32}}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{Cfloat})::Cvoid
end
function s_c2cpp_GetHWPM(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.s_c2cpp_GetHWPM(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{gridinfo_t{Int32}}, arg3::Ptr{sScalePermstruct_t{Int32}})::Cint
end
function sPrintLblocks(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int32.sPrintLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{sLocalLU_t{Int32}})::Cvoid
end
function sPrintUblocks(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int32.sPrintUblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{sLocalLU_t{Int32}})::Cvoid
end
function sPrint_CompCol_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int32.sPrint_CompCol_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}})::Cvoid
end
function sPrint_Dense_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int32.sPrint_Dense_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}})::Cvoid
end
function sPrint_CompRowLoc_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int32.sPrint_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}})::Cint
end
function file_sPrint_CompRowLoc_Matrix_dist(fp, A)
@ccall libsuperlu_dist_Int32.file_sPrint_CompRowLoc_Matrix_dist(fp::Ptr{Libc.FILE}, A::Ptr{SuperMatrix{Int32}})::Cint
end
function Printfloat5(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.Printfloat5(arg1::Ptr{Cchar}, arg2::int_t, arg3::Ptr{Cfloat})::Cvoid
end
function file_Printfloat5(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.file_Printfloat5(arg1::Ptr{Libc.FILE}, arg2::Ptr{Cchar}, arg3::int_t, arg4::Ptr{Cfloat})::Cint
end
function sGenCOOLblocks(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int32.sGenCOOLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{sLocalLU_t{Int32}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{Cfloat}}, arg9::Ptr{int_t}, arg10::Ptr{int_t})::Cvoid
end
function sGenCSCLblocks(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int32.sGenCSCLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{sLocalLU_t{Int32}}, arg6::Ptr{Ptr{Cfloat}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}}, arg9::Ptr{int_t}, arg10::Ptr{int_t})::Cvoid
end
function sGenCSRLblocks(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int32.sGenCSRLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{sLocalLU_t{Int32}}, arg6::Ptr{Ptr{Cfloat}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}}, arg9::Ptr{int_t}, arg10::Ptr{int_t})::Cvoid
end
function superlu_sgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
@ccall libsuperlu_dist_Int32.superlu_sgemm(transa::Ptr{Cchar}, transb::Ptr{Cchar}, m::Cint, n::Cint, k::Cint, alpha::Cfloat, a::Ptr{Cfloat}, lda::Cint, b::Ptr{Cfloat}, ldb::Cint, beta::Cfloat, c::Ptr{Cfloat}, ldc::Cint)::Cint
end
function superlu_strsm(sideRL, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
@ccall libsuperlu_dist_Int32.superlu_strsm(sideRL::Ptr{Cchar}, uplo::Ptr{Cchar}, transa::Ptr{Cchar}, diag::Ptr{Cchar}, m::Cint, n::Cint, alpha::Cfloat, a::Ptr{Cfloat}, lda::Cint, b::Ptr{Cfloat}, ldb::Cint)::Cint
end
function superlu_sger(m, n, alpha, x, incx, y, incy, a, lda)
@ccall libsuperlu_dist_Int32.superlu_sger(m::Cint, n::Cint, alpha::Cfloat, x::Ptr{Cfloat}, incx::Cint, y::Ptr{Cfloat}, incy::Cint, a::Ptr{Cfloat}, lda::Cint)::Cint
end
function superlu_sscal(n, alpha, x, incx)
@ccall libsuperlu_dist_Int32.superlu_sscal(n::Cint, alpha::Cfloat, x::Ptr{Cfloat}, incx::Cint)::Cint
end
function superlu_saxpy(n, alpha, x, incx, y, incy)
@ccall libsuperlu_dist_Int32.superlu_saxpy(n::Cint, alpha::Cfloat, x::Ptr{Cfloat}, incx::Cint, y::Ptr{Cfloat}, incy::Cint)::Cint
end
function superlu_sgemv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy)
@ccall libsuperlu_dist_Int32.superlu_sgemv(trans::Ptr{Cchar}, m::Cint, n::Cint, alpha::Cfloat, a::Ptr{Cfloat}, lda::Cint, x::Ptr{Cfloat}, incx::Cint, beta::Cfloat, y::Ptr{Cfloat}, incy::Cint)::Cint
end
function superlu_strsv(uplo, trans, diag, n, a, lda, x, incx)
@ccall libsuperlu_dist_Int32.superlu_strsv(uplo::Ptr{Cchar}, trans::Ptr{Cchar}, diag::Ptr{Cchar}, n::Cint, a::Ptr{Cfloat}, lda::Cint, x::Ptr{Cfloat}, incx::Cint)::Cint
end
function screate_matrix3d(A, nrhs, rhs, ldb, x, ldx, fp, grid3d)
@ccall libsuperlu_dist_Int32.screate_matrix3d(A::Ptr{SuperMatrix{Int32}}, nrhs::Cint, rhs::Ptr{Ptr{Cfloat}}, ldb::Ptr{Cint}, x::Ptr{Ptr{Cfloat}}, ldx::Ptr{Cint}, fp::Ptr{Libc.FILE}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cint
end
function screate_matrix_postfix3d(A, nrhs, rhs, ldb, x, ldx, fp, postfix, grid3d)
@ccall libsuperlu_dist_Int32.screate_matrix_postfix3d(A::Ptr{SuperMatrix{Int32}}, nrhs::Cint, rhs::Ptr{Ptr{Cfloat}}, ldb::Ptr{Cint}, x::Ptr{Ptr{Cfloat}}, ldx::Ptr{Cint}, fp::Ptr{Libc.FILE}, postfix::Ptr{Cchar}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cint
end
function sGatherNRformat_loc3d(Fact, A, B, ldb, nrhs, grid3d, arg7)
@ccall libsuperlu_dist_Int32.sGatherNRformat_loc3d(Fact::fact_t, A::Ptr{NRformat_loc{Int32}}, B::Ptr{Cfloat}, ldb::Cint, nrhs::Cint, grid3d::Ptr{gridinfo3d_t{Int32}}, arg7::Ptr{Ptr{NRformat_loc3d{Int32}}})::Cvoid
end
function sScatter_B3d(A3d, grid3d)
@ccall libsuperlu_dist_Int32.sScatter_B3d(A3d::Ptr{NRformat_loc3d{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cint
end
function psgssvx3d(arg1, arg2, arg3, B, ldb, nrhs, arg7, arg8, arg9, berr, arg11, info)
@ccall libsuperlu_dist_Int32.psgssvx3d(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{sScalePermstruct_t{Int32}}, B::Ptr{Cfloat}, ldb::Cint, nrhs::Cint, arg7::Ptr{gridinfo3d_t{Int32}}, arg8::Ptr{sLUstruct_t{Int32}}, arg9::Ptr{sSOLVEstruct_t{Int32}}, berr::Ptr{Cfloat}, arg11::Ptr{SuperLUStat_t{Int32}}, info::Ptr{Cint})::Cvoid
end
function psgstrf3d(arg1, m, n, anorm, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int32.psgstrf3d(arg1::Ptr{superlu_dist_options_t}, m::Cint, n::Cint, anorm::Cfloat, arg5::Ptr{strf3Dpartition_t{Int32}}, arg6::Ptr{SCT_t}, arg7::Ptr{sLUstruct_t{Int32}}, arg8::Ptr{gridinfo3d_t{Int32}}, arg9::Ptr{SuperLUStat_t{Int32}}, arg10::Ptr{Cint})::int_t
end
function sInit_HyP(HyP, Llu, mcb, mrb)
@ccall libsuperlu_dist_Int32.sInit_HyP(HyP::Ptr{HyP_t}, Llu::Ptr{sLocalLU_t{Int32}}, mcb::int_t, mrb::int_t)::Cvoid
end
function Free_HyP(HyP)
@ccall libsuperlu_dist_Int32.Free_HyP(HyP::Ptr{HyP_t})::Cvoid
end
function updateDirtyBit(k0, HyP, grid)
@ccall libsuperlu_dist_Int32.updateDirtyBit(k0::int_t, HyP::Ptr{HyP_t}, grid::Ptr{gridinfo_t{Int32}})::Cint
end
function sblock_gemm_scatter(lb, j, Ublock_info, Remain_info, L_mat, ldl, U_mat, ldu, bigV, knsupc, klst, lsub, usub, ldt, thread_id, indirect, indirect2, Lrowind_bc_ptr, Lnzval_bc_ptr, Ufstnz_br_ptr, Unzval_br_ptr, xsup, arg23, arg24)
@ccall libsuperlu_dist_Int32.sblock_gemm_scatter(lb::int_t, j::int_t, Ublock_info::Ptr{Ublock_info_t}, Remain_info::Ptr{Remain_info_t}, L_mat::Ptr{Cfloat}, ldl::Cint, U_mat::Ptr{Cfloat}, ldu::Cint, bigV::Ptr{Cfloat}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, thread_id::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, Lrowind_bc_ptr::Ptr{Ptr{int_t}}, Lnzval_bc_ptr::Ptr{Ptr{Cfloat}}, Ufstnz_br_ptr::Ptr{Ptr{int_t}}, Unzval_br_ptr::Ptr{Ptr{Cfloat}}, xsup::Ptr{int_t}, arg23::Ptr{gridinfo_t{Int32}}, arg24::Ptr{SuperLUStat_t{Int32}})::Cvoid
end
function sblock_gemm_scatterTopLeft(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int32.sblock_gemm_scatterTopLeft(lb::int_t, j::int_t, bigV::Ptr{Cfloat}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{sLUstruct_t{Int32}}, arg13::Ptr{gridinfo_t{Int32}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int32}})::int_t
end
function sblock_gemm_scatterTopRight(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int32.sblock_gemm_scatterTopRight(lb::int_t, j::int_t, bigV::Ptr{Cfloat}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{sLUstruct_t{Int32}}, arg13::Ptr{gridinfo_t{Int32}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int32}})::int_t
end
function sblock_gemm_scatterBottomLeft(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int32.sblock_gemm_scatterBottomLeft(lb::int_t, j::int_t, bigV::Ptr{Cfloat}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{sLUstruct_t{Int32}}, arg13::Ptr{gridinfo_t{Int32}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int32}})::int_t
end
function sblock_gemm_scatterBottomRight(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int32.sblock_gemm_scatterBottomRight(lb::int_t, j::int_t, bigV::Ptr{Cfloat}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{sLUstruct_t{Int32}}, arg13::Ptr{gridinfo_t{Int32}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int32}})::int_t
end
function sgather_u(num_u_blks, Ublock_info, usub, uval, bigU, ldu, xsup, klst)
@ccall libsuperlu_dist_Int32.sgather_u(num_u_blks::int_t, Ublock_info::Ptr{Ublock_info_t}, usub::Ptr{int_t}, uval::Ptr{Cfloat}, bigU::Ptr{Cfloat}, ldu::int_t, xsup::Ptr{int_t}, klst::int_t)::Cvoid
end
function sgather_l(num_LBlk, knsupc, L_info, lval, LD_lval, L_buff)
@ccall libsuperlu_dist_Int32.sgather_l(num_LBlk::int_t, knsupc::int_t, L_info::Ptr{Remain_info_t}, lval::Ptr{Cfloat}, LD_lval::int_t, L_buff::Ptr{Cfloat})::Cvoid
end
function sRgather_L(k, lsub, lusup, arg4, arg5, arg6, arg7, myIperm, iperm_c_supno)
@ccall libsuperlu_dist_Int32.sRgather_L(k::int_t, lsub::Ptr{int_t}, lusup::Ptr{Cfloat}, arg4::Ptr{gEtreeInfo_t{Int32}}, arg5::Ptr{Glu_persist_t}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{HyP_t}, myIperm::Ptr{int_t}, iperm_c_supno::Ptr{int_t})::Cvoid
end
function sRgather_U(k, jj0, usub, uval, bigU, arg6, arg7, arg8, arg9, myIperm, iperm_c_supno, perm_u)
@ccall libsuperlu_dist_Int32.sRgather_U(k::int_t, jj0::int_t, usub::Ptr{int_t}, uval::Ptr{Cfloat}, bigU::Ptr{Cfloat}, arg6::Ptr{gEtreeInfo_t{Int32}}, arg7::Ptr{Glu_persist_t}, arg8::Ptr{gridinfo_t{Int32}}, arg9::Ptr{HyP_t}, myIperm::Ptr{int_t}, iperm_c_supno::Ptr{int_t}, perm_u::Ptr{int_t})::Cvoid
end
function sinitTrf3Dpartition(nsupers, options, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.sinitTrf3Dpartition(nsupers::int_t, options::Ptr{superlu_dist_options_t}, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::Ptr{strf3Dpartition_t{Int32}}
end
function sDestroy_trf3Dpartition(trf3Dpartition, grid3d)
@ccall libsuperlu_dist_Int32.sDestroy_trf3Dpartition(trf3Dpartition::Ptr{strf3Dpartition_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cvoid
end
function s3D_printMemUse(trf3Dpartition, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.s3D_printMemUse(trf3Dpartition::Ptr{strf3Dpartition_t{Int32}}, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cvoid
end
function sinit3DLUstructForest(myTreeIdxs, myZeroTrIdxs, sForests, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.sinit3DLUstructForest(myTreeIdxs::Ptr{int_t}, myZeroTrIdxs::Ptr{int_t}, sForests::Ptr{Ptr{sForest_t{Int32}}}, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cvoid
end
function sgatherAllFactoredLUFr(myZeroTrIdxs, sForests, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.sgatherAllFactoredLUFr(myZeroTrIdxs::Ptr{int_t}, sForests::Ptr{sForest_t{Int32}}, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function sLpanelUpdate(off0, nsupc, ublk_ptr, ld_ujrow, lusup, nsupr, arg7)
@ccall libsuperlu_dist_Int32.sLpanelUpdate(off0::int_t, nsupc::int_t, ublk_ptr::Ptr{Cfloat}, ld_ujrow::int_t, lusup::Ptr{Cfloat}, nsupr::int_t, arg7::Ptr{SCT_t})::int_t
end
function Local_Sgstrf2(options, k, thresh, BlockUFactor, arg5, arg6, arg7, arg8, info, arg10)
@ccall libsuperlu_dist_Int32.Local_Sgstrf2(options::Ptr{superlu_dist_options_t}, k::int_t, thresh::Cdouble, BlockUFactor::Ptr{Cfloat}, arg5::Ptr{Glu_persist_t}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{sLocalLU_t{Int32}}, arg8::Ptr{SuperLUStat_t{Int32}}, info::Ptr{Cint}, arg10::Ptr{SCT_t})::Cvoid
end
function sTrs2_GatherU(iukp, rukp, klst, nsupc, ldu, usub, uval, tempv)
@ccall libsuperlu_dist_Int32.sTrs2_GatherU(iukp::int_t, rukp::int_t, klst::int_t, nsupc::int_t, ldu::int_t, usub::Ptr{int_t}, uval::Ptr{Cfloat}, tempv::Ptr{Cfloat})::int_t
end
function sTrs2_ScatterU(iukp, rukp, klst, nsupc, ldu, usub, uval, tempv)
@ccall libsuperlu_dist_Int32.sTrs2_ScatterU(iukp::int_t, rukp::int_t, klst::int_t, nsupc::int_t, ldu::int_t, usub::Ptr{int_t}, uval::Ptr{Cfloat}, tempv::Ptr{Cfloat})::int_t
end
function sTrs2_GatherTrsmScatter(klst, iukp, rukp, usub, uval, tempv, knsupc, nsupr, lusup, Glu_persist)
@ccall libsuperlu_dist_Int32.sTrs2_GatherTrsmScatter(klst::int_t, iukp::int_t, rukp::int_t, usub::Ptr{int_t}, uval::Ptr{Cfloat}, tempv::Ptr{Cfloat}, knsupc::int_t, nsupr::Cint, lusup::Ptr{Cfloat}, Glu_persist::Ptr{Glu_persist_t})::int_t
end
function psgstrs2(m, k0, k, Glu_persist, grid, Llu, stat)
@ccall libsuperlu_dist_Int32.psgstrs2(m::int_t, k0::int_t, k::int_t, Glu_persist::Ptr{Glu_persist_t}, grid::Ptr{gridinfo_t{Int32}}, Llu::Ptr{sLocalLU_t{Int32}}, stat::Ptr{SuperLUStat_t{Int32}})::Cvoid
end
function psgstrf2(arg1, nsupers, k0, k, thresh, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int32.psgstrf2(arg1::Ptr{superlu_dist_options_t}, nsupers::int_t, k0::int_t, k::int_t, thresh::Cdouble, arg6::Ptr{Glu_persist_t}, arg7::Ptr{gridinfo_t{Int32}}, arg8::Ptr{sLocalLU_t{Int32}}, arg9::Ptr{MPI_Request}, arg10::Cint, arg11::Ptr{SuperLUStat_t{Int32}}, arg12::Ptr{Cint})::Cvoid
end
function sAllocLlu_3d(nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.sAllocLlu_3d(nsupers::int_t, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function sp3dScatter(n, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.sp3dScatter(n::int_t, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function sscatter3dLPanels(nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.sscatter3dLPanels(nsupers::int_t, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function sscatter3dUPanels(nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.sscatter3dUPanels(nsupers::int_t, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function scollect3dLpanels(layer, nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.scollect3dLpanels(layer::int_t, nsupers::int_t, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function scollect3dUpanels(layer, nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.scollect3dUpanels(layer::int_t, nsupers::int_t, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function sp3dCollect(layer, n, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.sp3dCollect(layer::int_t, n::int_t, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function szeroSetLU(nnodes, nodeList, arg3, arg4)
@ccall libsuperlu_dist_Int32.szeroSetLU(nnodes::int_t, nodeList::Ptr{int_t}, arg3::Ptr{sLUstruct_t{Int32}}, arg4::Ptr{gridinfo3d_t{Int32}})::int_t
end
function sAllocGlu_3d(n, nsupers, arg3)
@ccall libsuperlu_dist_Int32.sAllocGlu_3d(n::int_t, nsupers::int_t, arg3::Ptr{sLUstruct_t{Int32}})::Cint
end
function sDeAllocLlu_3d(n, arg2, arg3)
@ccall libsuperlu_dist_Int32.sDeAllocLlu_3d(n::int_t, arg2::Ptr{sLUstruct_t{Int32}}, arg3::Ptr{gridinfo3d_t{Int32}})::Cint
end
function sDeAllocGlu_3d(arg1)
@ccall libsuperlu_dist_Int32.sDeAllocGlu_3d(arg1::Ptr{sLUstruct_t{Int32}})::Cint
end
function sreduceAncestors3d(sender, receiver, nnodes, nodeList, Lval_buf, Uval_buf, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.sreduceAncestors3d(sender::int_t, receiver::int_t, nnodes::int_t, nodeList::Ptr{int_t}, Lval_buf::Ptr{Cfloat}, Uval_buf::Ptr{Cfloat}, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function sreduceAllAncestors3d(ilvl, myNodeCount, treePerm, LUvsb, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.sreduceAllAncestors3d(ilvl::int_t, myNodeCount::Ptr{int_t}, treePerm::Ptr{Ptr{int_t}}, LUvsb::Ptr{sLUValSubBuf_t{Int32}}, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::Cint
end
function sgatherFactoredLU(sender, receiver, nnodes, nodeList, LUvsb, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.sgatherFactoredLU(sender::int_t, receiver::int_t, nnodes::int_t, nodeList::Ptr{int_t}, LUvsb::Ptr{sLUValSubBuf_t{Int32}}, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function sgatherAllFactoredLU(trf3Dpartition, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.sgatherAllFactoredLU(trf3Dpartition::Ptr{strf3Dpartition_t{Int32}}, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function sinit3DLUstruct(myTreeIdxs, myZeroTrIdxs, nodeCount, nodeList, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.sinit3DLUstruct(myTreeIdxs::Ptr{int_t}, myZeroTrIdxs::Ptr{int_t}, nodeCount::Ptr{int_t}, nodeList::Ptr{Ptr{int_t}}, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function szSendLPanel(k, receiver, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.szSendLPanel(k::int_t, receiver::int_t, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function szRecvLPanel(k, sender, alpha, beta, Lval_buf, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.szRecvLPanel(k::int_t, sender::int_t, alpha::Cfloat, beta::Cfloat, Lval_buf::Ptr{Cfloat}, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function szSendUPanel(k, receiver, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.szSendUPanel(k::int_t, receiver::int_t, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function szRecvUPanel(k, sender, alpha, beta, Uval_buf, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.szRecvUPanel(k::int_t, sender::int_t, alpha::Cfloat, beta::Cfloat, Uval_buf::Ptr{Cfloat}, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function sIBcast_LPanel(k, k0, lsub, lusup, arg5, msgcnt, arg7, ToSendR, xsup, arg10)
@ccall libsuperlu_dist_Int32.sIBcast_LPanel(k::int_t, k0::int_t, lsub::Ptr{int_t}, lusup::Ptr{Cfloat}, arg5::Ptr{gridinfo_t{Int32}}, msgcnt::Ptr{Cint}, arg7::Ptr{MPI_Request}, ToSendR::Ptr{Ptr{Cint}}, xsup::Ptr{int_t}, arg10::Cint)::int_t
end
function sBcast_LPanel(k, k0, lsub, lusup, arg5, msgcnt, ToSendR, xsup, arg9, arg10)
@ccall libsuperlu_dist_Int32.sBcast_LPanel(k::int_t, k0::int_t, lsub::Ptr{int_t}, lusup::Ptr{Cfloat}, arg5::Ptr{gridinfo_t{Int32}}, msgcnt::Ptr{Cint}, ToSendR::Ptr{Ptr{Cint}}, xsup::Ptr{int_t}, arg9::Ptr{SCT_t}, arg10::Cint)::int_t
end
function sIBcast_UPanel(k, k0, usub, uval, arg5, msgcnt, arg7, ToSendD, arg9)
@ccall libsuperlu_dist_Int32.sIBcast_UPanel(k::int_t, k0::int_t, usub::Ptr{int_t}, uval::Ptr{Cfloat}, arg5::Ptr{gridinfo_t{Int32}}, msgcnt::Ptr{Cint}, arg7::Ptr{MPI_Request}, ToSendD::Ptr{Cint}, arg9::Cint)::int_t
end
function sBcast_UPanel(k, k0, usub, uval, arg5, msgcnt, ToSendD, arg8, arg9)
@ccall libsuperlu_dist_Int32.sBcast_UPanel(k::int_t, k0::int_t, usub::Ptr{int_t}, uval::Ptr{Cfloat}, arg5::Ptr{gridinfo_t{Int32}}, msgcnt::Ptr{Cint}, ToSendD::Ptr{Cint}, arg8::Ptr{SCT_t}, arg9::Cint)::int_t
end
function sIrecv_LPanel(k, k0, Lsub_buf, Lval_buf, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.sIrecv_LPanel(k::int_t, k0::int_t, Lsub_buf::Ptr{int_t}, Lval_buf::Ptr{Cfloat}, arg5::Ptr{gridinfo_t{Int32}}, arg6::Ptr{MPI_Request}, arg7::Ptr{sLocalLU_t{Int32}}, arg8::Cint)::int_t
end
function sIrecv_UPanel(k, k0, Usub_buf, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.sIrecv_UPanel(k::int_t, k0::int_t, Usub_buf::Ptr{int_t}, arg4::Ptr{Cfloat}, arg5::Ptr{sLocalLU_t{Int32}}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{MPI_Request}, arg8::Cint)::int_t
end
function sWait_URecv(arg1, msgcnt, arg3)
@ccall libsuperlu_dist_Int32.sWait_URecv(arg1::Ptr{MPI_Request}, msgcnt::Ptr{Cint}, arg3::Ptr{SCT_t})::int_t
end
function sWait_LRecv(arg1, msgcnt, msgcntsU, arg4, arg5)
@ccall libsuperlu_dist_Int32.sWait_LRecv(arg1::Ptr{MPI_Request}, msgcnt::Ptr{Cint}, msgcntsU::Ptr{Cint}, arg4::Ptr{gridinfo_t{Int32}}, arg5::Ptr{SCT_t})::int_t
end
function sISend_UDiagBlock(k0, ublk_ptr, size, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.sISend_UDiagBlock(k0::int_t, ublk_ptr::Ptr{Cfloat}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int32}}, arg6::Cint)::int_t
end
function sRecv_UDiagBlock(k0, ublk_ptr, size, src, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.sRecv_UDiagBlock(k0::int_t, ublk_ptr::Ptr{Cfloat}, size::int_t, src::int_t, arg5::Ptr{gridinfo_t{Int32}}, arg6::Ptr{SCT_t}, arg7::Cint)::int_t
end
function sPackLBlock(k, Dest, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int32.sPackLBlock(k::int_t, Dest::Ptr{Cfloat}, arg3::Ptr{Glu_persist_t}, arg4::Ptr{gridinfo_t{Int32}}, arg5::Ptr{sLocalLU_t{Int32}})::int_t
end
function sISend_LDiagBlock(k0, lblk_ptr, size, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.sISend_LDiagBlock(k0::int_t, lblk_ptr::Ptr{Cfloat}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int32}}, arg6::Cint)::int_t
end
function sIRecv_UDiagBlock(k0, ublk_ptr, size, src, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.sIRecv_UDiagBlock(k0::int_t, ublk_ptr::Ptr{Cfloat}, size::int_t, src::int_t, arg5::Ptr{MPI_Request}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{SCT_t}, arg8::Cint)::int_t
end
function sIRecv_LDiagBlock(k0, L_blk_ptr, size, src, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.sIRecv_LDiagBlock(k0::int_t, L_blk_ptr::Ptr{Cfloat}, size::int_t, src::int_t, arg5::Ptr{MPI_Request}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{SCT_t}, arg8::Cint)::int_t
end
function sUDiagBlockRecvWait(k, IrecvPlcd_D, factored_L, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.sUDiagBlockRecvWait(k::int_t, IrecvPlcd_D::Ptr{int_t}, factored_L::Ptr{int_t}, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int32}}, arg6::Ptr{sLUstruct_t{Int32}}, arg7::Ptr{SCT_t})::int_t
end
function sIBcast_UDiagBlock(k, ublk_ptr, size, arg4, arg5)
@ccall libsuperlu_dist_Int32.sIBcast_UDiagBlock(k::int_t, ublk_ptr::Ptr{Cfloat}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int32}})::int_t
end
function sIBcast_LDiagBlock(k, lblk_ptr, size, arg4, arg5)
@ccall libsuperlu_dist_Int32.sIBcast_LDiagBlock(k::int_t, lblk_ptr::Ptr{Cfloat}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int32}})::int_t
end
function sDiagFactIBCast(k, k0, BlockUFactor, BlockLFactor, IrecvPlcd_D, arg6, arg7, arg8, arg9, arg10, arg11, thresh, LUstruct, arg14, info, arg16, tag_ub)
@ccall libsuperlu_dist_Int32.sDiagFactIBCast(k::int_t, k0::int_t, BlockUFactor::Ptr{Cfloat}, BlockLFactor::Ptr{Cfloat}, IrecvPlcd_D::Ptr{int_t}, arg6::Ptr{MPI_Request}, arg7::Ptr{MPI_Request}, arg8::Ptr{MPI_Request}, arg9::Ptr{MPI_Request}, arg10::Ptr{gridinfo_t{Int32}}, arg11::Ptr{superlu_dist_options_t}, thresh::Cdouble, LUstruct::Ptr{sLUstruct_t{Int32}}, arg14::Ptr{SuperLUStat_t{Int32}}, info::Ptr{Cint}, arg16::Ptr{SCT_t}, tag_ub::Cint)::int_t
end
function sUPanelTrSolve(k, BlockLFactor, bigV, ldt, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.sUPanelTrSolve(k::int_t, BlockLFactor::Ptr{Cfloat}, bigV::Ptr{Cfloat}, ldt::int_t, arg5::Ptr{Ublock_info_t}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{sLUstruct_t{Int32}}, arg8::Ptr{SuperLUStat_t{Int32}}, arg9::Ptr{SCT_t})::int_t
end
function sLPanelUpdate(k, IrecvPlcd_D, factored_L, arg4, BlockUFactor, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.sLPanelUpdate(k::int_t, IrecvPlcd_D::Ptr{int_t}, factored_L::Ptr{int_t}, arg4::Ptr{MPI_Request}, BlockUFactor::Ptr{Cfloat}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{sLUstruct_t{Int32}}, arg8::Ptr{SCT_t})::int_t
end
function sUPanelUpdate(k, factored_U, arg3, BlockLFactor, bigV, ldt, arg7, arg8, arg9, arg10, arg11)
@ccall libsuperlu_dist_Int32.sUPanelUpdate(k::int_t, factored_U::Ptr{int_t}, arg3::Ptr{MPI_Request}, BlockLFactor::Ptr{Cfloat}, bigV::Ptr{Cfloat}, ldt::int_t, arg7::Ptr{Ublock_info_t}, arg8::Ptr{gridinfo_t{Int32}}, arg9::Ptr{sLUstruct_t{Int32}}, arg10::Ptr{SuperLUStat_t{Int32}}, arg11::Ptr{SCT_t})::int_t
end
function sIBcastRecvLPanel(k, k0, msgcnt, arg4, arg5, Lsub_buf, Lval_buf, factored, arg9, arg10, arg11, tag_ub)
@ccall libsuperlu_dist_Int32.sIBcastRecvLPanel(k::int_t, k0::int_t, msgcnt::Ptr{Cint}, arg4::Ptr{MPI_Request}, arg5::Ptr{MPI_Request}, Lsub_buf::Ptr{int_t}, Lval_buf::Ptr{Cfloat}, factored::Ptr{int_t}, arg9::Ptr{gridinfo_t{Int32}}, arg10::Ptr{sLUstruct_t{Int32}}, arg11::Ptr{SCT_t}, tag_ub::Cint)::int_t
end
function sIBcastRecvUPanel(k, k0, msgcnt, arg4, arg5, Usub_buf, Uval_buf, arg8, arg9, arg10, tag_ub)
@ccall libsuperlu_dist_Int32.sIBcastRecvUPanel(k::int_t, k0::int_t, msgcnt::Ptr{Cint}, arg4::Ptr{MPI_Request}, arg5::Ptr{MPI_Request}, Usub_buf::Ptr{int_t}, Uval_buf::Ptr{Cfloat}, arg8::Ptr{gridinfo_t{Int32}}, arg9::Ptr{sLUstruct_t{Int32}}, arg10::Ptr{SCT_t}, tag_ub::Cint)::int_t
end
function sWaitL(k, msgcnt, msgcntU, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.sWaitL(k::int_t, msgcnt::Ptr{Cint}, msgcntU::Ptr{Cint}, arg4::Ptr{MPI_Request}, arg5::Ptr{MPI_Request}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{sLUstruct_t{Int32}}, arg8::Ptr{SCT_t})::int_t
end
function sWaitU(k, msgcnt, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.sWaitU(k::int_t, msgcnt::Ptr{Cint}, arg3::Ptr{MPI_Request}, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int32}}, arg6::Ptr{sLUstruct_t{Int32}}, arg7::Ptr{SCT_t})::int_t
end
function sLPanelTrSolve(k, factored_L, BlockUFactor, arg4, arg5)
@ccall libsuperlu_dist_Int32.sLPanelTrSolve(k::int_t, factored_L::Ptr{int_t}, BlockUFactor::Ptr{Cfloat}, arg4::Ptr{gridinfo_t{Int32}}, arg5::Ptr{sLUstruct_t{Int32}})::int_t
end
function initPackLUInfo(nsupers, packLUInfo)
@ccall libsuperlu_dist_Int32.initPackLUInfo(nsupers::int_t, packLUInfo::Ptr{packLUInfo_t{Int32}})::int_t
end
function freePackLUInfo(packLUInfo)
@ccall libsuperlu_dist_Int32.freePackLUInfo(packLUInfo::Ptr{packLUInfo_t{Int32}})::Cint
end
function sSchurComplementSetup(k, msgcnt, arg3, arg4, arg5, arg6, arg7, arg8, arg9, bigU, Lsub_buf, Lval_buf, Usub_buf, Uval_buf, arg15, arg16)
@ccall libsuperlu_dist_Int32.sSchurComplementSetup(k::int_t, msgcnt::Ptr{Cint}, arg3::Ptr{Ublock_info_t}, arg4::Ptr{Remain_info_t}, arg5::Ptr{uPanelInfo_t{Int32}}, arg6::Ptr{lPanelInfo_t{Int32}}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{int_t}, bigU::Ptr{Cfloat}, Lsub_buf::Ptr{int_t}, Lval_buf::Ptr{Cfloat}, Usub_buf::Ptr{int_t}, Uval_buf::Ptr{Cfloat}, arg15::Ptr{gridinfo_t{Int32}}, arg16::Ptr{sLUstruct_t{Int32}})::int_t
end
function sSchurComplementSetupGPU(k, msgs, arg3, arg4, arg5, arg6, arg7, arg8, arg9, LUvsb, arg11, arg12, arg13)
@ccall libsuperlu_dist_Int32.sSchurComplementSetupGPU(k::int_t, msgs::Ptr{msgs_t}, arg3::Ptr{packLUInfo_t{Int32}}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{int_t}, arg7::Ptr{gEtreeInfo_t{Int32}}, arg8::Ptr{factNodelists_t{Int32}}, arg9::Ptr{sscuBufs_t}, LUvsb::Ptr{sLUValSubBuf_t{Int32}}, arg11::Ptr{gridinfo_t{Int32}}, arg12::Ptr{sLUstruct_t{Int32}}, arg13::Ptr{HyP_t})::int_t
end
function sgetBigV(arg1, arg2)
@ccall libsuperlu_dist_Int32.sgetBigV(arg1::int_t, arg2::int_t)::Ptr{Cfloat}
end
function sgetBigU(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.sgetBigU(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{sLUstruct_t{Int32}})::Ptr{Cfloat}
end
function sLluBufInit(arg1, arg2)
@ccall libsuperlu_dist_Int32.sLluBufInit(arg1::Ptr{sLUValSubBuf_t{Int32}}, arg2::Ptr{sLUstruct_t{Int32}})::int_t
end
function sinitScuBufs(arg1, ldt, num_threads, nsupers, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.sinitScuBufs(arg1::Ptr{superlu_dist_options_t}, ldt::int_t, num_threads::int_t, nsupers::int_t, arg5::Ptr{sscuBufs_t}, arg6::Ptr{sLUstruct_t{Int32}}, arg7::Ptr{gridinfo_t{Int32}})::int_t
end
function sfreeScuBufs(scuBufs)
@ccall libsuperlu_dist_Int32.sfreeScuBufs(scuBufs::Ptr{sscuBufs_t})::Cint
end
function ssparseTreeFactor(nnodes, perm_c_supno, treeTopoInfo, comReqs, scuBufs, packLUInfo, msgs, LUvsb, dFBuf, factStat, fNlists, options, gIperm_c_supno, ldt, LUstruct, grid3d, stat, thresh, SCT, info)
@ccall libsuperlu_dist_Int32.ssparseTreeFactor(nnodes::int_t, perm_c_supno::Ptr{int_t}, treeTopoInfo::Ptr{treeTopoInfo_t{Int32}}, comReqs::Ptr{commRequests_t}, scuBufs::Ptr{sscuBufs_t}, packLUInfo::Ptr{packLUInfo_t{Int32}}, msgs::Ptr{msgs_t}, LUvsb::Ptr{sLUValSubBuf_t{Int32}}, dFBuf::Ptr{sdiagFactBufs_t}, factStat::Ptr{factStat_t{Int32}}, fNlists::Ptr{factNodelists_t{Int32}}, options::Ptr{superlu_dist_options_t}, gIperm_c_supno::Ptr{int_t}, ldt::int_t, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, stat::Ptr{SuperLUStat_t{Int32}}, thresh::Cdouble, SCT::Ptr{SCT_t}, info::Ptr{Cint})::int_t
end
function sdenseTreeFactor(nnnodes, perm_c_supno, comReqs, scuBufs, packLUInfo, msgs, LUvsb, dFBuf, factStat, fNlists, options, gIperm_c_supno, ldt, LUstruct, grid3d, stat, thresh, SCT, tag_ub, info)
@ccall libsuperlu_dist_Int32.sdenseTreeFactor(nnnodes::int_t, perm_c_supno::Ptr{int_t}, comReqs::Ptr{commRequests_t}, scuBufs::Ptr{sscuBufs_t}, packLUInfo::Ptr{packLUInfo_t{Int32}}, msgs::Ptr{msgs_t}, LUvsb::Ptr{sLUValSubBuf_t{Int32}}, dFBuf::Ptr{sdiagFactBufs_t}, factStat::Ptr{factStat_t{Int32}}, fNlists::Ptr{factNodelists_t{Int32}}, options::Ptr{superlu_dist_options_t}, gIperm_c_supno::Ptr{int_t}, ldt::int_t, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, stat::Ptr{SuperLUStat_t{Int32}}, thresh::Cdouble, SCT::Ptr{SCT_t}, tag_ub::Cint, info::Ptr{Cint})::int_t
end
function ssparseTreeFactor_ASYNC(sforest, comReqss, scuBufs, packLUInfo, msgss, LUvsbs, dFBufs, factStat, fNlists, gEtreeInfo, options, gIperm_c_supno, ldt, HyP, LUstruct, grid3d, stat, thresh, SCT, tag_ub, info)
@ccall libsuperlu_dist_Int32.ssparseTreeFactor_ASYNC(sforest::Ptr{sForest_t{Int32}}, comReqss::Ptr{Ptr{commRequests_t}}, scuBufs::Ptr{sscuBufs_t}, packLUInfo::Ptr{packLUInfo_t{Int32}}, msgss::Ptr{Ptr{msgs_t}}, LUvsbs::Ptr{Ptr{sLUValSubBuf_t{Int32}}}, dFBufs::Ptr{Ptr{sdiagFactBufs_t}}, factStat::Ptr{factStat_t{Int32}}, fNlists::Ptr{factNodelists_t{Int32}}, gEtreeInfo::Ptr{gEtreeInfo_t{Int32}}, options::Ptr{superlu_dist_options_t}, gIperm_c_supno::Ptr{int_t}, ldt::int_t, HyP::Ptr{HyP_t}, LUstruct::Ptr{sLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, stat::Ptr{SuperLUStat_t{Int32}}, thresh::Cdouble, SCT::Ptr{SCT_t}, tag_ub::Cint, info::Ptr{Cint})::int_t
end
function sLluBufInitArr(numLA, LUstruct)
@ccall libsuperlu_dist_Int32.sLluBufInitArr(numLA::int_t, LUstruct::Ptr{sLUstruct_t{Int32}})::Ptr{Ptr{sLUValSubBuf_t{Int32}}}
end
function sLluBufFreeArr(numLA, LUvsbs)
@ccall libsuperlu_dist_Int32.sLluBufFreeArr(numLA::int_t, LUvsbs::Ptr{Ptr{sLUValSubBuf_t{Int32}}})::Cint
end
function sinitDiagFactBufsArr(mxLeafNode, ldt, grid)
@ccall libsuperlu_dist_Int32.sinitDiagFactBufsArr(mxLeafNode::int_t, ldt::int_t, grid::Ptr{gridinfo_t{Int32}})::Ptr{Ptr{sdiagFactBufs_t}}
end
function sfreeDiagFactBufsArr(mxLeafNode, dFBufs)
@ccall libsuperlu_dist_Int32.sfreeDiagFactBufsArr(mxLeafNode::int_t, dFBufs::Ptr{Ptr{sdiagFactBufs_t}})::Cint
end
function sinitDiagFactBufs(ldt, dFBuf)
@ccall libsuperlu_dist_Int32.sinitDiagFactBufs(ldt::int_t, dFBuf::Ptr{sdiagFactBufs_t})::int_t
end
function checkRecvUDiag(k, comReqs, grid, SCT)
@ccall libsuperlu_dist_Int32.checkRecvUDiag(k::int_t, comReqs::Ptr{commRequests_t}, grid::Ptr{gridinfo_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function checkRecvLDiag(k, comReqs, arg3, arg4)
@ccall libsuperlu_dist_Int32.checkRecvLDiag(k::int_t, comReqs::Ptr{commRequests_t}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{SCT_t})::int_t
end
function dCreate_CompCol_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int32.dCreate_CompCol_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{Cdouble}, arg6::Ptr{int_t}, arg7::Ptr{int_t}, arg8::Stype_t, arg9::Dtype_t, arg10::Mtype_t)::Cvoid
end
function dCreate_CompRowLoc_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int32.dCreate_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::int_t, arg6::int_t, arg7::Ptr{Cdouble}, arg8::Ptr{int_t}, arg9::Ptr{int_t}, arg10::Stype_t, arg11::Dtype_t, arg12::Mtype_t)::Cvoid
end
function dCompRow_to_CompCol_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.dCompRow_to_CompCol_dist(arg1::int_t, arg2::int_t, arg3::int_t, arg4::Ptr{Cdouble}, arg5::Ptr{int_t}, arg6::Ptr{int_t}, arg7::Ptr{Ptr{Cdouble}}, arg8::Ptr{Ptr{int_t}}, arg9::Ptr{Ptr{int_t}})::Cvoid
end
function pdCompRow_loc_to_CompCol_global(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.pdCompRow_loc_to_CompCol_global(arg1::int_t, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{SuperMatrix{Int32}})::Cint
end
function dCopy_CompCol_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int32.dCopy_CompCol_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{SuperMatrix{Int32}})::Cvoid
end
function dCreate_Dense_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.dCreate_Dense_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::int_t, arg3::int_t, arg4::Ptr{Cdouble}, arg5::int_t, arg6::Stype_t, arg7::Dtype_t, arg8::Mtype_t)::Cvoid
end
function dCreate_SuperNode_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13)
@ccall libsuperlu_dist_Int32.dCreate_SuperNode_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{Cdouble}, arg6::Ptr{int_t}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{int_t}, arg10::Ptr{int_t}, arg11::Stype_t, arg12::Dtype_t, arg13::Mtype_t)::Cvoid
end
function dCopy_Dense_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.dCopy_Dense_Matrix_dist(arg1::int_t, arg2::int_t, arg3::Ptr{Cdouble}, arg4::int_t, arg5::Ptr{Cdouble}, arg6::int_t)::Cvoid
end
function dallocateA_dist(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int32.dallocateA_dist(arg1::int_t, arg2::int_t, arg3::Ptr{Ptr{Cdouble}}, arg4::Ptr{Ptr{int_t}}, arg5::Ptr{Ptr{int_t}})::Cvoid
end
function dGenXtrue_dist(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.dGenXtrue_dist(arg1::int_t, arg2::int_t, arg3::Ptr{Cdouble}, arg4::int_t)::Cvoid
end
function dFillRHS_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.dFillRHS_dist(arg1::Ptr{Cchar}, arg2::int_t, arg3::Ptr{Cdouble}, arg4::int_t, arg5::Ptr{SuperMatrix{Int32}}, arg6::Ptr{Cdouble}, arg7::int_t)::Cvoid
end
function dcreate_matrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.dcreate_matrix(arg1::Ptr{SuperMatrix{Int32}}, arg2::Cint, arg3::Ptr{Ptr{Cdouble}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{Cdouble}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{gridinfo_t{Int32}})::Cint
end
function dcreate_matrix_rb(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.dcreate_matrix_rb(arg1::Ptr{SuperMatrix{Int32}}, arg2::Cint, arg3::Ptr{Ptr{Cdouble}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{Cdouble}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{gridinfo_t{Int32}})::Cint
end
function dcreate_matrix_dat(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.dcreate_matrix_dat(arg1::Ptr{SuperMatrix{Int32}}, arg2::Cint, arg3::Ptr{Ptr{Cdouble}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{Cdouble}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{gridinfo_t{Int32}})::Cint
end
function dcreate_matrix_postfix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.dcreate_matrix_postfix(arg1::Ptr{SuperMatrix{Int32}}, arg2::Cint, arg3::Ptr{Ptr{Cdouble}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{Cdouble}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{Cchar}, arg9::Ptr{gridinfo_t{Int32}})::Cint
end
function dScalePermstructInit(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.dScalePermstructInit(arg1::int_t, arg2::int_t, arg3::Ptr{dScalePermstruct_t{Int32}})::Cvoid
end
function dScalePermstructFree(arg1)
@ccall libsuperlu_dist_Int32.dScalePermstructFree(arg1::Ptr{dScalePermstruct_t{Int32}})::Cvoid
end
function dgsequ_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.dgsequ_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble}, arg7::Ptr{int_t})::Cvoid
end
function dlangs_dist(arg1, arg2)
@ccall libsuperlu_dist_Int32.dlangs_dist(arg1::Ptr{Cchar}, arg2::Ptr{SuperMatrix{Int32}})::Cdouble
end
function dlaqgs_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.dlaqgs_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Cdouble, arg5::Cdouble, arg6::Cdouble, arg7::Ptr{Cchar})::Cvoid
end
function pdgsequ(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.pdgsequ(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble}, arg7::Ptr{int_t}, arg8::Ptr{gridinfo_t{Int32}})::Cvoid
end
function pdlangs(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.pdlangs(arg1::Ptr{Cchar}, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{gridinfo_t{Int32}})::Cdouble
end
function pdlaqgs(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.pdlaqgs(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Cdouble, arg5::Cdouble, arg6::Cdouble, arg7::Ptr{Cchar})::Cvoid
end
function pdPermute_Dense_Matrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int32.pdPermute_Dense_Matrix(arg1::int_t, arg2::int_t, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Cdouble}, arg6::Cint, arg7::Ptr{Cdouble}, arg8::Cint, arg9::Cint, arg10::Ptr{gridinfo_t{Int32}})::Cint
end
function sp_dtrsv_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.sp_dtrsv_dist(arg1::Ptr{Cchar}, arg2::Ptr{Cchar}, arg3::Ptr{Cchar}, arg4::Ptr{SuperMatrix{Int32}}, arg5::Ptr{SuperMatrix{Int32}}, arg6::Ptr{Cdouble}, arg7::Ptr{Cint})::Cint
end
function sp_dgemv_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.sp_dgemv_dist(arg1::Ptr{Cchar}, arg2::Cdouble, arg3::Ptr{SuperMatrix{Int32}}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cdouble, arg7::Ptr{Cdouble}, arg8::Cint)::Cint
end
function sp_dgemm_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.sp_dgemm_dist(arg1::Ptr{Cchar}, arg2::Cint, arg3::Cdouble, arg4::Ptr{SuperMatrix{Int32}}, arg5::Ptr{Cdouble}, arg6::Cint, arg7::Cdouble, arg8::Ptr{Cdouble}, arg9::Cint)::Cint
end
function ddistribute(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.ddistribute(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int32}}, arg4::Ptr{Glu_freeable_t{Int32}}, arg5::Ptr{dLUstruct_t{Int32}}, arg6::Ptr{gridinfo_t{Int32}})::Cfloat
end
function pdgssvx_ABglobal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
@ccall libsuperlu_dist_Int32.pdgssvx_ABglobal(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{dScalePermstruct_t{Int32}}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::Ptr{gridinfo_t{Int32}}, arg8::Ptr{dLUstruct_t{Int32}}, arg9::Ptr{Cdouble}, arg10::Ptr{SuperLUStat_t{Int32}}, arg11::Ptr{Cint})::Cvoid
end
function pddistribute(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.pddistribute(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int32}}, arg4::Ptr{dScalePermstruct_t{Int32}}, arg5::Ptr{Glu_freeable_t{Int32}}, arg6::Ptr{dLUstruct_t{Int32}}, arg7::Ptr{gridinfo_t{Int32}})::Cfloat
end
function pdgssvx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int32.pdgssvx(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{dScalePermstruct_t{Int32}}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::Ptr{gridinfo_t{Int32}}, arg8::Ptr{dLUstruct_t{Int32}}, arg9::Ptr{dSOLVEstruct_t{Int32}}, arg10::Ptr{Cdouble}, arg11::Ptr{SuperLUStat_t{Int32}}, arg12::Ptr{Cint})::Cvoid
end
function pdCompute_Diag_Inv(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int32.pdCompute_Diag_Inv(arg1::int_t, arg2::Ptr{dLUstruct_t{Int32}}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{SuperLUStat_t{Int32}}, arg5::Ptr{Cint})::Cvoid
end
function dSolveInit(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.dSolveInit(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::int_t, arg6::Ptr{dLUstruct_t{Int32}}, arg7::Ptr{gridinfo_t{Int32}}, arg8::Ptr{dSOLVEstruct_t{Int32}})::Cint
end
function dSolveFinalize(arg1, arg2)
@ccall libsuperlu_dist_Int32.dSolveFinalize(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{dSOLVEstruct_t{Int32}})::Cvoid
end
function dDestroy_A3d_gathered_on_2d(arg1, arg2)
@ccall libsuperlu_dist_Int32.dDestroy_A3d_gathered_on_2d(arg1::Ptr{dSOLVEstruct_t{Int32}}, arg2::Ptr{gridinfo3d_t{Int32}})::Cvoid
end
function pdgstrs_init(arg1, arg2, arg3, arg4, arg5, arg6, grid, arg8, arg9)
@ccall libsuperlu_dist_Int32.pdgstrs_init(arg1::int_t, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{int_t}, arg6::Ptr{int_t}, grid::Ptr{gridinfo_t{Int32}}, arg8::Ptr{Glu_persist_t}, arg9::Ptr{dSOLVEstruct_t{Int32}})::int_t
end
function dldperm_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.dldperm_dist(arg1::Cint, arg2::Cint, arg3::int_t, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{Cdouble}, arg7::Ptr{int_t}, arg8::Ptr{Cdouble}, arg9::Ptr{Cdouble})::Cint
end
function dstatic_schedule(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.dstatic_schedule(arg1::Ptr{superlu_dist_options_t}, arg2::Cint, arg3::Cint, arg4::Ptr{dLUstruct_t{Int32}}, arg5::Ptr{gridinfo_t{Int32}}, arg6::Ptr{SuperLUStat_t{Int32}}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{Cint})::Cint
end
function dLUstructInit(arg1, arg2)
@ccall libsuperlu_dist_Int32.dLUstructInit(arg1::int_t, arg2::Ptr{dLUstruct_t{Int32}})::Cvoid
end
function dLUstructFree(arg1)
@ccall libsuperlu_dist_Int32.dLUstructFree(arg1::Ptr{dLUstruct_t{Int32}})::Cvoid
end
function dDestroy_LU(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.dDestroy_LU(arg1::int_t, arg2::Ptr{gridinfo_t{Int32}}, arg3::Ptr{dLUstruct_t{Int32}})::Cvoid
end
function dDestroy_Tree(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.dDestroy_Tree(arg1::int_t, arg2::Ptr{gridinfo_t{Int32}}, arg3::Ptr{dLUstruct_t{Int32}})::Cvoid
end
function dscatter_l(ib, ljb, nsupc, iukp, xsup, klst, nbrow, lptr, temp_nbrow, usub, lsub, tempv, indirect_thread, indirect2, Lrowind_bc_ptr, Lnzval_bc_ptr, grid)
@ccall libsuperlu_dist_Int32.dscatter_l(ib::Cint, ljb::Cint, nsupc::Cint, iukp::int_t, xsup::Ptr{int_t}, klst::Cint, nbrow::Cint, lptr::int_t, temp_nbrow::Cint, usub::Ptr{int_t}, lsub::Ptr{int_t}, tempv::Ptr{Cdouble}, indirect_thread::Ptr{Cint}, indirect2::Ptr{Cint}, Lrowind_bc_ptr::Ptr{Ptr{int_t}}, Lnzval_bc_ptr::Ptr{Ptr{Cdouble}}, grid::Ptr{gridinfo_t{Int32}})::Cvoid
end
function dscatter_u(ib, jb, nsupc, iukp, xsup, klst, nbrow, lptr, temp_nbrow, lsub, usub, tempv, Ufstnz_br_ptr, Unzval_br_ptr, grid)
@ccall libsuperlu_dist_Int32.dscatter_u(ib::Cint, jb::Cint, nsupc::Cint, iukp::int_t, xsup::Ptr{int_t}, klst::Cint, nbrow::Cint, lptr::int_t, temp_nbrow::Cint, lsub::Ptr{int_t}, usub::Ptr{int_t}, tempv::Ptr{Cdouble}, Ufstnz_br_ptr::Ptr{Ptr{int_t}}, Unzval_br_ptr::Ptr{Ptr{Cdouble}}, grid::Ptr{gridinfo_t{Int32}})::Cvoid
end
function pdgstrf(arg1, arg2, arg3, anorm, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.pdgstrf(arg1::Ptr{superlu_dist_options_t}, arg2::Cint, arg3::Cint, anorm::Cdouble, arg5::Ptr{dLUstruct_t{Int32}}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{SuperLUStat_t{Int32}}, arg8::Ptr{Cint})::int_t
end
function pdgstrs_Bglobal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.pdgstrs_Bglobal(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{dLUstruct_t{Int32}}, arg4::Ptr{gridinfo_t{Int32}}, arg5::Ptr{Cdouble}, arg6::int_t, arg7::Cint, arg8::Ptr{SuperLUStat_t{Int32}}, arg9::Ptr{Cint})::Cvoid
end
function pdgstrs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13)
@ccall libsuperlu_dist_Int32.pdgstrs(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{dLUstruct_t{Int32}}, arg4::Ptr{dScalePermstruct_t{Int32}}, arg5::Ptr{gridinfo_t{Int32}}, arg6::Ptr{Cdouble}, arg7::int_t, arg8::int_t, arg9::int_t, arg10::Cint, arg11::Ptr{dSOLVEstruct_t{Int32}}, arg12::Ptr{SuperLUStat_t{Int32}}, arg13::Ptr{Cint})::Cvoid
end
function pdgstrf2_trsm(options, k0, k, thresh, arg5, arg6, arg7, arg8, tag_ub, arg10, info)
@ccall libsuperlu_dist_Int32.pdgstrf2_trsm(options::Ptr{superlu_dist_options_t}, k0::int_t, k::int_t, thresh::Cdouble, arg5::Ptr{Glu_persist_t}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{dLocalLU_t{Int32}}, arg8::Ptr{MPI_Request}, tag_ub::Cint, arg10::Ptr{SuperLUStat_t{Int32}}, info::Ptr{Cint})::Cvoid
end
function pdgstrs2_omp(k0, k, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.pdgstrs2_omp(k0::int_t, k::int_t, arg3::Ptr{Glu_persist_t}, arg4::Ptr{gridinfo_t{Int32}}, arg5::Ptr{dLocalLU_t{Int32}}, arg6::Ptr{Ublock_info_t}, arg7::Ptr{SuperLUStat_t{Int32}})::Cvoid
end
function pdReDistribute_B_to_X(B, m_loc, nrhs, ldb, fst_row, ilsum, x, arg8, arg9, arg10, arg11)
@ccall libsuperlu_dist_Int32.pdReDistribute_B_to_X(B::Ptr{Cdouble}, m_loc::int_t, nrhs::Cint, ldb::int_t, fst_row::int_t, ilsum::Ptr{int_t}, x::Ptr{Cdouble}, arg8::Ptr{dScalePermstruct_t{Int32}}, arg9::Ptr{Glu_persist_t}, arg10::Ptr{gridinfo_t{Int32}}, arg11::Ptr{dSOLVEstruct_t{Int32}})::int_t
end
function dlsum_fmod(arg1, arg2, arg3, arg4, arg5, arg6, arg7, fmod, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16)
@ccall libsuperlu_dist_Int32.dlsum_fmod(arg1::Ptr{Cdouble}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::int_t, fmod::Ptr{Cint}, arg9::int_t, arg10::int_t, arg11::int_t, arg12::Ptr{int_t}, arg13::Ptr{gridinfo_t{Int32}}, arg14::Ptr{dLocalLU_t{Int32}}, arg15::Ptr{MPI_Request}, arg16::Ptr{SuperLUStat_t{Int32}})::Cvoid
end
function dlsum_bmod(arg1, arg2, arg3, arg4, arg5, bmod, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14)
@ccall libsuperlu_dist_Int32.dlsum_bmod(arg1::Ptr{Cdouble}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Cint, arg5::int_t, bmod::Ptr{Cint}, arg7::Ptr{int_t}, arg8::Ptr{Ptr{Ucb_indptr_t}}, arg9::Ptr{Ptr{int_t}}, arg10::Ptr{int_t}, arg11::Ptr{gridinfo_t{Int32}}, arg12::Ptr{dLocalLU_t{Int32}}, arg13::Ptr{MPI_Request}, arg14::Ptr{SuperLUStat_t{Int32}})::Cvoid
end
function dlsum_fmod_inv(arg1, arg2, arg3, arg4, arg5, arg6, fmod, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19)
@ccall libsuperlu_dist_Int32.dlsum_fmod_inv(arg1::Ptr{Cdouble}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::int_t, fmod::Ptr{Cint}, arg8::Ptr{int_t}, arg9::Ptr{gridinfo_t{Int32}}, arg10::Ptr{dLocalLU_t{Int32}}, arg11::Ptr{Ptr{SuperLUStat_t{Int32}}}, arg12::Ptr{int_t}, arg13::Ptr{int_t}, arg14::int_t, arg15::int_t, arg16::int_t, arg17::int_t, arg18::Cint, arg19::Cint)::Cvoid
end
function dlsum_fmod_inv_master(arg1, arg2, arg3, arg4, arg5, arg6, arg7, fmod, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19)
@ccall libsuperlu_dist_Int32.dlsum_fmod_inv_master(arg1::Ptr{Cdouble}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::int_t, fmod::Ptr{Cint}, arg9::int_t, arg10::Ptr{int_t}, arg11::Ptr{gridinfo_t{Int32}}, arg12::Ptr{dLocalLU_t{Int32}}, arg13::Ptr{Ptr{SuperLUStat_t{Int32}}}, arg14::int_t, arg15::int_t, arg16::int_t, arg17::int_t, arg18::Cint, arg19::Cint)::Cvoid
end
function dlsum_bmod_inv(arg1, arg2, arg3, arg4, arg5, arg6, bmod, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20)
@ccall libsuperlu_dist_Int32.dlsum_bmod_inv(arg1::Ptr{Cdouble}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::int_t, bmod::Ptr{Cint}, arg8::Ptr{int_t}, arg9::Ptr{Ptr{Ucb_indptr_t}}, arg10::Ptr{Ptr{int_t}}, arg11::Ptr{int_t}, arg12::Ptr{gridinfo_t{Int32}}, arg13::Ptr{dLocalLU_t{Int32}}, arg14::Ptr{Ptr{SuperLUStat_t{Int32}}}, arg15::Ptr{int_t}, arg16::Ptr{int_t}, arg17::int_t, arg18::int_t, arg19::Cint, arg20::Cint)::Cvoid
end
function dlsum_bmod_inv_master(arg1, arg2, arg3, arg4, arg5, arg6, bmod, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18)
@ccall libsuperlu_dist_Int32.dlsum_bmod_inv_master(arg1::Ptr{Cdouble}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::int_t, bmod::Ptr{Cint}, arg8::Ptr{int_t}, arg9::Ptr{Ptr{Ucb_indptr_t}}, arg10::Ptr{Ptr{int_t}}, arg11::Ptr{int_t}, arg12::Ptr{gridinfo_t{Int32}}, arg13::Ptr{dLocalLU_t{Int32}}, arg14::Ptr{Ptr{SuperLUStat_t{Int32}}}, arg15::int_t, arg16::int_t, arg17::Cint, arg18::Cint)::Cvoid
end
function dComputeLevelsets(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.dComputeLevelsets(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{dLocalLU_t{Int32}}, arg6::Ptr{int_t})::Cvoid
end
function pdgsrfs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16)
@ccall libsuperlu_dist_Int32.pdgsrfs(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int32}}, arg4::Cdouble, arg5::Ptr{dLUstruct_t{Int32}}, arg6::Ptr{dScalePermstruct_t{Int32}}, arg7::Ptr{gridinfo_t{Int32}}, arg8::Ptr{Cdouble}, arg9::int_t, arg10::Ptr{Cdouble}, arg11::int_t, arg12::Cint, arg13::Ptr{dSOLVEstruct_t{Int32}}, arg14::Ptr{Cdouble}, arg15::Ptr{SuperLUStat_t{Int32}}, arg16::Ptr{Cint})::Cvoid
end
function pdgsrfs_ABXglobal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14)
@ccall libsuperlu_dist_Int32.pdgsrfs_ABXglobal(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int32}}, arg4::Cdouble, arg5::Ptr{dLUstruct_t{Int32}}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{Cdouble}, arg8::int_t, arg9::Ptr{Cdouble}, arg10::int_t, arg11::Cint, arg12::Ptr{Cdouble}, arg13::Ptr{SuperLUStat_t{Int32}}, arg14::Ptr{Cint})::Cvoid
end
function pdgsmv_AXglobal_setup(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.pdgsmv_AXglobal_setup(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{Glu_persist_t}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{int_t}}, arg6::Ptr{Ptr{Cdouble}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{int_t})::Cint
end
function pdgsmv_AXglobal(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.pdgsmv_AXglobal(arg1::int_t, arg2::Ptr{int_t}, arg3::Ptr{Cdouble}, arg4::Ptr{int_t}, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble})::Cint
end
function pdgsmv_AXglobal_abs(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.pdgsmv_AXglobal_abs(arg1::int_t, arg2::Ptr{int_t}, arg3::Ptr{Cdouble}, arg4::Ptr{int_t}, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble})::Cint
end
function pdgsmv_init(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.pdgsmv_init(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{int_t}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{pdgsmv_comm_t})::Cvoid
end
function pdgsmv(arg1, arg2, arg3, arg4, x, ax)
@ccall libsuperlu_dist_Int32.pdgsmv(arg1::int_t, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{pdgsmv_comm_t}, x::Ptr{Cdouble}, ax::Ptr{Cdouble})::Cvoid
end
function pdgsmv_finalize(arg1)
@ccall libsuperlu_dist_Int32.pdgsmv_finalize(arg1::Ptr{pdgsmv_comm_t})::Cvoid
end
function doubleMalloc_dist(arg1)
@ccall libsuperlu_dist_Int32.doubleMalloc_dist(arg1::int_t)::Ptr{Cdouble}
end
function doubleCalloc_dist(arg1)
@ccall libsuperlu_dist_Int32.doubleCalloc_dist(arg1::int_t)::Ptr{Cdouble}
end
function dQuerySpace_dist(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int32.dQuerySpace_dist(arg1::int_t, arg2::Ptr{dLUstruct_t{Int32}}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{SuperLUStat_t{Int32}}, arg5::Ptr{superlu_dist_mem_usage_t})::int_t
end
function dClone_CompRowLoc_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int32.dClone_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{SuperMatrix{Int32}})::Cvoid
end
function dCopy_CompRowLoc_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int32.dCopy_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{SuperMatrix{Int32}})::Cvoid
end
function dZero_CompRowLoc_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int32.dZero_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}})::Cvoid
end
function dScaleAddId_CompRowLoc_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int32.dScaleAddId_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::Cdouble)::Cvoid
end
function dScaleAdd_CompRowLoc_Matrix_dist(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.dScaleAdd_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{SuperMatrix{Int32}}, arg3::Cdouble)::Cvoid
end
function dZeroLblocks(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.dZeroLblocks(arg1::Cint, arg2::Cint, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{dLUstruct_t{Int32}})::Cvoid
end
function dZeroUblocks(iam, n, arg3, arg4)
@ccall libsuperlu_dist_Int32.dZeroUblocks(iam::Cint, n::Cint, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{dLUstruct_t{Int32}})::Cvoid
end
function dfill_dist(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.dfill_dist(arg1::Ptr{Cdouble}, arg2::int_t, arg3::Cdouble)::Cvoid
end
function dinf_norm_error_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.dinf_norm_error_dist(arg1::int_t, arg2::int_t, arg3::Ptr{Cdouble}, arg4::int_t, arg5::Ptr{Cdouble}, arg6::int_t, arg7::Ptr{gridinfo_t{Int32}})::Cvoid
end
function pdinf_norm_error(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.pdinf_norm_error(arg1::Cint, arg2::int_t, arg3::int_t, arg4::Ptr{Cdouble}, arg5::int_t, arg6::Ptr{Cdouble}, arg7::int_t, arg8::MPI_Comm)::Cvoid
end
function dreadhb_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.dreadhb_dist(arg1::Cint, arg2::Ptr{Libc.FILE}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{Ptr{Cdouble}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}})::Cvoid
end
function dreadtriple_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.dreadtriple_dist(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{Cdouble}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cvoid
end
function dreadtriple_noheader(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.dreadtriple_noheader(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{Cdouble}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cvoid
end
function dreadrb_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.dreadrb_dist(arg1::Cint, arg2::Ptr{Libc.FILE}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{Ptr{Cdouble}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}})::Cvoid
end
function dreadMM_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.dreadMM_dist(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{Cdouble}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cvoid
end
function dread_binary(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.dread_binary(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{Cdouble}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cint
end
function ddist_psymbtonum(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.ddist_psymbtonum(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int32}}, arg4::Ptr{dScalePermstruct_t{Int32}}, arg5::Ptr{Pslu_freeable_t}, arg6::Ptr{dLUstruct_t{Int32}}, arg7::Ptr{gridinfo_t{Int32}})::Cfloat
end
function pdGetDiagU(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.pdGetDiagU(arg1::int_t, arg2::Ptr{dLUstruct_t{Int32}}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{Cdouble})::Cvoid
end
function d_c2cpp_GetHWPM(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.d_c2cpp_GetHWPM(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{gridinfo_t{Int32}}, arg3::Ptr{dScalePermstruct_t{Int32}})::Cint
end
function dPrintLblocks(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int32.dPrintLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{dLocalLU_t{Int32}})::Cvoid
end
function dPrintUblocks(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int32.dPrintUblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{dLocalLU_t{Int32}})::Cvoid
end
function dPrint_CompCol_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int32.dPrint_CompCol_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}})::Cvoid
end
function dPrint_Dense_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int32.dPrint_Dense_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}})::Cvoid
end
function dPrint_CompRowLoc_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int32.dPrint_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}})::Cint
end
function file_dPrint_CompRowLoc_Matrix_dist(fp, A)
@ccall libsuperlu_dist_Int32.file_dPrint_CompRowLoc_Matrix_dist(fp::Ptr{Libc.FILE}, A::Ptr{SuperMatrix{Int32}})::Cint
end
function Printdouble5(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.Printdouble5(arg1::Ptr{Cchar}, arg2::int_t, arg3::Ptr{Cdouble})::Cvoid
end
function file_Printdouble5(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.file_Printdouble5(arg1::Ptr{Libc.FILE}, arg2::Ptr{Cchar}, arg3::int_t, arg4::Ptr{Cdouble})::Cint
end
function dGenCOOLblocks(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int32.dGenCOOLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{dLocalLU_t{Int32}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{Cdouble}}, arg9::Ptr{int_t}, arg10::Ptr{int_t})::Cvoid
end
function dGenCSCLblocks(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int32.dGenCSCLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{dLocalLU_t{Int32}}, arg6::Ptr{Ptr{Cdouble}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}}, arg9::Ptr{int_t}, arg10::Ptr{int_t})::Cvoid
end
function dGenCSRLblocks(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int32.dGenCSRLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{dLocalLU_t{Int32}}, arg6::Ptr{Ptr{Cdouble}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}}, arg9::Ptr{int_t}, arg10::Ptr{int_t})::Cvoid
end
function superlu_dgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
@ccall libsuperlu_dist_Int32.superlu_dgemm(transa::Ptr{Cchar}, transb::Ptr{Cchar}, m::Cint, n::Cint, k::Cint, alpha::Cdouble, a::Ptr{Cdouble}, lda::Cint, b::Ptr{Cdouble}, ldb::Cint, beta::Cdouble, c::Ptr{Cdouble}, ldc::Cint)::Cint
end
function superlu_dtrsm(sideRL, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
@ccall libsuperlu_dist_Int32.superlu_dtrsm(sideRL::Ptr{Cchar}, uplo::Ptr{Cchar}, transa::Ptr{Cchar}, diag::Ptr{Cchar}, m::Cint, n::Cint, alpha::Cdouble, a::Ptr{Cdouble}, lda::Cint, b::Ptr{Cdouble}, ldb::Cint)::Cint
end
function superlu_dger(m, n, alpha, x, incx, y, incy, a, lda)
@ccall libsuperlu_dist_Int32.superlu_dger(m::Cint, n::Cint, alpha::Cdouble, x::Ptr{Cdouble}, incx::Cint, y::Ptr{Cdouble}, incy::Cint, a::Ptr{Cdouble}, lda::Cint)::Cint
end
function superlu_dscal(n, alpha, x, incx)
@ccall libsuperlu_dist_Int32.superlu_dscal(n::Cint, alpha::Cdouble, x::Ptr{Cdouble}, incx::Cint)::Cint
end
function superlu_daxpy(n, alpha, x, incx, y, incy)
@ccall libsuperlu_dist_Int32.superlu_daxpy(n::Cint, alpha::Cdouble, x::Ptr{Cdouble}, incx::Cint, y::Ptr{Cdouble}, incy::Cint)::Cint
end
function superlu_dgemv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy)
@ccall libsuperlu_dist_Int32.superlu_dgemv(trans::Ptr{Cchar}, m::Cint, n::Cint, alpha::Cdouble, a::Ptr{Cdouble}, lda::Cint, x::Ptr{Cdouble}, incx::Cint, beta::Cdouble, y::Ptr{Cdouble}, incy::Cint)::Cint
end
function superlu_dtrsv(uplo, trans, diag, n, a, lda, x, incx)
@ccall libsuperlu_dist_Int32.superlu_dtrsv(uplo::Ptr{Cchar}, trans::Ptr{Cchar}, diag::Ptr{Cchar}, n::Cint, a::Ptr{Cdouble}, lda::Cint, x::Ptr{Cdouble}, incx::Cint)::Cint
end
function dcreate_matrix3d(A, nrhs, rhs, ldb, x, ldx, fp, grid3d)
@ccall libsuperlu_dist_Int32.dcreate_matrix3d(A::Ptr{SuperMatrix{Int32}}, nrhs::Cint, rhs::Ptr{Ptr{Cdouble}}, ldb::Ptr{Cint}, x::Ptr{Ptr{Cdouble}}, ldx::Ptr{Cint}, fp::Ptr{Libc.FILE}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cint
end
function dcreate_matrix_postfix3d(A, nrhs, rhs, ldb, x, ldx, fp, postfix, grid3d)
@ccall libsuperlu_dist_Int32.dcreate_matrix_postfix3d(A::Ptr{SuperMatrix{Int32}}, nrhs::Cint, rhs::Ptr{Ptr{Cdouble}}, ldb::Ptr{Cint}, x::Ptr{Ptr{Cdouble}}, ldx::Ptr{Cint}, fp::Ptr{Libc.FILE}, postfix::Ptr{Cchar}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cint
end
function dGatherNRformat_loc3d(Fact, A, B, ldb, nrhs, grid3d, arg7)
@ccall libsuperlu_dist_Int32.dGatherNRformat_loc3d(Fact::fact_t, A::Ptr{NRformat_loc{Int32}}, B::Ptr{Cdouble}, ldb::Cint, nrhs::Cint, grid3d::Ptr{gridinfo3d_t{Int32}}, arg7::Ptr{Ptr{NRformat_loc3d{Int32}}})::Cvoid
end
function dScatter_B3d(A3d, grid3d)
@ccall libsuperlu_dist_Int32.dScatter_B3d(A3d::Ptr{NRformat_loc3d{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cint
end
function pdgssvx3d(arg1, arg2, arg3, B, ldb, nrhs, arg7, arg8, arg9, berr, arg11, info)
@ccall libsuperlu_dist_Int32.pdgssvx3d(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{dScalePermstruct_t{Int32}}, B::Ptr{Cdouble}, ldb::Cint, nrhs::Cint, arg7::Ptr{gridinfo3d_t{Int32}}, arg8::Ptr{dLUstruct_t{Int32}}, arg9::Ptr{dSOLVEstruct_t{Int32}}, berr::Ptr{Cdouble}, arg11::Ptr{SuperLUStat_t{Int32}}, info::Ptr{Cint})::Cvoid
end
function pdgstrf3d(arg1, m, n, anorm, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int32.pdgstrf3d(arg1::Ptr{superlu_dist_options_t}, m::Cint, n::Cint, anorm::Cdouble, arg5::Ptr{dtrf3Dpartition_t{Int32}}, arg6::Ptr{SCT_t}, arg7::Ptr{dLUstruct_t{Int32}}, arg8::Ptr{gridinfo3d_t{Int32}}, arg9::Ptr{SuperLUStat_t{Int32}}, arg10::Ptr{Cint})::int_t
end
function dInit_HyP(HyP, Llu, mcb, mrb)
@ccall libsuperlu_dist_Int32.dInit_HyP(HyP::Ptr{HyP_t}, Llu::Ptr{dLocalLU_t{Int32}}, mcb::int_t, mrb::int_t)::Cvoid
end
function dblock_gemm_scatter(lb, j, Ublock_info, Remain_info, L_mat, ldl, U_mat, ldu, bigV, knsupc, klst, lsub, usub, ldt, thread_id, indirect, indirect2, Lrowind_bc_ptr, Lnzval_bc_ptr, Ufstnz_br_ptr, Unzval_br_ptr, xsup, arg23, arg24)
@ccall libsuperlu_dist_Int32.dblock_gemm_scatter(lb::int_t, j::int_t, Ublock_info::Ptr{Ublock_info_t}, Remain_info::Ptr{Remain_info_t}, L_mat::Ptr{Cdouble}, ldl::Cint, U_mat::Ptr{Cdouble}, ldu::Cint, bigV::Ptr{Cdouble}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, thread_id::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, Lrowind_bc_ptr::Ptr{Ptr{int_t}}, Lnzval_bc_ptr::Ptr{Ptr{Cdouble}}, Ufstnz_br_ptr::Ptr{Ptr{int_t}}, Unzval_br_ptr::Ptr{Ptr{Cdouble}}, xsup::Ptr{int_t}, arg23::Ptr{gridinfo_t{Int32}}, arg24::Ptr{SuperLUStat_t{Int32}})::Cvoid
end
function dblock_gemm_scatterTopLeft(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int32.dblock_gemm_scatterTopLeft(lb::int_t, j::int_t, bigV::Ptr{Cdouble}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{dLUstruct_t{Int32}}, arg13::Ptr{gridinfo_t{Int32}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int32}})::int_t
end
function dblock_gemm_scatterTopRight(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int32.dblock_gemm_scatterTopRight(lb::int_t, j::int_t, bigV::Ptr{Cdouble}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{dLUstruct_t{Int32}}, arg13::Ptr{gridinfo_t{Int32}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int32}})::int_t
end
function dblock_gemm_scatterBottomLeft(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int32.dblock_gemm_scatterBottomLeft(lb::int_t, j::int_t, bigV::Ptr{Cdouble}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{dLUstruct_t{Int32}}, arg13::Ptr{gridinfo_t{Int32}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int32}})::int_t
end
function dblock_gemm_scatterBottomRight(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int32.dblock_gemm_scatterBottomRight(lb::int_t, j::int_t, bigV::Ptr{Cdouble}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{dLUstruct_t{Int32}}, arg13::Ptr{gridinfo_t{Int32}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int32}})::int_t
end
function dgather_u(num_u_blks, Ublock_info, usub, uval, bigU, ldu, xsup, klst)
@ccall libsuperlu_dist_Int32.dgather_u(num_u_blks::int_t, Ublock_info::Ptr{Ublock_info_t}, usub::Ptr{int_t}, uval::Ptr{Cdouble}, bigU::Ptr{Cdouble}, ldu::int_t, xsup::Ptr{int_t}, klst::int_t)::Cvoid
end
function dgather_l(num_LBlk, knsupc, L_info, lval, LD_lval, L_buff)
@ccall libsuperlu_dist_Int32.dgather_l(num_LBlk::int_t, knsupc::int_t, L_info::Ptr{Remain_info_t}, lval::Ptr{Cdouble}, LD_lval::int_t, L_buff::Ptr{Cdouble})::Cvoid
end
function dRgather_L(k, lsub, lusup, arg4, arg5, arg6, arg7, myIperm, iperm_c_supno)
@ccall libsuperlu_dist_Int32.dRgather_L(k::int_t, lsub::Ptr{int_t}, lusup::Ptr{Cdouble}, arg4::Ptr{gEtreeInfo_t{Int32}}, arg5::Ptr{Glu_persist_t}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{HyP_t}, myIperm::Ptr{int_t}, iperm_c_supno::Ptr{int_t})::Cvoid
end
function dRgather_U(k, jj0, usub, uval, bigU, arg6, arg7, arg8, arg9, myIperm, iperm_c_supno, perm_u)
@ccall libsuperlu_dist_Int32.dRgather_U(k::int_t, jj0::int_t, usub::Ptr{int_t}, uval::Ptr{Cdouble}, bigU::Ptr{Cdouble}, arg6::Ptr{gEtreeInfo_t{Int32}}, arg7::Ptr{Glu_persist_t}, arg8::Ptr{gridinfo_t{Int32}}, arg9::Ptr{HyP_t}, myIperm::Ptr{int_t}, iperm_c_supno::Ptr{int_t}, perm_u::Ptr{int_t})::Cvoid
end
function dinitTrf3Dpartition(nsupers, options, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.dinitTrf3Dpartition(nsupers::int_t, options::Ptr{superlu_dist_options_t}, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::Ptr{dtrf3Dpartition_t{Int32}}
end
function dDestroy_trf3Dpartition(trf3Dpartition, grid3d)
@ccall libsuperlu_dist_Int32.dDestroy_trf3Dpartition(trf3Dpartition::Ptr{dtrf3Dpartition_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cvoid
end
function d3D_printMemUse(trf3Dpartition, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.d3D_printMemUse(trf3Dpartition::Ptr{dtrf3Dpartition_t{Int32}}, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cvoid
end
function dinit3DLUstructForest(myTreeIdxs, myZeroTrIdxs, sForests, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.dinit3DLUstructForest(myTreeIdxs::Ptr{int_t}, myZeroTrIdxs::Ptr{int_t}, sForests::Ptr{Ptr{sForest_t{Int32}}}, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cvoid
end
function dgatherAllFactoredLUFr(myZeroTrIdxs, sForests, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.dgatherAllFactoredLUFr(myZeroTrIdxs::Ptr{int_t}, sForests::Ptr{sForest_t{Int32}}, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function dLpanelUpdate(off0, nsupc, ublk_ptr, ld_ujrow, lusup, nsupr, arg7)
@ccall libsuperlu_dist_Int32.dLpanelUpdate(off0::int_t, nsupc::int_t, ublk_ptr::Ptr{Cdouble}, ld_ujrow::int_t, lusup::Ptr{Cdouble}, nsupr::int_t, arg7::Ptr{SCT_t})::int_t
end
function Local_Dgstrf2(options, k, thresh, BlockUFactor, arg5, arg6, arg7, arg8, info, arg10)
@ccall libsuperlu_dist_Int32.Local_Dgstrf2(options::Ptr{superlu_dist_options_t}, k::int_t, thresh::Cdouble, BlockUFactor::Ptr{Cdouble}, arg5::Ptr{Glu_persist_t}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{dLocalLU_t{Int32}}, arg8::Ptr{SuperLUStat_t{Int32}}, info::Ptr{Cint}, arg10::Ptr{SCT_t})::Cvoid
end
function dTrs2_GatherU(iukp, rukp, klst, nsupc, ldu, usub, uval, tempv)
@ccall libsuperlu_dist_Int32.dTrs2_GatherU(iukp::int_t, rukp::int_t, klst::int_t, nsupc::int_t, ldu::int_t, usub::Ptr{int_t}, uval::Ptr{Cdouble}, tempv::Ptr{Cdouble})::int_t
end
function dTrs2_ScatterU(iukp, rukp, klst, nsupc, ldu, usub, uval, tempv)
@ccall libsuperlu_dist_Int32.dTrs2_ScatterU(iukp::int_t, rukp::int_t, klst::int_t, nsupc::int_t, ldu::int_t, usub::Ptr{int_t}, uval::Ptr{Cdouble}, tempv::Ptr{Cdouble})::int_t
end
function dTrs2_GatherTrsmScatter(klst, iukp, rukp, usub, uval, tempv, knsupc, nsupr, lusup, Glu_persist)
@ccall libsuperlu_dist_Int32.dTrs2_GatherTrsmScatter(klst::int_t, iukp::int_t, rukp::int_t, usub::Ptr{int_t}, uval::Ptr{Cdouble}, tempv::Ptr{Cdouble}, knsupc::int_t, nsupr::Cint, lusup::Ptr{Cdouble}, Glu_persist::Ptr{Glu_persist_t})::int_t
end
function pdgstrs2(m, k0, k, Glu_persist, grid, Llu, stat)
@ccall libsuperlu_dist_Int32.pdgstrs2(m::int_t, k0::int_t, k::int_t, Glu_persist::Ptr{Glu_persist_t}, grid::Ptr{gridinfo_t{Int32}}, Llu::Ptr{dLocalLU_t{Int32}}, stat::Ptr{SuperLUStat_t{Int32}})::Cvoid
end
function pdgstrf2(arg1, nsupers, k0, k, thresh, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int32.pdgstrf2(arg1::Ptr{superlu_dist_options_t}, nsupers::int_t, k0::int_t, k::int_t, thresh::Cdouble, arg6::Ptr{Glu_persist_t}, arg7::Ptr{gridinfo_t{Int32}}, arg8::Ptr{dLocalLU_t{Int32}}, arg9::Ptr{MPI_Request}, arg10::Cint, arg11::Ptr{SuperLUStat_t{Int32}}, arg12::Ptr{Cint})::Cvoid
end
function dAllocLlu_3d(nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.dAllocLlu_3d(nsupers::int_t, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function dp3dScatter(n, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.dp3dScatter(n::int_t, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function dscatter3dLPanels(nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.dscatter3dLPanels(nsupers::int_t, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function dscatter3dUPanels(nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.dscatter3dUPanels(nsupers::int_t, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function dcollect3dLpanels(layer, nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.dcollect3dLpanels(layer::int_t, nsupers::int_t, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function dcollect3dUpanels(layer, nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.dcollect3dUpanels(layer::int_t, nsupers::int_t, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function dp3dCollect(layer, n, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.dp3dCollect(layer::int_t, n::int_t, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function dzeroSetLU(nnodes, nodeList, arg3, arg4)
@ccall libsuperlu_dist_Int32.dzeroSetLU(nnodes::int_t, nodeList::Ptr{int_t}, arg3::Ptr{dLUstruct_t{Int32}}, arg4::Ptr{gridinfo3d_t{Int32}})::int_t
end
function dAllocGlu_3d(n, nsupers, arg3)
@ccall libsuperlu_dist_Int32.dAllocGlu_3d(n::int_t, nsupers::int_t, arg3::Ptr{dLUstruct_t{Int32}})::Cint
end
function dDeAllocLlu_3d(n, arg2, arg3)
@ccall libsuperlu_dist_Int32.dDeAllocLlu_3d(n::int_t, arg2::Ptr{dLUstruct_t{Int32}}, arg3::Ptr{gridinfo3d_t{Int32}})::Cint
end
function dDeAllocGlu_3d(arg1)
@ccall libsuperlu_dist_Int32.dDeAllocGlu_3d(arg1::Ptr{dLUstruct_t{Int32}})::Cint
end
function dreduceAncestors3d(sender, receiver, nnodes, nodeList, Lval_buf, Uval_buf, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.dreduceAncestors3d(sender::int_t, receiver::int_t, nnodes::int_t, nodeList::Ptr{int_t}, Lval_buf::Ptr{Cdouble}, Uval_buf::Ptr{Cdouble}, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function dreduceAllAncestors3d(ilvl, myNodeCount, treePerm, LUvsb, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.dreduceAllAncestors3d(ilvl::int_t, myNodeCount::Ptr{int_t}, treePerm::Ptr{Ptr{int_t}}, LUvsb::Ptr{dLUValSubBuf_t{Int32}}, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::Cint
end
function dgatherFactoredLU(sender, receiver, nnodes, nodeList, LUvsb, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.dgatherFactoredLU(sender::int_t, receiver::int_t, nnodes::int_t, nodeList::Ptr{int_t}, LUvsb::Ptr{dLUValSubBuf_t{Int32}}, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function dgatherAllFactoredLU(trf3Dpartition, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.dgatherAllFactoredLU(trf3Dpartition::Ptr{dtrf3Dpartition_t{Int32}}, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function dinit3DLUstruct(myTreeIdxs, myZeroTrIdxs, nodeCount, nodeList, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.dinit3DLUstruct(myTreeIdxs::Ptr{int_t}, myZeroTrIdxs::Ptr{int_t}, nodeCount::Ptr{int_t}, nodeList::Ptr{Ptr{int_t}}, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function dzSendLPanel(k, receiver, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.dzSendLPanel(k::int_t, receiver::int_t, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function dzRecvLPanel(k, sender, alpha, beta, Lval_buf, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.dzRecvLPanel(k::int_t, sender::int_t, alpha::Cdouble, beta::Cdouble, Lval_buf::Ptr{Cdouble}, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function dzSendUPanel(k, receiver, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.dzSendUPanel(k::int_t, receiver::int_t, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function dzRecvUPanel(k, sender, alpha, beta, Uval_buf, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.dzRecvUPanel(k::int_t, sender::int_t, alpha::Cdouble, beta::Cdouble, Uval_buf::Ptr{Cdouble}, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function dIBcast_LPanel(k, k0, lsub, lusup, arg5, msgcnt, arg7, ToSendR, xsup, arg10)
@ccall libsuperlu_dist_Int32.dIBcast_LPanel(k::int_t, k0::int_t, lsub::Ptr{int_t}, lusup::Ptr{Cdouble}, arg5::Ptr{gridinfo_t{Int32}}, msgcnt::Ptr{Cint}, arg7::Ptr{MPI_Request}, ToSendR::Ptr{Ptr{Cint}}, xsup::Ptr{int_t}, arg10::Cint)::int_t
end
function dBcast_LPanel(k, k0, lsub, lusup, arg5, msgcnt, ToSendR, xsup, arg9, arg10)
@ccall libsuperlu_dist_Int32.dBcast_LPanel(k::int_t, k0::int_t, lsub::Ptr{int_t}, lusup::Ptr{Cdouble}, arg5::Ptr{gridinfo_t{Int32}}, msgcnt::Ptr{Cint}, ToSendR::Ptr{Ptr{Cint}}, xsup::Ptr{int_t}, arg9::Ptr{SCT_t}, arg10::Cint)::int_t
end
function dIBcast_UPanel(k, k0, usub, uval, arg5, msgcnt, arg7, ToSendD, arg9)
@ccall libsuperlu_dist_Int32.dIBcast_UPanel(k::int_t, k0::int_t, usub::Ptr{int_t}, uval::Ptr{Cdouble}, arg5::Ptr{gridinfo_t{Int32}}, msgcnt::Ptr{Cint}, arg7::Ptr{MPI_Request}, ToSendD::Ptr{Cint}, arg9::Cint)::int_t
end
function dBcast_UPanel(k, k0, usub, uval, arg5, msgcnt, ToSendD, arg8, arg9)
@ccall libsuperlu_dist_Int32.dBcast_UPanel(k::int_t, k0::int_t, usub::Ptr{int_t}, uval::Ptr{Cdouble}, arg5::Ptr{gridinfo_t{Int32}}, msgcnt::Ptr{Cint}, ToSendD::Ptr{Cint}, arg8::Ptr{SCT_t}, arg9::Cint)::int_t
end
function dIrecv_LPanel(k, k0, Lsub_buf, Lval_buf, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.dIrecv_LPanel(k::int_t, k0::int_t, Lsub_buf::Ptr{int_t}, Lval_buf::Ptr{Cdouble}, arg5::Ptr{gridinfo_t{Int32}}, arg6::Ptr{MPI_Request}, arg7::Ptr{dLocalLU_t{Int32}}, arg8::Cint)::int_t
end
function dIrecv_UPanel(k, k0, Usub_buf, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.dIrecv_UPanel(k::int_t, k0::int_t, Usub_buf::Ptr{int_t}, arg4::Ptr{Cdouble}, arg5::Ptr{dLocalLU_t{Int32}}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{MPI_Request}, arg8::Cint)::int_t
end
function dWait_URecv(arg1, msgcnt, arg3)
@ccall libsuperlu_dist_Int32.dWait_URecv(arg1::Ptr{MPI_Request}, msgcnt::Ptr{Cint}, arg3::Ptr{SCT_t})::int_t
end
function dWait_LRecv(arg1, msgcnt, msgcntsU, arg4, arg5)
@ccall libsuperlu_dist_Int32.dWait_LRecv(arg1::Ptr{MPI_Request}, msgcnt::Ptr{Cint}, msgcntsU::Ptr{Cint}, arg4::Ptr{gridinfo_t{Int32}}, arg5::Ptr{SCT_t})::int_t
end
function dISend_UDiagBlock(k0, ublk_ptr, size, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.dISend_UDiagBlock(k0::int_t, ublk_ptr::Ptr{Cdouble}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int32}}, arg6::Cint)::int_t
end
function dRecv_UDiagBlock(k0, ublk_ptr, size, src, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.dRecv_UDiagBlock(k0::int_t, ublk_ptr::Ptr{Cdouble}, size::int_t, src::int_t, arg5::Ptr{gridinfo_t{Int32}}, arg6::Ptr{SCT_t}, arg7::Cint)::int_t
end
function dPackLBlock(k, Dest, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int32.dPackLBlock(k::int_t, Dest::Ptr{Cdouble}, arg3::Ptr{Glu_persist_t}, arg4::Ptr{gridinfo_t{Int32}}, arg5::Ptr{dLocalLU_t{Int32}})::int_t
end
function dISend_LDiagBlock(k0, lblk_ptr, size, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.dISend_LDiagBlock(k0::int_t, lblk_ptr::Ptr{Cdouble}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int32}}, arg6::Cint)::int_t
end
function dIRecv_UDiagBlock(k0, ublk_ptr, size, src, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.dIRecv_UDiagBlock(k0::int_t, ublk_ptr::Ptr{Cdouble}, size::int_t, src::int_t, arg5::Ptr{MPI_Request}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{SCT_t}, arg8::Cint)::int_t
end
function dIRecv_LDiagBlock(k0, L_blk_ptr, size, src, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.dIRecv_LDiagBlock(k0::int_t, L_blk_ptr::Ptr{Cdouble}, size::int_t, src::int_t, arg5::Ptr{MPI_Request}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{SCT_t}, arg8::Cint)::int_t
end
function dUDiagBlockRecvWait(k, IrecvPlcd_D, factored_L, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.dUDiagBlockRecvWait(k::int_t, IrecvPlcd_D::Ptr{int_t}, factored_L::Ptr{int_t}, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int32}}, arg6::Ptr{dLUstruct_t{Int32}}, arg7::Ptr{SCT_t})::int_t
end
function dIBcast_UDiagBlock(k, ublk_ptr, size, arg4, arg5)
@ccall libsuperlu_dist_Int32.dIBcast_UDiagBlock(k::int_t, ublk_ptr::Ptr{Cdouble}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int32}})::int_t
end
function dIBcast_LDiagBlock(k, lblk_ptr, size, arg4, arg5)
@ccall libsuperlu_dist_Int32.dIBcast_LDiagBlock(k::int_t, lblk_ptr::Ptr{Cdouble}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int32}})::int_t
end
function dDiagFactIBCast(k, k0, BlockUFactor, BlockLFactor, IrecvPlcd_D, arg6, arg7, arg8, arg9, arg10, arg11, thresh, LUstruct, arg14, info, arg16, tag_ub)
@ccall libsuperlu_dist_Int32.dDiagFactIBCast(k::int_t, k0::int_t, BlockUFactor::Ptr{Cdouble}, BlockLFactor::Ptr{Cdouble}, IrecvPlcd_D::Ptr{int_t}, arg6::Ptr{MPI_Request}, arg7::Ptr{MPI_Request}, arg8::Ptr{MPI_Request}, arg9::Ptr{MPI_Request}, arg10::Ptr{gridinfo_t{Int32}}, arg11::Ptr{superlu_dist_options_t}, thresh::Cdouble, LUstruct::Ptr{dLUstruct_t{Int32}}, arg14::Ptr{SuperLUStat_t{Int32}}, info::Ptr{Cint}, arg16::Ptr{SCT_t}, tag_ub::Cint)::int_t
end
function dUPanelTrSolve(k, BlockLFactor, bigV, ldt, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.dUPanelTrSolve(k::int_t, BlockLFactor::Ptr{Cdouble}, bigV::Ptr{Cdouble}, ldt::int_t, arg5::Ptr{Ublock_info_t}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{dLUstruct_t{Int32}}, arg8::Ptr{SuperLUStat_t{Int32}}, arg9::Ptr{SCT_t})::int_t
end
function dLPanelUpdate(k, IrecvPlcd_D, factored_L, arg4, BlockUFactor, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.dLPanelUpdate(k::int_t, IrecvPlcd_D::Ptr{int_t}, factored_L::Ptr{int_t}, arg4::Ptr{MPI_Request}, BlockUFactor::Ptr{Cdouble}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{dLUstruct_t{Int32}}, arg8::Ptr{SCT_t})::int_t
end
function dUPanelUpdate(k, factored_U, arg3, BlockLFactor, bigV, ldt, arg7, arg8, arg9, arg10, arg11)
@ccall libsuperlu_dist_Int32.dUPanelUpdate(k::int_t, factored_U::Ptr{int_t}, arg3::Ptr{MPI_Request}, BlockLFactor::Ptr{Cdouble}, bigV::Ptr{Cdouble}, ldt::int_t, arg7::Ptr{Ublock_info_t}, arg8::Ptr{gridinfo_t{Int32}}, arg9::Ptr{dLUstruct_t{Int32}}, arg10::Ptr{SuperLUStat_t{Int32}}, arg11::Ptr{SCT_t})::int_t
end
function dIBcastRecvLPanel(k, k0, msgcnt, arg4, arg5, Lsub_buf, Lval_buf, factored, arg9, arg10, arg11, tag_ub)
@ccall libsuperlu_dist_Int32.dIBcastRecvLPanel(k::int_t, k0::int_t, msgcnt::Ptr{Cint}, arg4::Ptr{MPI_Request}, arg5::Ptr{MPI_Request}, Lsub_buf::Ptr{int_t}, Lval_buf::Ptr{Cdouble}, factored::Ptr{int_t}, arg9::Ptr{gridinfo_t{Int32}}, arg10::Ptr{dLUstruct_t{Int32}}, arg11::Ptr{SCT_t}, tag_ub::Cint)::int_t
end
function dIBcastRecvUPanel(k, k0, msgcnt, arg4, arg5, Usub_buf, Uval_buf, arg8, arg9, arg10, tag_ub)
@ccall libsuperlu_dist_Int32.dIBcastRecvUPanel(k::int_t, k0::int_t, msgcnt::Ptr{Cint}, arg4::Ptr{MPI_Request}, arg5::Ptr{MPI_Request}, Usub_buf::Ptr{int_t}, Uval_buf::Ptr{Cdouble}, arg8::Ptr{gridinfo_t{Int32}}, arg9::Ptr{dLUstruct_t{Int32}}, arg10::Ptr{SCT_t}, tag_ub::Cint)::int_t
end
function dWaitL(k, msgcnt, msgcntU, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.dWaitL(k::int_t, msgcnt::Ptr{Cint}, msgcntU::Ptr{Cint}, arg4::Ptr{MPI_Request}, arg5::Ptr{MPI_Request}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{dLUstruct_t{Int32}}, arg8::Ptr{SCT_t})::int_t
end
function dWaitU(k, msgcnt, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.dWaitU(k::int_t, msgcnt::Ptr{Cint}, arg3::Ptr{MPI_Request}, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int32}}, arg6::Ptr{dLUstruct_t{Int32}}, arg7::Ptr{SCT_t})::int_t
end
function dLPanelTrSolve(k, factored_L, BlockUFactor, arg4, arg5)
@ccall libsuperlu_dist_Int32.dLPanelTrSolve(k::int_t, factored_L::Ptr{int_t}, BlockUFactor::Ptr{Cdouble}, arg4::Ptr{gridinfo_t{Int32}}, arg5::Ptr{dLUstruct_t{Int32}})::int_t
end
function dSchurComplementSetup(k, msgcnt, arg3, arg4, arg5, arg6, arg7, arg8, arg9, bigU, Lsub_buf, Lval_buf, Usub_buf, Uval_buf, arg15, arg16)
@ccall libsuperlu_dist_Int32.dSchurComplementSetup(k::int_t, msgcnt::Ptr{Cint}, arg3::Ptr{Ublock_info_t}, arg4::Ptr{Remain_info_t}, arg5::Ptr{uPanelInfo_t{Int32}}, arg6::Ptr{lPanelInfo_t{Int32}}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{int_t}, bigU::Ptr{Cdouble}, Lsub_buf::Ptr{int_t}, Lval_buf::Ptr{Cdouble}, Usub_buf::Ptr{int_t}, Uval_buf::Ptr{Cdouble}, arg15::Ptr{gridinfo_t{Int32}}, arg16::Ptr{dLUstruct_t{Int32}})::int_t
end
function dSchurComplementSetupGPU(k, msgs, arg3, arg4, arg5, arg6, arg7, arg8, arg9, LUvsb, arg11, arg12, arg13)
@ccall libsuperlu_dist_Int32.dSchurComplementSetupGPU(k::int_t, msgs::Ptr{msgs_t}, arg3::Ptr{packLUInfo_t{Int32}}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{int_t}, arg7::Ptr{gEtreeInfo_t{Int32}}, arg8::Ptr{factNodelists_t{Int32}}, arg9::Ptr{dscuBufs_t}, LUvsb::Ptr{dLUValSubBuf_t{Int32}}, arg11::Ptr{gridinfo_t{Int32}}, arg12::Ptr{dLUstruct_t{Int32}}, arg13::Ptr{HyP_t})::int_t
end
function dgetBigV(arg1, arg2)
@ccall libsuperlu_dist_Int32.dgetBigV(arg1::int_t, arg2::int_t)::Ptr{Cdouble}
end
function dgetBigU(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.dgetBigU(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{dLUstruct_t{Int32}})::Ptr{Cdouble}
end
function dLluBufInit(arg1, arg2)
@ccall libsuperlu_dist_Int32.dLluBufInit(arg1::Ptr{dLUValSubBuf_t{Int32}}, arg2::Ptr{dLUstruct_t{Int32}})::int_t
end
function dinitScuBufs(arg1, ldt, num_threads, nsupers, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.dinitScuBufs(arg1::Ptr{superlu_dist_options_t}, ldt::int_t, num_threads::int_t, nsupers::int_t, arg5::Ptr{dscuBufs_t}, arg6::Ptr{dLUstruct_t{Int32}}, arg7::Ptr{gridinfo_t{Int32}})::int_t
end
function dfreeScuBufs(scuBufs)
@ccall libsuperlu_dist_Int32.dfreeScuBufs(scuBufs::Ptr{dscuBufs_t})::Cint
end
function dsparseTreeFactor(nnodes, perm_c_supno, treeTopoInfo, comReqs, scuBufs, packLUInfo, msgs, LUvsb, dFBuf, factStat, fNlists, options, gIperm_c_supno, ldt, LUstruct, grid3d, stat, thresh, SCT, info)
@ccall libsuperlu_dist_Int32.dsparseTreeFactor(nnodes::int_t, perm_c_supno::Ptr{int_t}, treeTopoInfo::Ptr{treeTopoInfo_t{Int32}}, comReqs::Ptr{commRequests_t}, scuBufs::Ptr{dscuBufs_t}, packLUInfo::Ptr{packLUInfo_t{Int32}}, msgs::Ptr{msgs_t}, LUvsb::Ptr{dLUValSubBuf_t{Int32}}, dFBuf::Ptr{ddiagFactBufs_t}, factStat::Ptr{factStat_t{Int32}}, fNlists::Ptr{factNodelists_t{Int32}}, options::Ptr{superlu_dist_options_t}, gIperm_c_supno::Ptr{int_t}, ldt::int_t, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, stat::Ptr{SuperLUStat_t{Int32}}, thresh::Cdouble, SCT::Ptr{SCT_t}, info::Ptr{Cint})::int_t
end
function ddenseTreeFactor(nnnodes, perm_c_supno, comReqs, scuBufs, packLUInfo, msgs, LUvsb, dFBuf, factStat, fNlists, options, gIperm_c_supno, ldt, LUstruct, grid3d, stat, thresh, SCT, tag_ub, info)
@ccall libsuperlu_dist_Int32.ddenseTreeFactor(nnnodes::int_t, perm_c_supno::Ptr{int_t}, comReqs::Ptr{commRequests_t}, scuBufs::Ptr{dscuBufs_t}, packLUInfo::Ptr{packLUInfo_t{Int32}}, msgs::Ptr{msgs_t}, LUvsb::Ptr{dLUValSubBuf_t{Int32}}, dFBuf::Ptr{ddiagFactBufs_t}, factStat::Ptr{factStat_t{Int32}}, fNlists::Ptr{factNodelists_t{Int32}}, options::Ptr{superlu_dist_options_t}, gIperm_c_supno::Ptr{int_t}, ldt::int_t, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, stat::Ptr{SuperLUStat_t{Int32}}, thresh::Cdouble, SCT::Ptr{SCT_t}, tag_ub::Cint, info::Ptr{Cint})::int_t
end
function dsparseTreeFactor_ASYNC(sforest, comReqss, scuBufs, packLUInfo, msgss, LUvsbs, dFBufs, factStat, fNlists, gEtreeInfo, options, gIperm_c_supno, ldt, HyP, LUstruct, grid3d, stat, thresh, SCT, tag_ub, info)
@ccall libsuperlu_dist_Int32.dsparseTreeFactor_ASYNC(sforest::Ptr{sForest_t{Int32}}, comReqss::Ptr{Ptr{commRequests_t}}, scuBufs::Ptr{dscuBufs_t}, packLUInfo::Ptr{packLUInfo_t{Int32}}, msgss::Ptr{Ptr{msgs_t}}, LUvsbs::Ptr{Ptr{dLUValSubBuf_t{Int32}}}, dFBufs::Ptr{Ptr{ddiagFactBufs_t}}, factStat::Ptr{factStat_t{Int32}}, fNlists::Ptr{factNodelists_t{Int32}}, gEtreeInfo::Ptr{gEtreeInfo_t{Int32}}, options::Ptr{superlu_dist_options_t}, gIperm_c_supno::Ptr{int_t}, ldt::int_t, HyP::Ptr{HyP_t}, LUstruct::Ptr{dLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, stat::Ptr{SuperLUStat_t{Int32}}, thresh::Cdouble, SCT::Ptr{SCT_t}, tag_ub::Cint, info::Ptr{Cint})::int_t
end
function dLluBufInitArr(numLA, LUstruct)
@ccall libsuperlu_dist_Int32.dLluBufInitArr(numLA::int_t, LUstruct::Ptr{dLUstruct_t{Int32}})::Ptr{Ptr{dLUValSubBuf_t{Int32}}}
end
function dLluBufFreeArr(numLA, LUvsbs)
@ccall libsuperlu_dist_Int32.dLluBufFreeArr(numLA::int_t, LUvsbs::Ptr{Ptr{dLUValSubBuf_t{Int32}}})::Cint
end
function dinitDiagFactBufsArr(mxLeafNode, ldt, grid)
@ccall libsuperlu_dist_Int32.dinitDiagFactBufsArr(mxLeafNode::int_t, ldt::int_t, grid::Ptr{gridinfo_t{Int32}})::Ptr{Ptr{ddiagFactBufs_t}}
end
function dfreeDiagFactBufsArr(mxLeafNode, dFBufs)
@ccall libsuperlu_dist_Int32.dfreeDiagFactBufsArr(mxLeafNode::int_t, dFBufs::Ptr{Ptr{ddiagFactBufs_t}})::Cint
end
function dinitDiagFactBufs(ldt, dFBuf)
@ccall libsuperlu_dist_Int32.dinitDiagFactBufs(ldt::int_t, dFBuf::Ptr{ddiagFactBufs_t})::int_t
end
function slud_z_div(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.slud_z_div(arg1::Ptr{doublecomplex}, arg2::Ptr{doublecomplex}, arg3::Ptr{doublecomplex})::Cvoid
end
function slud_z_abs(arg1)
@ccall libsuperlu_dist_Int32.slud_z_abs(arg1::Ptr{doublecomplex})::Cdouble
end
function slud_z_abs1(arg1)
@ccall libsuperlu_dist_Int32.slud_z_abs1(arg1::Ptr{doublecomplex})::Cdouble
end
function zCreate_CompCol_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int32.zCreate_CompCol_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{doublecomplex}, arg6::Ptr{int_t}, arg7::Ptr{int_t}, arg8::Stype_t, arg9::Dtype_t, arg10::Mtype_t)::Cvoid
end
function zCreate_CompRowLoc_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int32.zCreate_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::int_t, arg6::int_t, arg7::Ptr{doublecomplex}, arg8::Ptr{int_t}, arg9::Ptr{int_t}, arg10::Stype_t, arg11::Dtype_t, arg12::Mtype_t)::Cvoid
end
function zCompRow_to_CompCol_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.zCompRow_to_CompCol_dist(arg1::int_t, arg2::int_t, arg3::int_t, arg4::Ptr{doublecomplex}, arg5::Ptr{int_t}, arg6::Ptr{int_t}, arg7::Ptr{Ptr{doublecomplex}}, arg8::Ptr{Ptr{int_t}}, arg9::Ptr{Ptr{int_t}})::Cvoid
end
function pzCompRow_loc_to_CompCol_global(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.pzCompRow_loc_to_CompCol_global(arg1::int_t, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{SuperMatrix{Int32}})::Cint
end
function zCopy_CompCol_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int32.zCopy_CompCol_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{SuperMatrix{Int32}})::Cvoid
end
function zCreate_Dense_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.zCreate_Dense_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::int_t, arg3::int_t, arg4::Ptr{doublecomplex}, arg5::int_t, arg6::Stype_t, arg7::Dtype_t, arg8::Mtype_t)::Cvoid
end
function zCreate_SuperNode_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13)
@ccall libsuperlu_dist_Int32.zCreate_SuperNode_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{doublecomplex}, arg6::Ptr{int_t}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{int_t}, arg10::Ptr{int_t}, arg11::Stype_t, arg12::Dtype_t, arg13::Mtype_t)::Cvoid
end
function zCopy_Dense_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.zCopy_Dense_Matrix_dist(arg1::int_t, arg2::int_t, arg3::Ptr{doublecomplex}, arg4::int_t, arg5::Ptr{doublecomplex}, arg6::int_t)::Cvoid
end
function zallocateA_dist(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int32.zallocateA_dist(arg1::int_t, arg2::int_t, arg3::Ptr{Ptr{doublecomplex}}, arg4::Ptr{Ptr{int_t}}, arg5::Ptr{Ptr{int_t}})::Cvoid
end
function zGenXtrue_dist(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.zGenXtrue_dist(arg1::int_t, arg2::int_t, arg3::Ptr{doublecomplex}, arg4::int_t)::Cvoid
end
function zFillRHS_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.zFillRHS_dist(arg1::Ptr{Cchar}, arg2::int_t, arg3::Ptr{doublecomplex}, arg4::int_t, arg5::Ptr{SuperMatrix{Int32}}, arg6::Ptr{doublecomplex}, arg7::int_t)::Cvoid
end
function zcreate_matrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.zcreate_matrix(arg1::Ptr{SuperMatrix{Int32}}, arg2::Cint, arg3::Ptr{Ptr{doublecomplex}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{doublecomplex}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{gridinfo_t{Int32}})::Cint
end
function zcreate_matrix_rb(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.zcreate_matrix_rb(arg1::Ptr{SuperMatrix{Int32}}, arg2::Cint, arg3::Ptr{Ptr{doublecomplex}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{doublecomplex}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{gridinfo_t{Int32}})::Cint
end
function zcreate_matrix_dat(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.zcreate_matrix_dat(arg1::Ptr{SuperMatrix{Int32}}, arg2::Cint, arg3::Ptr{Ptr{doublecomplex}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{doublecomplex}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{gridinfo_t{Int32}})::Cint
end
function zcreate_matrix_postfix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.zcreate_matrix_postfix(arg1::Ptr{SuperMatrix{Int32}}, arg2::Cint, arg3::Ptr{Ptr{doublecomplex}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{doublecomplex}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{Cchar}, arg9::Ptr{gridinfo_t{Int32}})::Cint
end
function zScalePermstructInit(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.zScalePermstructInit(arg1::int_t, arg2::int_t, arg3::Ptr{zScalePermstruct_t})::Cvoid
end
function zScalePermstructFree(arg1)
@ccall libsuperlu_dist_Int32.zScalePermstructFree(arg1::Ptr{zScalePermstruct_t})::Cvoid
end
function zgsequ_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.zgsequ_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble}, arg7::Ptr{int_t})::Cvoid
end
function zlangs_dist(arg1, arg2)
@ccall libsuperlu_dist_Int32.zlangs_dist(arg1::Ptr{Cchar}, arg2::Ptr{SuperMatrix{Int32}})::Cdouble
end
function zlaqgs_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.zlaqgs_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Cdouble, arg5::Cdouble, arg6::Cdouble, arg7::Ptr{Cchar})::Cvoid
end
function pzgsequ(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.pzgsequ(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble}, arg7::Ptr{int_t}, arg8::Ptr{gridinfo_t{Int32}})::Cvoid
end
function pzlangs(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.pzlangs(arg1::Ptr{Cchar}, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{gridinfo_t{Int32}})::Cdouble
end
function pzlaqgs(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.pzlaqgs(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Cdouble, arg5::Cdouble, arg6::Cdouble, arg7::Ptr{Cchar})::Cvoid
end
function pzPermute_Dense_Matrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int32.pzPermute_Dense_Matrix(arg1::int_t, arg2::int_t, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{doublecomplex}, arg6::Cint, arg7::Ptr{doublecomplex}, arg8::Cint, arg9::Cint, arg10::Ptr{gridinfo_t{Int32}})::Cint
end
function sp_ztrsv_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.sp_ztrsv_dist(arg1::Ptr{Cchar}, arg2::Ptr{Cchar}, arg3::Ptr{Cchar}, arg4::Ptr{SuperMatrix{Int32}}, arg5::Ptr{SuperMatrix{Int32}}, arg6::Ptr{doublecomplex}, arg7::Ptr{Cint})::Cint
end
function sp_zgemv_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.sp_zgemv_dist(arg1::Ptr{Cchar}, arg2::doublecomplex, arg3::Ptr{SuperMatrix{Int32}}, arg4::Ptr{doublecomplex}, arg5::Cint, arg6::doublecomplex, arg7::Ptr{doublecomplex}, arg8::Cint)::Cint
end
function sp_zgemm_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.sp_zgemm_dist(arg1::Ptr{Cchar}, arg2::Cint, arg3::doublecomplex, arg4::Ptr{SuperMatrix{Int32}}, arg5::Ptr{doublecomplex}, arg6::Cint, arg7::doublecomplex, arg8::Ptr{doublecomplex}, arg9::Cint)::Cint
end
function zdistribute(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.zdistribute(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int32}}, arg4::Ptr{Glu_freeable_t{Int32}}, arg5::Ptr{zLUstruct_t{Int32}}, arg6::Ptr{gridinfo_t{Int32}})::Cfloat
end
function pzgssvx_ABglobal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
@ccall libsuperlu_dist_Int32.pzgssvx_ABglobal(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{zScalePermstruct_t}, arg4::Ptr{doublecomplex}, arg5::Cint, arg6::Cint, arg7::Ptr{gridinfo_t{Int32}}, arg8::Ptr{zLUstruct_t{Int32}}, arg9::Ptr{Cdouble}, arg10::Ptr{SuperLUStat_t{Int32}}, arg11::Ptr{Cint})::Cvoid
end
function pzdistribute(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.pzdistribute(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int32}}, arg4::Ptr{zScalePermstruct_t}, arg5::Ptr{Glu_freeable_t{Int32}}, arg6::Ptr{zLUstruct_t{Int32}}, arg7::Ptr{gridinfo_t{Int32}})::Cfloat
end
function pzgssvx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int32.pzgssvx(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{zScalePermstruct_t}, arg4::Ptr{doublecomplex}, arg5::Cint, arg6::Cint, arg7::Ptr{gridinfo_t{Int32}}, arg8::Ptr{zLUstruct_t{Int32}}, arg9::Ptr{zSOLVEstruct_t{Int32}}, arg10::Ptr{Cdouble}, arg11::Ptr{SuperLUStat_t{Int32}}, arg12::Ptr{Cint})::Cvoid
end
function pzCompute_Diag_Inv(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int32.pzCompute_Diag_Inv(arg1::int_t, arg2::Ptr{zLUstruct_t{Int32}}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{SuperLUStat_t{Int32}}, arg5::Ptr{Cint})::Cvoid
end
function zSolveInit(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.zSolveInit(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::int_t, arg6::Ptr{zLUstruct_t{Int32}}, arg7::Ptr{gridinfo_t{Int32}}, arg8::Ptr{zSOLVEstruct_t{Int32}})::Cint
end
function zSolveFinalize(arg1, arg2)
@ccall libsuperlu_dist_Int32.zSolveFinalize(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{zSOLVEstruct_t{Int32}})::Cvoid
end
function zDestroy_A3d_gathered_on_2d(arg1, arg2)
@ccall libsuperlu_dist_Int32.zDestroy_A3d_gathered_on_2d(arg1::Ptr{zSOLVEstruct_t{Int32}}, arg2::Ptr{gridinfo3d_t{Int32}})::Cvoid
end
function pzgstrs_init(arg1, arg2, arg3, arg4, arg5, arg6, grid, arg8, arg9)
@ccall libsuperlu_dist_Int32.pzgstrs_init(arg1::int_t, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{int_t}, arg6::Ptr{int_t}, grid::Ptr{gridinfo_t{Int32}}, arg8::Ptr{Glu_persist_t}, arg9::Ptr{zSOLVEstruct_t{Int32}})::int_t
end
function zldperm_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.zldperm_dist(arg1::Cint, arg2::Cint, arg3::int_t, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{doublecomplex}, arg7::Ptr{int_t}, arg8::Ptr{Cdouble}, arg9::Ptr{Cdouble})::Cint
end
function zstatic_schedule(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.zstatic_schedule(arg1::Ptr{superlu_dist_options_t}, arg2::Cint, arg3::Cint, arg4::Ptr{zLUstruct_t{Int32}}, arg5::Ptr{gridinfo_t{Int32}}, arg6::Ptr{SuperLUStat_t{Int32}}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{Cint})::Cint
end
function zLUstructInit(arg1, arg2)
@ccall libsuperlu_dist_Int32.zLUstructInit(arg1::int_t, arg2::Ptr{zLUstruct_t{Int32}})::Cvoid
end
function zLUstructFree(arg1)
@ccall libsuperlu_dist_Int32.zLUstructFree(arg1::Ptr{zLUstruct_t{Int32}})::Cvoid
end
function zDestroy_LU(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.zDestroy_LU(arg1::int_t, arg2::Ptr{gridinfo_t{Int32}}, arg3::Ptr{zLUstruct_t{Int32}})::Cvoid
end
function zDestroy_Tree(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.zDestroy_Tree(arg1::int_t, arg2::Ptr{gridinfo_t{Int32}}, arg3::Ptr{zLUstruct_t{Int32}})::Cvoid
end
function zscatter_l(ib, ljb, nsupc, iukp, xsup, klst, nbrow, lptr, temp_nbrow, usub, lsub, tempv, indirect_thread, indirect2, Lrowind_bc_ptr, Lnzval_bc_ptr, grid)
@ccall libsuperlu_dist_Int32.zscatter_l(ib::Cint, ljb::Cint, nsupc::Cint, iukp::int_t, xsup::Ptr{int_t}, klst::Cint, nbrow::Cint, lptr::int_t, temp_nbrow::Cint, usub::Ptr{int_t}, lsub::Ptr{int_t}, tempv::Ptr{doublecomplex}, indirect_thread::Ptr{Cint}, indirect2::Ptr{Cint}, Lrowind_bc_ptr::Ptr{Ptr{int_t}}, Lnzval_bc_ptr::Ptr{Ptr{doublecomplex}}, grid::Ptr{gridinfo_t{Int32}})::Cvoid
end
function zscatter_u(ib, jb, nsupc, iukp, xsup, klst, nbrow, lptr, temp_nbrow, lsub, usub, tempv, Ufstnz_br_ptr, Unzval_br_ptr, grid)
@ccall libsuperlu_dist_Int32.zscatter_u(ib::Cint, jb::Cint, nsupc::Cint, iukp::int_t, xsup::Ptr{int_t}, klst::Cint, nbrow::Cint, lptr::int_t, temp_nbrow::Cint, lsub::Ptr{int_t}, usub::Ptr{int_t}, tempv::Ptr{doublecomplex}, Ufstnz_br_ptr::Ptr{Ptr{int_t}}, Unzval_br_ptr::Ptr{Ptr{doublecomplex}}, grid::Ptr{gridinfo_t{Int32}})::Cvoid
end
function pzgstrf(arg1, arg2, arg3, anorm, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.pzgstrf(arg1::Ptr{superlu_dist_options_t}, arg2::Cint, arg3::Cint, anorm::Cdouble, arg5::Ptr{zLUstruct_t{Int32}}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{SuperLUStat_t{Int32}}, arg8::Ptr{Cint})::int_t
end
function pzgstrs_Bglobal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.pzgstrs_Bglobal(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{zLUstruct_t{Int32}}, arg4::Ptr{gridinfo_t{Int32}}, arg5::Ptr{doublecomplex}, arg6::int_t, arg7::Cint, arg8::Ptr{SuperLUStat_t{Int32}}, arg9::Ptr{Cint})::Cvoid
end
function pzgstrs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13)
@ccall libsuperlu_dist_Int32.pzgstrs(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{zLUstruct_t{Int32}}, arg4::Ptr{zScalePermstruct_t}, arg5::Ptr{gridinfo_t{Int32}}, arg6::Ptr{doublecomplex}, arg7::int_t, arg8::int_t, arg9::int_t, arg10::Cint, arg11::Ptr{zSOLVEstruct_t{Int32}}, arg12::Ptr{SuperLUStat_t{Int32}}, arg13::Ptr{Cint})::Cvoid
end
function pzgstrf2_trsm(options, k0, k, thresh, arg5, arg6, arg7, arg8, tag_ub, arg10, info)
@ccall libsuperlu_dist_Int32.pzgstrf2_trsm(options::Ptr{superlu_dist_options_t}, k0::int_t, k::int_t, thresh::Cdouble, arg5::Ptr{Glu_persist_t}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{zLocalLU_t{Int32}}, arg8::Ptr{MPI_Request}, tag_ub::Cint, arg10::Ptr{SuperLUStat_t{Int32}}, info::Ptr{Cint})::Cvoid
end
function pzgstrs2_omp(k0, k, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.pzgstrs2_omp(k0::int_t, k::int_t, arg3::Ptr{Glu_persist_t}, arg4::Ptr{gridinfo_t{Int32}}, arg5::Ptr{zLocalLU_t{Int32}}, arg6::Ptr{Ublock_info_t}, arg7::Ptr{SuperLUStat_t{Int32}})::Cvoid
end
function pzReDistribute_B_to_X(B, m_loc, nrhs, ldb, fst_row, ilsum, x, arg8, arg9, arg10, arg11)
@ccall libsuperlu_dist_Int32.pzReDistribute_B_to_X(B::Ptr{doublecomplex}, m_loc::int_t, nrhs::Cint, ldb::int_t, fst_row::int_t, ilsum::Ptr{int_t}, x::Ptr{doublecomplex}, arg8::Ptr{zScalePermstruct_t}, arg9::Ptr{Glu_persist_t}, arg10::Ptr{gridinfo_t{Int32}}, arg11::Ptr{zSOLVEstruct_t{Int32}})::int_t
end
function zlsum_fmod(arg1, arg2, arg3, arg4, arg5, arg6, arg7, fmod, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16)
@ccall libsuperlu_dist_Int32.zlsum_fmod(arg1::Ptr{doublecomplex}, arg2::Ptr{doublecomplex}, arg3::Ptr{doublecomplex}, arg4::Ptr{doublecomplex}, arg5::Cint, arg6::Cint, arg7::int_t, fmod::Ptr{Cint}, arg9::int_t, arg10::int_t, arg11::int_t, arg12::Ptr{int_t}, arg13::Ptr{gridinfo_t{Int32}}, arg14::Ptr{zLocalLU_t{Int32}}, arg15::Ptr{MPI_Request}, arg16::Ptr{SuperLUStat_t{Int32}})::Cvoid
end
function zlsum_bmod(arg1, arg2, arg3, arg4, arg5, bmod, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14)
@ccall libsuperlu_dist_Int32.zlsum_bmod(arg1::Ptr{doublecomplex}, arg2::Ptr{doublecomplex}, arg3::Ptr{doublecomplex}, arg4::Cint, arg5::int_t, bmod::Ptr{Cint}, arg7::Ptr{int_t}, arg8::Ptr{Ptr{Ucb_indptr_t}}, arg9::Ptr{Ptr{int_t}}, arg10::Ptr{int_t}, arg11::Ptr{gridinfo_t{Int32}}, arg12::Ptr{zLocalLU_t{Int32}}, arg13::Ptr{MPI_Request}, arg14::Ptr{SuperLUStat_t{Int32}})::Cvoid
end
function zlsum_fmod_inv(arg1, arg2, arg3, arg4, arg5, arg6, fmod, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19)
@ccall libsuperlu_dist_Int32.zlsum_fmod_inv(arg1::Ptr{doublecomplex}, arg2::Ptr{doublecomplex}, arg3::Ptr{doublecomplex}, arg4::Ptr{doublecomplex}, arg5::Cint, arg6::int_t, fmod::Ptr{Cint}, arg8::Ptr{int_t}, arg9::Ptr{gridinfo_t{Int32}}, arg10::Ptr{zLocalLU_t{Int32}}, arg11::Ptr{Ptr{SuperLUStat_t{Int32}}}, arg12::Ptr{int_t}, arg13::Ptr{int_t}, arg14::int_t, arg15::int_t, arg16::int_t, arg17::int_t, arg18::Cint, arg19::Cint)::Cvoid
end
function zlsum_fmod_inv_master(arg1, arg2, arg3, arg4, arg5, arg6, arg7, fmod, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19)
@ccall libsuperlu_dist_Int32.zlsum_fmod_inv_master(arg1::Ptr{doublecomplex}, arg2::Ptr{doublecomplex}, arg3::Ptr{doublecomplex}, arg4::Ptr{doublecomplex}, arg5::Cint, arg6::Cint, arg7::int_t, fmod::Ptr{Cint}, arg9::int_t, arg10::Ptr{int_t}, arg11::Ptr{gridinfo_t{Int32}}, arg12::Ptr{zLocalLU_t{Int32}}, arg13::Ptr{Ptr{SuperLUStat_t{Int32}}}, arg14::int_t, arg15::int_t, arg16::int_t, arg17::int_t, arg18::Cint, arg19::Cint)::Cvoid
end
function zlsum_bmod_inv(arg1, arg2, arg3, arg4, arg5, arg6, bmod, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20)
@ccall libsuperlu_dist_Int32.zlsum_bmod_inv(arg1::Ptr{doublecomplex}, arg2::Ptr{doublecomplex}, arg3::Ptr{doublecomplex}, arg4::Ptr{doublecomplex}, arg5::Cint, arg6::int_t, bmod::Ptr{Cint}, arg8::Ptr{int_t}, arg9::Ptr{Ptr{Ucb_indptr_t}}, arg10::Ptr{Ptr{int_t}}, arg11::Ptr{int_t}, arg12::Ptr{gridinfo_t{Int32}}, arg13::Ptr{zLocalLU_t{Int32}}, arg14::Ptr{Ptr{SuperLUStat_t{Int32}}}, arg15::Ptr{int_t}, arg16::Ptr{int_t}, arg17::int_t, arg18::int_t, arg19::Cint, arg20::Cint)::Cvoid
end
function zlsum_bmod_inv_master(arg1, arg2, arg3, arg4, arg5, arg6, bmod, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18)
@ccall libsuperlu_dist_Int32.zlsum_bmod_inv_master(arg1::Ptr{doublecomplex}, arg2::Ptr{doublecomplex}, arg3::Ptr{doublecomplex}, arg4::Ptr{doublecomplex}, arg5::Cint, arg6::int_t, bmod::Ptr{Cint}, arg8::Ptr{int_t}, arg9::Ptr{Ptr{Ucb_indptr_t}}, arg10::Ptr{Ptr{int_t}}, arg11::Ptr{int_t}, arg12::Ptr{gridinfo_t{Int32}}, arg13::Ptr{zLocalLU_t{Int32}}, arg14::Ptr{Ptr{SuperLUStat_t{Int32}}}, arg15::int_t, arg16::int_t, arg17::Cint, arg18::Cint)::Cvoid
end
function zComputeLevelsets(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.zComputeLevelsets(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{zLocalLU_t{Int32}}, arg6::Ptr{int_t})::Cvoid
end
function pzgsrfs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16)
@ccall libsuperlu_dist_Int32.pzgsrfs(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int32}}, arg4::Cdouble, arg5::Ptr{zLUstruct_t{Int32}}, arg6::Ptr{zScalePermstruct_t}, arg7::Ptr{gridinfo_t{Int32}}, arg8::Ptr{doublecomplex}, arg9::int_t, arg10::Ptr{doublecomplex}, arg11::int_t, arg12::Cint, arg13::Ptr{zSOLVEstruct_t{Int32}}, arg14::Ptr{Cdouble}, arg15::Ptr{SuperLUStat_t{Int32}}, arg16::Ptr{Cint})::Cvoid
end
function pzgsrfs_ABXglobal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14)
@ccall libsuperlu_dist_Int32.pzgsrfs_ABXglobal(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int32}}, arg4::Cdouble, arg5::Ptr{zLUstruct_t{Int32}}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{doublecomplex}, arg8::int_t, arg9::Ptr{doublecomplex}, arg10::int_t, arg11::Cint, arg12::Ptr{Cdouble}, arg13::Ptr{SuperLUStat_t{Int32}}, arg14::Ptr{Cint})::Cvoid
end
function pzgsmv_AXglobal_setup(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.pzgsmv_AXglobal_setup(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{Glu_persist_t}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{int_t}}, arg6::Ptr{Ptr{doublecomplex}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{int_t})::Cint
end
function pzgsmv_AXglobal(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.pzgsmv_AXglobal(arg1::int_t, arg2::Ptr{int_t}, arg3::Ptr{doublecomplex}, arg4::Ptr{int_t}, arg5::Ptr{doublecomplex}, arg6::Ptr{doublecomplex})::Cint
end
function pzgsmv_AXglobal_abs(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.pzgsmv_AXglobal_abs(arg1::int_t, arg2::Ptr{int_t}, arg3::Ptr{doublecomplex}, arg4::Ptr{int_t}, arg5::Ptr{doublecomplex}, arg6::Ptr{Cdouble})::Cint
end
function pzgsmv_init(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.pzgsmv_init(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{int_t}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{pzgsmv_comm_t})::Cvoid
end
function pzgsmv(arg1, arg2, arg3, arg4, x, ax)
@ccall libsuperlu_dist_Int32.pzgsmv(arg1::int_t, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{pzgsmv_comm_t}, x::Ptr{doublecomplex}, ax::Ptr{doublecomplex})::Cvoid
end
function pzgsmv_finalize(arg1)
@ccall libsuperlu_dist_Int32.pzgsmv_finalize(arg1::Ptr{pzgsmv_comm_t})::Cvoid
end
function doublecomplexMalloc_dist(arg1)
@ccall libsuperlu_dist_Int32.doublecomplexMalloc_dist(arg1::int_t)::Ptr{doublecomplex}
end
function doublecomplexCalloc_dist(arg1)
@ccall libsuperlu_dist_Int32.doublecomplexCalloc_dist(arg1::int_t)::Ptr{doublecomplex}
end
function zQuerySpace_dist(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int32.zQuerySpace_dist(arg1::int_t, arg2::Ptr{zLUstruct_t{Int32}}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{SuperLUStat_t{Int32}}, arg5::Ptr{superlu_dist_mem_usage_t})::int_t
end
function zClone_CompRowLoc_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int32.zClone_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{SuperMatrix{Int32}})::Cvoid
end
function zCopy_CompRowLoc_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int32.zCopy_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{SuperMatrix{Int32}})::Cvoid
end
function zZero_CompRowLoc_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int32.zZero_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}})::Cvoid
end
function zScaleAddId_CompRowLoc_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int32.zScaleAddId_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::doublecomplex)::Cvoid
end
function zScaleAdd_CompRowLoc_Matrix_dist(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.zScaleAdd_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{SuperMatrix{Int32}}, arg3::doublecomplex)::Cvoid
end
function zZeroLblocks(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.zZeroLblocks(arg1::Cint, arg2::Cint, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{zLUstruct_t{Int32}})::Cvoid
end
function zZeroUblocks(iam, n, arg3, arg4)
@ccall libsuperlu_dist_Int32.zZeroUblocks(iam::Cint, n::Cint, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{zLUstruct_t{Int32}})::Cvoid
end
function zfill_dist(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.zfill_dist(arg1::Ptr{doublecomplex}, arg2::int_t, arg3::doublecomplex)::Cvoid
end
function zinf_norm_error_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.zinf_norm_error_dist(arg1::int_t, arg2::int_t, arg3::Ptr{doublecomplex}, arg4::int_t, arg5::Ptr{doublecomplex}, arg6::int_t, arg7::Ptr{gridinfo_t{Int32}})::Cvoid
end
function pzinf_norm_error(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.pzinf_norm_error(arg1::Cint, arg2::int_t, arg3::int_t, arg4::Ptr{doublecomplex}, arg5::int_t, arg6::Ptr{doublecomplex}, arg7::int_t, arg8::MPI_Comm)::Cvoid
end
function zreadhb_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.zreadhb_dist(arg1::Cint, arg2::Ptr{Libc.FILE}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{Ptr{doublecomplex}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}})::Cvoid
end
function zreadtriple_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.zreadtriple_dist(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{doublecomplex}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cvoid
end
function zreadtriple_noheader(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.zreadtriple_noheader(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{doublecomplex}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cvoid
end
function zreadrb_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.zreadrb_dist(arg1::Cint, arg2::Ptr{Libc.FILE}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{Ptr{doublecomplex}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}})::Cvoid
end
function zreadMM_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.zreadMM_dist(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{doublecomplex}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cvoid
end
function zread_binary(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.zread_binary(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{doublecomplex}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cint
end
function zdist_psymbtonum(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.zdist_psymbtonum(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int32}}, arg4::Ptr{zScalePermstruct_t}, arg5::Ptr{Pslu_freeable_t}, arg6::Ptr{zLUstruct_t{Int32}}, arg7::Ptr{gridinfo_t{Int32}})::Cfloat
end
function pzGetDiagU(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.pzGetDiagU(arg1::int_t, arg2::Ptr{zLUstruct_t{Int32}}, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{doublecomplex})::Cvoid
end
function z_c2cpp_GetHWPM(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.z_c2cpp_GetHWPM(arg1::Ptr{SuperMatrix{Int32}}, arg2::Ptr{gridinfo_t{Int32}}, arg3::Ptr{zScalePermstruct_t})::Cint
end
function zPrintLblocks(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int32.zPrintLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{zLocalLU_t{Int32}})::Cvoid
end
function zPrintUblocks(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int32.zPrintUblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{zLocalLU_t{Int32}})::Cvoid
end
function zPrint_CompCol_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int32.zPrint_CompCol_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}})::Cvoid
end
function zPrint_Dense_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int32.zPrint_Dense_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}})::Cvoid
end
function zPrint_CompRowLoc_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int32.zPrint_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int32}})::Cint
end
function file_zPrint_CompRowLoc_Matrix_dist(fp, A)
@ccall libsuperlu_dist_Int32.file_zPrint_CompRowLoc_Matrix_dist(fp::Ptr{Libc.FILE}, A::Ptr{SuperMatrix{Int32}})::Cint
end
function PrintDoublecomplex(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int32.PrintDoublecomplex(arg1::Ptr{Cchar}, arg2::int_t, arg3::Ptr{doublecomplex})::Cvoid
end
function file_PrintDoublecomplex(fp, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.file_PrintDoublecomplex(fp::Ptr{Libc.FILE}, arg2::Ptr{Cchar}, arg3::int_t, arg4::Ptr{doublecomplex})::Cint
end
function zGenCOOLblocks(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int32.zGenCOOLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{zLocalLU_t{Int32}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{doublecomplex}}, arg9::Ptr{int_t}, arg10::Ptr{int_t})::Cvoid
end
function zGenCSCLblocks(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int32.zGenCSCLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{zLocalLU_t{Int32}}, arg6::Ptr{Ptr{doublecomplex}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}}, arg9::Ptr{int_t}, arg10::Ptr{int_t})::Cvoid
end
function zGenCSRLblocks(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int32.zGenCSRLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{zLocalLU_t{Int32}}, arg6::Ptr{Ptr{doublecomplex}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}}, arg9::Ptr{int_t}, arg10::Ptr{int_t})::Cvoid
end
function superlu_zgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
@ccall libsuperlu_dist_Int32.superlu_zgemm(transa::Ptr{Cchar}, transb::Ptr{Cchar}, m::Cint, n::Cint, k::Cint, alpha::doublecomplex, a::Ptr{doublecomplex}, lda::Cint, b::Ptr{doublecomplex}, ldb::Cint, beta::doublecomplex, c::Ptr{doublecomplex}, ldc::Cint)::Cint
end
function superlu_ztrsm(sideRL, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
@ccall libsuperlu_dist_Int32.superlu_ztrsm(sideRL::Ptr{Cchar}, uplo::Ptr{Cchar}, transa::Ptr{Cchar}, diag::Ptr{Cchar}, m::Cint, n::Cint, alpha::doublecomplex, a::Ptr{doublecomplex}, lda::Cint, b::Ptr{doublecomplex}, ldb::Cint)::Cint
end
function superlu_zger(m, n, alpha, x, incx, y, incy, a, lda)
@ccall libsuperlu_dist_Int32.superlu_zger(m::Cint, n::Cint, alpha::doublecomplex, x::Ptr{doublecomplex}, incx::Cint, y::Ptr{doublecomplex}, incy::Cint, a::Ptr{doublecomplex}, lda::Cint)::Cint
end
function superlu_zscal(n, alpha, x, incx)
@ccall libsuperlu_dist_Int32.superlu_zscal(n::Cint, alpha::doublecomplex, x::Ptr{doublecomplex}, incx::Cint)::Cint
end
function superlu_zaxpy(n, alpha, x, incx, y, incy)
@ccall libsuperlu_dist_Int32.superlu_zaxpy(n::Cint, alpha::doublecomplex, x::Ptr{doublecomplex}, incx::Cint, y::Ptr{doublecomplex}, incy::Cint)::Cint
end
function superlu_zgemv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy)
@ccall libsuperlu_dist_Int32.superlu_zgemv(trans::Ptr{Cchar}, m::Cint, n::Cint, alpha::doublecomplex, a::Ptr{doublecomplex}, lda::Cint, x::Ptr{doublecomplex}, incx::Cint, beta::doublecomplex, y::Ptr{doublecomplex}, incy::Cint)::Cint
end
function superlu_ztrsv(uplo, trans, diag, n, a, lda, x, incx)
@ccall libsuperlu_dist_Int32.superlu_ztrsv(uplo::Ptr{Cchar}, trans::Ptr{Cchar}, diag::Ptr{Cchar}, n::Cint, a::Ptr{doublecomplex}, lda::Cint, x::Ptr{doublecomplex}, incx::Cint)::Cint
end
function zcreate_matrix3d(A, nrhs, rhs, ldb, x, ldx, fp, grid3d)
@ccall libsuperlu_dist_Int32.zcreate_matrix3d(A::Ptr{SuperMatrix{Int32}}, nrhs::Cint, rhs::Ptr{Ptr{doublecomplex}}, ldb::Ptr{Cint}, x::Ptr{Ptr{doublecomplex}}, ldx::Ptr{Cint}, fp::Ptr{Libc.FILE}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cint
end
function zcreate_matrix_postfix3d(A, nrhs, rhs, ldb, x, ldx, fp, postfix, grid3d)
@ccall libsuperlu_dist_Int32.zcreate_matrix_postfix3d(A::Ptr{SuperMatrix{Int32}}, nrhs::Cint, rhs::Ptr{Ptr{doublecomplex}}, ldb::Ptr{Cint}, x::Ptr{Ptr{doublecomplex}}, ldx::Ptr{Cint}, fp::Ptr{Libc.FILE}, postfix::Ptr{Cchar}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cint
end
function zGatherNRformat_loc3d(Fact, A, B, ldb, nrhs, grid3d, arg7)
@ccall libsuperlu_dist_Int32.zGatherNRformat_loc3d(Fact::fact_t, A::Ptr{NRformat_loc{Int32}}, B::Ptr{doublecomplex}, ldb::Cint, nrhs::Cint, grid3d::Ptr{gridinfo3d_t{Int32}}, arg7::Ptr{Ptr{NRformat_loc3d{Int32}}})::Cvoid
end
function zScatter_B3d(A3d, grid3d)
@ccall libsuperlu_dist_Int32.zScatter_B3d(A3d::Ptr{NRformat_loc3d{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cint
end
function pzgssvx3d(arg1, arg2, arg3, B, ldb, nrhs, arg7, arg8, arg9, berr, arg11, info)
@ccall libsuperlu_dist_Int32.pzgssvx3d(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int32}}, arg3::Ptr{zScalePermstruct_t}, B::Ptr{doublecomplex}, ldb::Cint, nrhs::Cint, arg7::Ptr{gridinfo3d_t{Int32}}, arg8::Ptr{zLUstruct_t{Int32}}, arg9::Ptr{zSOLVEstruct_t{Int32}}, berr::Ptr{Cdouble}, arg11::Ptr{SuperLUStat_t{Int32}}, info::Ptr{Cint})::Cvoid
end
function pzgstrf3d(arg1, m, n, anorm, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int32.pzgstrf3d(arg1::Ptr{superlu_dist_options_t}, m::Cint, n::Cint, anorm::Cdouble, arg5::Ptr{ztrf3Dpartition_t{Int32}}, arg6::Ptr{SCT_t}, arg7::Ptr{zLUstruct_t{Int32}}, arg8::Ptr{gridinfo3d_t{Int32}}, arg9::Ptr{SuperLUStat_t{Int32}}, arg10::Ptr{Cint})::int_t
end
function zInit_HyP(HyP, Llu, mcb, mrb)
@ccall libsuperlu_dist_Int32.zInit_HyP(HyP::Ptr{HyP_t}, Llu::Ptr{zLocalLU_t{Int32}}, mcb::int_t, mrb::int_t)::Cvoid
end
function zblock_gemm_scatter(lb, j, Ublock_info, Remain_info, L_mat, ldl, U_mat, ldu, bigV, knsupc, klst, lsub, usub, ldt, thread_id, indirect, indirect2, Lrowind_bc_ptr, Lnzval_bc_ptr, Ufstnz_br_ptr, Unzval_br_ptr, xsup, arg23, arg24)
@ccall libsuperlu_dist_Int32.zblock_gemm_scatter(lb::int_t, j::int_t, Ublock_info::Ptr{Ublock_info_t}, Remain_info::Ptr{Remain_info_t}, L_mat::Ptr{doublecomplex}, ldl::Cint, U_mat::Ptr{doublecomplex}, ldu::Cint, bigV::Ptr{doublecomplex}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, thread_id::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, Lrowind_bc_ptr::Ptr{Ptr{int_t}}, Lnzval_bc_ptr::Ptr{Ptr{doublecomplex}}, Ufstnz_br_ptr::Ptr{Ptr{int_t}}, Unzval_br_ptr::Ptr{Ptr{doublecomplex}}, xsup::Ptr{int_t}, arg23::Ptr{gridinfo_t{Int32}}, arg24::Ptr{SuperLUStat_t{Int32}})::Cvoid
end
function zblock_gemm_scatterTopLeft(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int32.zblock_gemm_scatterTopLeft(lb::int_t, j::int_t, bigV::Ptr{doublecomplex}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{zLUstruct_t{Int32}}, arg13::Ptr{gridinfo_t{Int32}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int32}})::int_t
end
function zblock_gemm_scatterTopRight(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int32.zblock_gemm_scatterTopRight(lb::int_t, j::int_t, bigV::Ptr{doublecomplex}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{zLUstruct_t{Int32}}, arg13::Ptr{gridinfo_t{Int32}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int32}})::int_t
end
function zblock_gemm_scatterBottomLeft(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int32.zblock_gemm_scatterBottomLeft(lb::int_t, j::int_t, bigV::Ptr{doublecomplex}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{zLUstruct_t{Int32}}, arg13::Ptr{gridinfo_t{Int32}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int32}})::int_t
end
function zblock_gemm_scatterBottomRight(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int32.zblock_gemm_scatterBottomRight(lb::int_t, j::int_t, bigV::Ptr{doublecomplex}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{zLUstruct_t{Int32}}, arg13::Ptr{gridinfo_t{Int32}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int32}})::int_t
end
function zgather_u(num_u_blks, Ublock_info, usub, uval, bigU, ldu, xsup, klst)
@ccall libsuperlu_dist_Int32.zgather_u(num_u_blks::int_t, Ublock_info::Ptr{Ublock_info_t}, usub::Ptr{int_t}, uval::Ptr{doublecomplex}, bigU::Ptr{doublecomplex}, ldu::int_t, xsup::Ptr{int_t}, klst::int_t)::Cvoid
end
function zgather_l(num_LBlk, knsupc, L_info, lval, LD_lval, L_buff)
@ccall libsuperlu_dist_Int32.zgather_l(num_LBlk::int_t, knsupc::int_t, L_info::Ptr{Remain_info_t}, lval::Ptr{doublecomplex}, LD_lval::int_t, L_buff::Ptr{doublecomplex})::Cvoid
end
function zRgather_L(k, lsub, lusup, arg4, arg5, arg6, arg7, myIperm, iperm_c_supno)
@ccall libsuperlu_dist_Int32.zRgather_L(k::int_t, lsub::Ptr{int_t}, lusup::Ptr{doublecomplex}, arg4::Ptr{gEtreeInfo_t{Int32}}, arg5::Ptr{Glu_persist_t}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{HyP_t}, myIperm::Ptr{int_t}, iperm_c_supno::Ptr{int_t})::Cvoid
end
function zRgather_U(k, jj0, usub, uval, bigU, arg6, arg7, arg8, arg9, myIperm, iperm_c_supno, perm_u)
@ccall libsuperlu_dist_Int32.zRgather_U(k::int_t, jj0::int_t, usub::Ptr{int_t}, uval::Ptr{doublecomplex}, bigU::Ptr{doublecomplex}, arg6::Ptr{gEtreeInfo_t{Int32}}, arg7::Ptr{Glu_persist_t}, arg8::Ptr{gridinfo_t{Int32}}, arg9::Ptr{HyP_t}, myIperm::Ptr{int_t}, iperm_c_supno::Ptr{int_t}, perm_u::Ptr{int_t})::Cvoid
end
function zinitTrf3Dpartition(nsupers, options, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.zinitTrf3Dpartition(nsupers::int_t, options::Ptr{superlu_dist_options_t}, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::Ptr{ztrf3Dpartition_t{Int32}}
end
function zDestroy_trf3Dpartition(trf3Dpartition, grid3d)
@ccall libsuperlu_dist_Int32.zDestroy_trf3Dpartition(trf3Dpartition::Ptr{ztrf3Dpartition_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cvoid
end
function z3D_printMemUse(trf3Dpartition, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.z3D_printMemUse(trf3Dpartition::Ptr{ztrf3Dpartition_t{Int32}}, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cvoid
end
function zinit3DLUstructForest(myTreeIdxs, myZeroTrIdxs, sForests, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.zinit3DLUstructForest(myTreeIdxs::Ptr{int_t}, myZeroTrIdxs::Ptr{int_t}, sForests::Ptr{Ptr{sForest_t{Int32}}}, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::Cvoid
end
function zgatherAllFactoredLUFr(myZeroTrIdxs, sForests, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.zgatherAllFactoredLUFr(myZeroTrIdxs::Ptr{int_t}, sForests::Ptr{sForest_t{Int32}}, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function zLpanelUpdate(off0, nsupc, ublk_ptr, ld_ujrow, lusup, nsupr, arg7)
@ccall libsuperlu_dist_Int32.zLpanelUpdate(off0::int_t, nsupc::int_t, ublk_ptr::Ptr{doublecomplex}, ld_ujrow::int_t, lusup::Ptr{doublecomplex}, nsupr::int_t, arg7::Ptr{SCT_t})::int_t
end
function Local_Zgstrf2(options, k, thresh, BlockUFactor, arg5, arg6, arg7, arg8, info, arg10)
@ccall libsuperlu_dist_Int32.Local_Zgstrf2(options::Ptr{superlu_dist_options_t}, k::int_t, thresh::Cdouble, BlockUFactor::Ptr{doublecomplex}, arg5::Ptr{Glu_persist_t}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{zLocalLU_t{Int32}}, arg8::Ptr{SuperLUStat_t{Int32}}, info::Ptr{Cint}, arg10::Ptr{SCT_t})::Cvoid
end
function zTrs2_GatherU(iukp, rukp, klst, nsupc, ldu, usub, uval, tempv)
@ccall libsuperlu_dist_Int32.zTrs2_GatherU(iukp::int_t, rukp::int_t, klst::int_t, nsupc::int_t, ldu::int_t, usub::Ptr{int_t}, uval::Ptr{doublecomplex}, tempv::Ptr{doublecomplex})::int_t
end
function zTrs2_ScatterU(iukp, rukp, klst, nsupc, ldu, usub, uval, tempv)
@ccall libsuperlu_dist_Int32.zTrs2_ScatterU(iukp::int_t, rukp::int_t, klst::int_t, nsupc::int_t, ldu::int_t, usub::Ptr{int_t}, uval::Ptr{doublecomplex}, tempv::Ptr{doublecomplex})::int_t
end
function zTrs2_GatherTrsmScatter(klst, iukp, rukp, usub, uval, tempv, knsupc, nsupr, lusup, Glu_persist)
@ccall libsuperlu_dist_Int32.zTrs2_GatherTrsmScatter(klst::int_t, iukp::int_t, rukp::int_t, usub::Ptr{int_t}, uval::Ptr{doublecomplex}, tempv::Ptr{doublecomplex}, knsupc::int_t, nsupr::Cint, lusup::Ptr{doublecomplex}, Glu_persist::Ptr{Glu_persist_t})::int_t
end
function pzgstrs2(m, k0, k, Glu_persist, grid, Llu, stat)
@ccall libsuperlu_dist_Int32.pzgstrs2(m::int_t, k0::int_t, k::int_t, Glu_persist::Ptr{Glu_persist_t}, grid::Ptr{gridinfo_t{Int32}}, Llu::Ptr{zLocalLU_t{Int32}}, stat::Ptr{SuperLUStat_t{Int32}})::Cvoid
end
function pzgstrf2(arg1, nsupers, k0, k, thresh, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int32.pzgstrf2(arg1::Ptr{superlu_dist_options_t}, nsupers::int_t, k0::int_t, k::int_t, thresh::Cdouble, arg6::Ptr{Glu_persist_t}, arg7::Ptr{gridinfo_t{Int32}}, arg8::Ptr{zLocalLU_t{Int32}}, arg9::Ptr{MPI_Request}, arg10::Cint, arg11::Ptr{SuperLUStat_t{Int32}}, arg12::Ptr{Cint})::Cvoid
end
function zAllocLlu_3d(nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.zAllocLlu_3d(nsupers::int_t, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function zp3dScatter(n, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.zp3dScatter(n::int_t, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function zscatter3dLPanels(nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.zscatter3dLPanels(nsupers::int_t, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function zscatter3dUPanels(nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.zscatter3dUPanels(nsupers::int_t, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function zcollect3dLpanels(layer, nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.zcollect3dLpanels(layer::int_t, nsupers::int_t, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function zcollect3dUpanels(layer, nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.zcollect3dUpanels(layer::int_t, nsupers::int_t, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function zp3dCollect(layer, n, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.zp3dCollect(layer::int_t, n::int_t, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function zzeroSetLU(nnodes, nodeList, arg3, arg4)
@ccall libsuperlu_dist_Int32.zzeroSetLU(nnodes::int_t, nodeList::Ptr{int_t}, arg3::Ptr{zLUstruct_t{Int32}}, arg4::Ptr{gridinfo3d_t{Int32}})::int_t
end
function zAllocGlu_3d(n, nsupers, arg3)
@ccall libsuperlu_dist_Int32.zAllocGlu_3d(n::int_t, nsupers::int_t, arg3::Ptr{zLUstruct_t{Int32}})::Cint
end
function zDeAllocLlu_3d(n, arg2, arg3)
@ccall libsuperlu_dist_Int32.zDeAllocLlu_3d(n::int_t, arg2::Ptr{zLUstruct_t{Int32}}, arg3::Ptr{gridinfo3d_t{Int32}})::Cint
end
function zDeAllocGlu_3d(arg1)
@ccall libsuperlu_dist_Int32.zDeAllocGlu_3d(arg1::Ptr{zLUstruct_t{Int32}})::Cint
end
function zreduceAncestors3d(sender, receiver, nnodes, nodeList, Lval_buf, Uval_buf, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.zreduceAncestors3d(sender::int_t, receiver::int_t, nnodes::int_t, nodeList::Ptr{int_t}, Lval_buf::Ptr{doublecomplex}, Uval_buf::Ptr{doublecomplex}, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function zreduceAllAncestors3d(ilvl, myNodeCount, treePerm, LUvsb, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.zreduceAllAncestors3d(ilvl::int_t, myNodeCount::Ptr{int_t}, treePerm::Ptr{Ptr{int_t}}, LUvsb::Ptr{zLUValSubBuf_t{Int32}}, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::Cint
end
function zgatherFactoredLU(sender, receiver, nnodes, nodeList, LUvsb, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.zgatherFactoredLU(sender::int_t, receiver::int_t, nnodes::int_t, nodeList::Ptr{int_t}, LUvsb::Ptr{zLUValSubBuf_t{Int32}}, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function zgatherAllFactoredLU(trf3Dpartition, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.zgatherAllFactoredLU(trf3Dpartition::Ptr{ztrf3Dpartition_t{Int32}}, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function zinit3DLUstruct(myTreeIdxs, myZeroTrIdxs, nodeCount, nodeList, LUstruct, grid3d)
@ccall libsuperlu_dist_Int32.zinit3DLUstruct(myTreeIdxs::Ptr{int_t}, myZeroTrIdxs::Ptr{int_t}, nodeCount::Ptr{int_t}, nodeList::Ptr{Ptr{int_t}}, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}})::int_t
end
function zzSendLPanel(k, receiver, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.zzSendLPanel(k::int_t, receiver::int_t, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function zzRecvLPanel(k, sender, alpha, beta, Lval_buf, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.zzRecvLPanel(k::int_t, sender::int_t, alpha::doublecomplex, beta::doublecomplex, Lval_buf::Ptr{doublecomplex}, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function zzSendUPanel(k, receiver, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.zzSendUPanel(k::int_t, receiver::int_t, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function zzRecvUPanel(k, sender, alpha, beta, Uval_buf, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int32.zzRecvUPanel(k::int_t, sender::int_t, alpha::doublecomplex, beta::doublecomplex, Uval_buf::Ptr{doublecomplex}, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, SCT::Ptr{SCT_t})::int_t
end
function zIBcast_LPanel(k, k0, lsub, lusup, arg5, msgcnt, arg7, ToSendR, xsup, arg10)
@ccall libsuperlu_dist_Int32.zIBcast_LPanel(k::int_t, k0::int_t, lsub::Ptr{int_t}, lusup::Ptr{doublecomplex}, arg5::Ptr{gridinfo_t{Int32}}, msgcnt::Ptr{Cint}, arg7::Ptr{MPI_Request}, ToSendR::Ptr{Ptr{Cint}}, xsup::Ptr{int_t}, arg10::Cint)::int_t
end
function zBcast_LPanel(k, k0, lsub, lusup, arg5, msgcnt, ToSendR, xsup, arg9, arg10)
@ccall libsuperlu_dist_Int32.zBcast_LPanel(k::int_t, k0::int_t, lsub::Ptr{int_t}, lusup::Ptr{doublecomplex}, arg5::Ptr{gridinfo_t{Int32}}, msgcnt::Ptr{Cint}, ToSendR::Ptr{Ptr{Cint}}, xsup::Ptr{int_t}, arg9::Ptr{SCT_t}, arg10::Cint)::int_t
end
function zIBcast_UPanel(k, k0, usub, uval, arg5, msgcnt, arg7, ToSendD, arg9)
@ccall libsuperlu_dist_Int32.zIBcast_UPanel(k::int_t, k0::int_t, usub::Ptr{int_t}, uval::Ptr{doublecomplex}, arg5::Ptr{gridinfo_t{Int32}}, msgcnt::Ptr{Cint}, arg7::Ptr{MPI_Request}, ToSendD::Ptr{Cint}, arg9::Cint)::int_t
end
function zBcast_UPanel(k, k0, usub, uval, arg5, msgcnt, ToSendD, arg8, arg9)
@ccall libsuperlu_dist_Int32.zBcast_UPanel(k::int_t, k0::int_t, usub::Ptr{int_t}, uval::Ptr{doublecomplex}, arg5::Ptr{gridinfo_t{Int32}}, msgcnt::Ptr{Cint}, ToSendD::Ptr{Cint}, arg8::Ptr{SCT_t}, arg9::Cint)::int_t
end
function zIrecv_LPanel(k, k0, Lsub_buf, Lval_buf, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.zIrecv_LPanel(k::int_t, k0::int_t, Lsub_buf::Ptr{int_t}, Lval_buf::Ptr{doublecomplex}, arg5::Ptr{gridinfo_t{Int32}}, arg6::Ptr{MPI_Request}, arg7::Ptr{zLocalLU_t{Int32}}, arg8::Cint)::int_t
end
function zIrecv_UPanel(k, k0, Usub_buf, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.zIrecv_UPanel(k::int_t, k0::int_t, Usub_buf::Ptr{int_t}, arg4::Ptr{doublecomplex}, arg5::Ptr{zLocalLU_t{Int32}}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{MPI_Request}, arg8::Cint)::int_t
end
function zWait_URecv(arg1, msgcnt, arg3)
@ccall libsuperlu_dist_Int32.zWait_URecv(arg1::Ptr{MPI_Request}, msgcnt::Ptr{Cint}, arg3::Ptr{SCT_t})::int_t
end
function zWait_LRecv(arg1, msgcnt, msgcntsU, arg4, arg5)
@ccall libsuperlu_dist_Int32.zWait_LRecv(arg1::Ptr{MPI_Request}, msgcnt::Ptr{Cint}, msgcntsU::Ptr{Cint}, arg4::Ptr{gridinfo_t{Int32}}, arg5::Ptr{SCT_t})::int_t
end
function zISend_UDiagBlock(k0, ublk_ptr, size, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.zISend_UDiagBlock(k0::int_t, ublk_ptr::Ptr{doublecomplex}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int32}}, arg6::Cint)::int_t
end
function zRecv_UDiagBlock(k0, ublk_ptr, size, src, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.zRecv_UDiagBlock(k0::int_t, ublk_ptr::Ptr{doublecomplex}, size::int_t, src::int_t, arg5::Ptr{gridinfo_t{Int32}}, arg6::Ptr{SCT_t}, arg7::Cint)::int_t
end
function zPackLBlock(k, Dest, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int32.zPackLBlock(k::int_t, Dest::Ptr{doublecomplex}, arg3::Ptr{Glu_persist_t}, arg4::Ptr{gridinfo_t{Int32}}, arg5::Ptr{zLocalLU_t{Int32}})::int_t
end
function zISend_LDiagBlock(k0, lblk_ptr, size, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int32.zISend_LDiagBlock(k0::int_t, lblk_ptr::Ptr{doublecomplex}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int32}}, arg6::Cint)::int_t
end
function zIRecv_UDiagBlock(k0, ublk_ptr, size, src, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.zIRecv_UDiagBlock(k0::int_t, ublk_ptr::Ptr{doublecomplex}, size::int_t, src::int_t, arg5::Ptr{MPI_Request}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{SCT_t}, arg8::Cint)::int_t
end
function zIRecv_LDiagBlock(k0, L_blk_ptr, size, src, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.zIRecv_LDiagBlock(k0::int_t, L_blk_ptr::Ptr{doublecomplex}, size::int_t, src::int_t, arg5::Ptr{MPI_Request}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{SCT_t}, arg8::Cint)::int_t
end
function zUDiagBlockRecvWait(k, IrecvPlcd_D, factored_L, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.zUDiagBlockRecvWait(k::int_t, IrecvPlcd_D::Ptr{int_t}, factored_L::Ptr{int_t}, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int32}}, arg6::Ptr{zLUstruct_t{Int32}}, arg7::Ptr{SCT_t})::int_t
end
function zIBcast_UDiagBlock(k, ublk_ptr, size, arg4, arg5)
@ccall libsuperlu_dist_Int32.zIBcast_UDiagBlock(k::int_t, ublk_ptr::Ptr{doublecomplex}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int32}})::int_t
end
function zIBcast_LDiagBlock(k, lblk_ptr, size, arg4, arg5)
@ccall libsuperlu_dist_Int32.zIBcast_LDiagBlock(k::int_t, lblk_ptr::Ptr{doublecomplex}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int32}})::int_t
end
function zDiagFactIBCast(k, k0, BlockUFactor, BlockLFactor, IrecvPlcd_D, arg6, arg7, arg8, arg9, arg10, arg11, thresh, LUstruct, arg14, info, arg16, tag_ub)
@ccall libsuperlu_dist_Int32.zDiagFactIBCast(k::int_t, k0::int_t, BlockUFactor::Ptr{doublecomplex}, BlockLFactor::Ptr{doublecomplex}, IrecvPlcd_D::Ptr{int_t}, arg6::Ptr{MPI_Request}, arg7::Ptr{MPI_Request}, arg8::Ptr{MPI_Request}, arg9::Ptr{MPI_Request}, arg10::Ptr{gridinfo_t{Int32}}, arg11::Ptr{superlu_dist_options_t}, thresh::Cdouble, LUstruct::Ptr{zLUstruct_t{Int32}}, arg14::Ptr{SuperLUStat_t{Int32}}, info::Ptr{Cint}, arg16::Ptr{SCT_t}, tag_ub::Cint)::int_t
end
function zUPanelTrSolve(k, BlockLFactor, bigV, ldt, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int32.zUPanelTrSolve(k::int_t, BlockLFactor::Ptr{doublecomplex}, bigV::Ptr{doublecomplex}, ldt::int_t, arg5::Ptr{Ublock_info_t}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{zLUstruct_t{Int32}}, arg8::Ptr{SuperLUStat_t{Int32}}, arg9::Ptr{SCT_t})::int_t
end
function zLPanelUpdate(k, IrecvPlcd_D, factored_L, arg4, BlockUFactor, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.zLPanelUpdate(k::int_t, IrecvPlcd_D::Ptr{int_t}, factored_L::Ptr{int_t}, arg4::Ptr{MPI_Request}, BlockUFactor::Ptr{doublecomplex}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{zLUstruct_t{Int32}}, arg8::Ptr{SCT_t})::int_t
end
function zUPanelUpdate(k, factored_U, arg3, BlockLFactor, bigV, ldt, arg7, arg8, arg9, arg10, arg11)
@ccall libsuperlu_dist_Int32.zUPanelUpdate(k::int_t, factored_U::Ptr{int_t}, arg3::Ptr{MPI_Request}, BlockLFactor::Ptr{doublecomplex}, bigV::Ptr{doublecomplex}, ldt::int_t, arg7::Ptr{Ublock_info_t}, arg8::Ptr{gridinfo_t{Int32}}, arg9::Ptr{zLUstruct_t{Int32}}, arg10::Ptr{SuperLUStat_t{Int32}}, arg11::Ptr{SCT_t})::int_t
end
function zIBcastRecvLPanel(k, k0, msgcnt, arg4, arg5, Lsub_buf, Lval_buf, factored, arg9, arg10, arg11, tag_ub)
@ccall libsuperlu_dist_Int32.zIBcastRecvLPanel(k::int_t, k0::int_t, msgcnt::Ptr{Cint}, arg4::Ptr{MPI_Request}, arg5::Ptr{MPI_Request}, Lsub_buf::Ptr{int_t}, Lval_buf::Ptr{doublecomplex}, factored::Ptr{int_t}, arg9::Ptr{gridinfo_t{Int32}}, arg10::Ptr{zLUstruct_t{Int32}}, arg11::Ptr{SCT_t}, tag_ub::Cint)::int_t
end
function zIBcastRecvUPanel(k, k0, msgcnt, arg4, arg5, Usub_buf, Uval_buf, arg8, arg9, arg10, tag_ub)
@ccall libsuperlu_dist_Int32.zIBcastRecvUPanel(k::int_t, k0::int_t, msgcnt::Ptr{Cint}, arg4::Ptr{MPI_Request}, arg5::Ptr{MPI_Request}, Usub_buf::Ptr{int_t}, Uval_buf::Ptr{doublecomplex}, arg8::Ptr{gridinfo_t{Int32}}, arg9::Ptr{zLUstruct_t{Int32}}, arg10::Ptr{SCT_t}, tag_ub::Cint)::int_t
end
function zWaitL(k, msgcnt, msgcntU, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int32.zWaitL(k::int_t, msgcnt::Ptr{Cint}, msgcntU::Ptr{Cint}, arg4::Ptr{MPI_Request}, arg5::Ptr{MPI_Request}, arg6::Ptr{gridinfo_t{Int32}}, arg7::Ptr{zLUstruct_t{Int32}}, arg8::Ptr{SCT_t})::int_t
end
function zWaitU(k, msgcnt, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.zWaitU(k::int_t, msgcnt::Ptr{Cint}, arg3::Ptr{MPI_Request}, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int32}}, arg6::Ptr{zLUstruct_t{Int32}}, arg7::Ptr{SCT_t})::int_t
end
function zLPanelTrSolve(k, factored_L, BlockUFactor, arg4, arg5)
@ccall libsuperlu_dist_Int32.zLPanelTrSolve(k::int_t, factored_L::Ptr{int_t}, BlockUFactor::Ptr{doublecomplex}, arg4::Ptr{gridinfo_t{Int32}}, arg5::Ptr{zLUstruct_t{Int32}})::int_t
end
function zSchurComplementSetup(k, msgcnt, arg3, arg4, arg5, arg6, arg7, arg8, arg9, bigU, Lsub_buf, Lval_buf, Usub_buf, Uval_buf, arg15, arg16)
@ccall libsuperlu_dist_Int32.zSchurComplementSetup(k::int_t, msgcnt::Ptr{Cint}, arg3::Ptr{Ublock_info_t}, arg4::Ptr{Remain_info_t}, arg5::Ptr{uPanelInfo_t{Int32}}, arg6::Ptr{lPanelInfo_t{Int32}}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{int_t}, bigU::Ptr{doublecomplex}, Lsub_buf::Ptr{int_t}, Lval_buf::Ptr{doublecomplex}, Usub_buf::Ptr{int_t}, Uval_buf::Ptr{doublecomplex}, arg15::Ptr{gridinfo_t{Int32}}, arg16::Ptr{zLUstruct_t{Int32}})::int_t
end
function zSchurComplementSetupGPU(k, msgs, arg3, arg4, arg5, arg6, arg7, arg8, arg9, LUvsb, arg11, arg12, arg13)
@ccall libsuperlu_dist_Int32.zSchurComplementSetupGPU(k::int_t, msgs::Ptr{msgs_t}, arg3::Ptr{packLUInfo_t{Int32}}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{int_t}, arg7::Ptr{gEtreeInfo_t{Int32}}, arg8::Ptr{factNodelists_t{Int32}}, arg9::Ptr{zscuBufs_t}, LUvsb::Ptr{zLUValSubBuf_t{Int32}}, arg11::Ptr{gridinfo_t{Int32}}, arg12::Ptr{zLUstruct_t{Int32}}, arg13::Ptr{HyP_t})::int_t
end
function zgetBigV(arg1, arg2)
@ccall libsuperlu_dist_Int32.zgetBigV(arg1::int_t, arg2::int_t)::Ptr{doublecomplex}
end
function zgetBigU(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int32.zgetBigU(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{gridinfo_t{Int32}}, arg4::Ptr{zLUstruct_t{Int32}})::Ptr{doublecomplex}
end
function zLluBufInit(arg1, arg2)
@ccall libsuperlu_dist_Int32.zLluBufInit(arg1::Ptr{zLUValSubBuf_t{Int32}}, arg2::Ptr{zLUstruct_t{Int32}})::int_t
end
function zinitScuBufs(arg1, ldt, num_threads, nsupers, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int32.zinitScuBufs(arg1::Ptr{superlu_dist_options_t}, ldt::int_t, num_threads::int_t, nsupers::int_t, arg5::Ptr{zscuBufs_t}, arg6::Ptr{zLUstruct_t{Int32}}, arg7::Ptr{gridinfo_t{Int32}})::int_t
end
function zfreeScuBufs(scuBufs)
@ccall libsuperlu_dist_Int32.zfreeScuBufs(scuBufs::Ptr{zscuBufs_t})::Cint
end
function zsparseTreeFactor(nnodes, perm_c_supno, treeTopoInfo, comReqs, scuBufs, packLUInfo, msgs, LUvsb, dFBuf, factStat, fNlists, options, gIperm_c_supno, ldt, LUstruct, grid3d, stat, thresh, SCT, info)
@ccall libsuperlu_dist_Int32.zsparseTreeFactor(nnodes::int_t, perm_c_supno::Ptr{int_t}, treeTopoInfo::Ptr{treeTopoInfo_t{Int32}}, comReqs::Ptr{commRequests_t}, scuBufs::Ptr{zscuBufs_t}, packLUInfo::Ptr{packLUInfo_t{Int32}}, msgs::Ptr{msgs_t}, LUvsb::Ptr{zLUValSubBuf_t{Int32}}, dFBuf::Ptr{zdiagFactBufs_t}, factStat::Ptr{factStat_t{Int32}}, fNlists::Ptr{factNodelists_t{Int32}}, options::Ptr{superlu_dist_options_t}, gIperm_c_supno::Ptr{int_t}, ldt::int_t, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, stat::Ptr{SuperLUStat_t{Int32}}, thresh::Cdouble, SCT::Ptr{SCT_t}, info::Ptr{Cint})::int_t
end
function zdenseTreeFactor(nnnodes, perm_c_supno, comReqs, scuBufs, packLUInfo, msgs, LUvsb, dFBuf, factStat, fNlists, options, gIperm_c_supno, ldt, LUstruct, grid3d, stat, thresh, SCT, tag_ub, info)
@ccall libsuperlu_dist_Int32.zdenseTreeFactor(nnnodes::int_t, perm_c_supno::Ptr{int_t}, comReqs::Ptr{commRequests_t}, scuBufs::Ptr{zscuBufs_t}, packLUInfo::Ptr{packLUInfo_t{Int32}}, msgs::Ptr{msgs_t}, LUvsb::Ptr{zLUValSubBuf_t{Int32}}, dFBuf::Ptr{zdiagFactBufs_t}, factStat::Ptr{factStat_t{Int32}}, fNlists::Ptr{factNodelists_t{Int32}}, options::Ptr{superlu_dist_options_t}, gIperm_c_supno::Ptr{int_t}, ldt::int_t, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, stat::Ptr{SuperLUStat_t{Int32}}, thresh::Cdouble, SCT::Ptr{SCT_t}, tag_ub::Cint, info::Ptr{Cint})::int_t
end
function zsparseTreeFactor_ASYNC(sforest, comReqss, scuBufs, packLUInfo, msgss, LUvsbs, dFBufs, factStat, fNlists, gEtreeInfo, options, gIperm_c_supno, ldt, HyP, LUstruct, grid3d, stat, thresh, SCT, tag_ub, info)
@ccall libsuperlu_dist_Int32.zsparseTreeFactor_ASYNC(sforest::Ptr{sForest_t{Int32}}, comReqss::Ptr{Ptr{commRequests_t}}, scuBufs::Ptr{zscuBufs_t}, packLUInfo::Ptr{packLUInfo_t{Int32}}, msgss::Ptr{Ptr{msgs_t}}, LUvsbs::Ptr{Ptr{zLUValSubBuf_t{Int32}}}, dFBufs::Ptr{Ptr{zdiagFactBufs_t}}, factStat::Ptr{factStat_t{Int32}}, fNlists::Ptr{factNodelists_t{Int32}}, gEtreeInfo::Ptr{gEtreeInfo_t{Int32}}, options::Ptr{superlu_dist_options_t}, gIperm_c_supno::Ptr{int_t}, ldt::int_t, HyP::Ptr{HyP_t}, LUstruct::Ptr{zLUstruct_t{Int32}}, grid3d::Ptr{gridinfo3d_t{Int32}}, stat::Ptr{SuperLUStat_t{Int32}}, thresh::Cdouble, SCT::Ptr{SCT_t}, tag_ub::Cint, info::Ptr{Cint})::int_t
end
function zLluBufInitArr(numLA, LUstruct)
@ccall libsuperlu_dist_Int32.zLluBufInitArr(numLA::int_t, LUstruct::Ptr{zLUstruct_t{Int32}})::Ptr{Ptr{zLUValSubBuf_t{Int32}}}
end
function zLluBufFreeArr(numLA, LUvsbs)
@ccall libsuperlu_dist_Int32.zLluBufFreeArr(numLA::int_t, LUvsbs::Ptr{Ptr{zLUValSubBuf_t{Int32}}})::Cint
end
function zinitDiagFactBufsArr(mxLeafNode, ldt, grid)
@ccall libsuperlu_dist_Int32.zinitDiagFactBufsArr(mxLeafNode::int_t, ldt::int_t, grid::Ptr{gridinfo_t{Int32}})::Ptr{Ptr{zdiagFactBufs_t}}
end
function zfreeDiagFactBufsArr(mxLeafNode, dFBufs)
@ccall libsuperlu_dist_Int32.zfreeDiagFactBufsArr(mxLeafNode::int_t, dFBufs::Ptr{Ptr{zdiagFactBufs_t}})::Cint
end
function zinitDiagFactBufs(ldt, dFBuf)
@ccall libsuperlu_dist_Int32.zinitDiagFactBufs(ldt::int_t, dFBuf::Ptr{zdiagFactBufs_t})::int_t
end
const SUPERLU_DIST_MAJOR_VERSION = 8
const SUPERLU_DIST_MINOR_VERSION = 1
const SUPERLU_DIST_PATCH_VERSION = 2
const SUPERLU_DIST_RELEASE_DATE = "November 12, 2022"
const TRUE = 1
const HAVE_PARMETIS = TRUE
const XSDK_INDEX_SIZE = 32
const _LONGINT = 0
const EMPTY = -1
const FALSE = 0
const MAX_3D_LEVEL = 32
const CBLOCK = 192
const CACHE_LINE_SIZE = 8
const CSTEPPING = 8
const NO_MARKER = 3
const tag_interLvl = 2
const tag_interLvl_LData = 0
const tag_interLvl_UData = 1
const tag_intraLvl_szMsg = 1000
const tag_intraLvl_LData = 1001
const tag_intraLvl_UData = 1002
const tag_intraLvl = 1003
const DIAG_IND = 0
const NELTS_IND = 1
const RCVD_IND = 2
const SUCCES_RET = 0
const ERROR_RET = 1
const FILLED_SEP = 2
const FILLED_SEPS = 3
const USUB_PR = 0
const LSUB_PR = 1
const RL_SYMB = 0
const DOMAIN_SYMB = 1
const LL_SYMB = 2
const DNS_UPSEPS = 3
const DNS_CURSEP = 4
const MAX_SUPER_SIZE = 512
const BC_HEADER = 2
const LB_DESCRIPTOR = 2
const BR_HEADER = 3
const UB_DESCRIPTOR = 2
const BC_HEADER_NEWU = 3
const UB_DESCRIPTOR_NEWU = 2
const NBUFFERS = 5
const UjROW = 10
const UkSUB = 11
const UkVAL = 12
const LkSUB = 13
const LkVAL = 14
const LkkDIAG = 15
const GSUM = 20
const Xk = 21
const Yk = 22
const LSUM = 23
const COMM_ALL = 100
const COMM_COLUMN = 101
const COMM_ROW = 102
const SUPER_LINEAR = 11
const SUPER_BLOCK = 12
const DIM_X = 16
const DIM_Y = 16
const BLK_M = DIM_X * 4
const BLK_N = DIM_Y * 4
const BLK_K = 2048 ÷ BLK_M
const DIM_XA = DIM_X
const DIM_YA = DIM_Y
const DIM_XB = DIM_X
const DIM_YB = DIM_Y
const NWARP = (DIM_X * DIM_Y) ÷ 32
const THR_M = BLK_M ÷ DIM_X
const THR_N = BLK_N ÷ DIM_Y
const DEG_TREE = 2
const MAX_LOOKAHEADS = 50
end
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 209991 | module SuperLU_Int64
import MPI: MPI_Comm, MPI_Request, MPI_Datatype, MPI_Errhandler
using SuperLU_DIST_jll
using ..SuperLUDIST_Common
import ..SuperLUDIST: libsuperlu_dist_Int64
using SuperLUBase.Common
function superlu_abort_and_exit_dist(arg1)
@ccall libsuperlu_dist_Int64.superlu_abort_and_exit_dist(arg1::Ptr{Cchar})::Cvoid
end
function superlu_malloc_dist(arg1)
@ccall libsuperlu_dist_Int64.superlu_malloc_dist(arg1::Csize_t)::Ptr{Cvoid}
end
function superlu_free_dist(arg1)
@ccall libsuperlu_dist_Int64.superlu_free_dist(arg1::Ptr{Cvoid})::Cvoid
end
const int_t = Int64
function scuStatUpdate(knsupc, HyP, SCT, stat)
@ccall libsuperlu_dist_Int64.scuStatUpdate(knsupc::int_t, HyP::Ptr{HyP_t}, SCT::Ptr{SCT_t}, stat::Ptr{SuperLUStat_t{Int64}})::int_t
end
function dCreate_CompCol_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int64.dCreate_CompCol_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{Cdouble}, arg6::Ptr{int_t}, arg7::Ptr{int_t}, arg8::Stype_t, arg9::Dtype_t, arg10::Mtype_t)::Cvoid
end
function dCreate_CompRowLoc_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int64.dCreate_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::int_t, arg6::int_t, arg7::Ptr{Cdouble}, arg8::Ptr{int_t}, arg9::Ptr{int_t}, arg10::Stype_t, arg11::Dtype_t, arg12::Mtype_t)::Cvoid
end
function dCompRow_to_CompCol_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.dCompRow_to_CompCol_dist(arg1::int_t, arg2::int_t, arg3::int_t, arg4::Ptr{Cdouble}, arg5::Ptr{int_t}, arg6::Ptr{int_t}, arg7::Ptr{Ptr{Cdouble}}, arg8::Ptr{Ptr{int_t}}, arg9::Ptr{Ptr{int_t}})::Cvoid
end
function pdCompRow_loc_to_CompCol_global(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.pdCompRow_loc_to_CompCol_global(arg1::int_t, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{SuperMatrix{Int64}})::Cint
end
function dCopy_CompCol_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int64.dCopy_CompCol_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{SuperMatrix{Int64}})::Cvoid
end
function dCreate_Dense_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.dCreate_Dense_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::int_t, arg3::int_t, arg4::Ptr{Cdouble}, arg5::int_t, arg6::Stype_t, arg7::Dtype_t, arg8::Mtype_t)::Cvoid
end
function dCreate_SuperNode_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13)
@ccall libsuperlu_dist_Int64.dCreate_SuperNode_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{Cdouble}, arg6::Ptr{int_t}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{int_t}, arg10::Ptr{int_t}, arg11::Stype_t, arg12::Dtype_t, arg13::Mtype_t)::Cvoid
end
function dCopy_Dense_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.dCopy_Dense_Matrix_dist(arg1::int_t, arg2::int_t, arg3::Ptr{Cdouble}, arg4::int_t, arg5::Ptr{Cdouble}, arg6::int_t)::Cvoid
end
function dallocateA_dist(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int64.dallocateA_dist(arg1::int_t, arg2::int_t, arg3::Ptr{Ptr{Cdouble}}, arg4::Ptr{Ptr{int_t}}, arg5::Ptr{Ptr{int_t}})::Cvoid
end
function dGenXtrue_dist(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.dGenXtrue_dist(arg1::int_t, arg2::int_t, arg3::Ptr{Cdouble}, arg4::int_t)::Cvoid
end
function dFillRHS_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.dFillRHS_dist(arg1::Ptr{Cchar}, arg2::int_t, arg3::Ptr{Cdouble}, arg4::int_t, arg5::Ptr{SuperMatrix{Int64}}, arg6::Ptr{Cdouble}, arg7::int_t)::Cvoid
end
function dcreate_matrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.dcreate_matrix(arg1::Ptr{SuperMatrix{Int64}}, arg2::Cint, arg3::Ptr{Ptr{Cdouble}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{Cdouble}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{gridinfo_t{Int64}})::Cint
end
function dcreate_matrix_rb(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.dcreate_matrix_rb(arg1::Ptr{SuperMatrix{Int64}}, arg2::Cint, arg3::Ptr{Ptr{Cdouble}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{Cdouble}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{gridinfo_t{Int64}})::Cint
end
function dcreate_matrix_dat(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.dcreate_matrix_dat(arg1::Ptr{SuperMatrix{Int64}}, arg2::Cint, arg3::Ptr{Ptr{Cdouble}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{Cdouble}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{gridinfo_t{Int64}})::Cint
end
function dcreate_matrix_postfix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.dcreate_matrix_postfix(arg1::Ptr{SuperMatrix{Int64}}, arg2::Cint, arg3::Ptr{Ptr{Cdouble}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{Cdouble}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{Cchar}, arg9::Ptr{gridinfo_t{Int64}})::Cint
end
function dScalePermstructInit(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.dScalePermstructInit(arg1::int_t, arg2::int_t, arg3::Ptr{dScalePermstruct_t{Int64}})::Cvoid
end
function dScalePermstructFree(arg1)
@ccall libsuperlu_dist_Int64.dScalePermstructFree(arg1::Ptr{dScalePermstruct_t{Int64}})::Cvoid
end
function dgsequ_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.dgsequ_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble}, arg7::Ptr{int_t})::Cvoid
end
function dlangs_dist(arg1, arg2)
@ccall libsuperlu_dist_Int64.dlangs_dist(arg1::Ptr{Cchar}, arg2::Ptr{SuperMatrix{Int64}})::Cdouble
end
function dlaqgs_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.dlaqgs_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Cdouble, arg5::Cdouble, arg6::Cdouble, arg7::Ptr{Cchar})::Cvoid
end
function pdgsequ(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.pdgsequ(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble}, arg7::Ptr{int_t}, arg8::Ptr{gridinfo_t{Int64}})::Cvoid
end
function pdlangs(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.pdlangs(arg1::Ptr{Cchar}, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{gridinfo_t{Int64}})::Cdouble
end
function pdlaqgs(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.pdlaqgs(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Cdouble, arg5::Cdouble, arg6::Cdouble, arg7::Ptr{Cchar})::Cvoid
end
function pdPermute_Dense_Matrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int64.pdPermute_Dense_Matrix(arg1::int_t, arg2::int_t, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Cdouble}, arg6::Cint, arg7::Ptr{Cdouble}, arg8::Cint, arg9::Cint, arg10::Ptr{gridinfo_t{Int64}})::Cint
end
function sp_dtrsv_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.sp_dtrsv_dist(arg1::Ptr{Cchar}, arg2::Ptr{Cchar}, arg3::Ptr{Cchar}, arg4::Ptr{SuperMatrix{Int64}}, arg5::Ptr{SuperMatrix{Int64}}, arg6::Ptr{Cdouble}, arg7::Ptr{Cint})::Cint
end
function sp_dgemv_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.sp_dgemv_dist(arg1::Ptr{Cchar}, arg2::Cdouble, arg3::Ptr{SuperMatrix{Int64}}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cdouble, arg7::Ptr{Cdouble}, arg8::Cint)::Cint
end
function sp_dgemm_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.sp_dgemm_dist(arg1::Ptr{Cchar}, arg2::Cint, arg3::Cdouble, arg4::Ptr{SuperMatrix{Int64}}, arg5::Ptr{Cdouble}, arg6::Cint, arg7::Cdouble, arg8::Ptr{Cdouble}, arg9::Cint)::Cint
end
function ddistribute(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.ddistribute(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int64}}, arg4::Ptr{Glu_freeable_t{Int64}}, arg5::Ptr{dLUstruct_t{Int64}}, arg6::Ptr{gridinfo_t{Int64}})::Cfloat
end
function pdgssvx_ABglobal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
@ccall libsuperlu_dist_Int64.pdgssvx_ABglobal(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{dScalePermstruct_t{Int64}}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::Ptr{gridinfo_t{Int64}}, arg8::Ptr{dLUstruct_t{Int64}}, arg9::Ptr{Cdouble}, arg10::Ptr{SuperLUStat_t{Int64}}, arg11::Ptr{Cint})::Cvoid
end
function pddistribute(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.pddistribute(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int64}}, arg4::Ptr{dScalePermstruct_t{Int64}}, arg5::Ptr{Glu_freeable_t{Int64}}, arg6::Ptr{dLUstruct_t{Int64}}, arg7::Ptr{gridinfo_t{Int64}})::Cfloat
end
function pdgssvx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int64.pdgssvx(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{dScalePermstruct_t{Int64}}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::Ptr{gridinfo_t{Int64}}, arg8::Ptr{dLUstruct_t{Int64}}, arg9::Ptr{dSOLVEstruct_t{Int64}}, arg10::Ptr{Cdouble}, arg11::Ptr{SuperLUStat_t{Int64}}, arg12::Ptr{Cint})::Cvoid
end
function pdCompute_Diag_Inv(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int64.pdCompute_Diag_Inv(arg1::int_t, arg2::Ptr{dLUstruct_t{Int64}}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{SuperLUStat_t{Int64}}, arg5::Ptr{Cint})::Cvoid
end
function dSolveInit(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.dSolveInit(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::int_t, arg6::Ptr{dLUstruct_t{Int64}}, arg7::Ptr{gridinfo_t{Int64}}, arg8::Ptr{dSOLVEstruct_t{Int64}})::Cint
end
function dSolveFinalize(arg1, arg2)
@ccall libsuperlu_dist_Int64.dSolveFinalize(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{dSOLVEstruct_t{Int64}})::Cvoid
end
function dDestroy_A3d_gathered_on_2d(arg1, arg2)
@ccall libsuperlu_dist_Int64.dDestroy_A3d_gathered_on_2d(arg1::Ptr{dSOLVEstruct_t{Int64}}, arg2::Ptr{gridinfo3d_t{Int64}})::Cvoid
end
function pdgstrs_init(arg1, arg2, arg3, arg4, arg5, arg6, grid, arg8, arg9)
@ccall libsuperlu_dist_Int64.pdgstrs_init(arg1::int_t, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{int_t}, arg6::Ptr{int_t}, grid::Ptr{gridinfo_t{Int64}}, arg8::Ptr{Glu_persist_t}, arg9::Ptr{dSOLVEstruct_t{Int64}})::int_t
end
function pxgstrs_finalize(arg1)
@ccall libsuperlu_dist_Int64.pxgstrs_finalize(arg1::Ptr{pxgstrs_comm_t})::Cvoid
end
function dldperm_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.dldperm_dist(arg1::Cint, arg2::Cint, arg3::int_t, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{Cdouble}, arg7::Ptr{int_t}, arg8::Ptr{Cdouble}, arg9::Ptr{Cdouble})::Cint
end
function dstatic_schedule(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.dstatic_schedule(arg1::Ptr{superlu_dist_options_t}, arg2::Cint, arg3::Cint, arg4::Ptr{dLUstruct_t{Int64}}, arg5::Ptr{gridinfo_t{Int64}}, arg6::Ptr{SuperLUStat_t{Int64}}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{Cint})::Cint
end
function dLUstructInit(arg1, arg2)
@ccall libsuperlu_dist_Int64.dLUstructInit(arg1::int_t, arg2::Ptr{dLUstruct_t{Int64}})::Cvoid
end
function dLUstructFree(arg1)
@ccall libsuperlu_dist_Int64.dLUstructFree(arg1::Ptr{dLUstruct_t{Int64}})::Cvoid
end
function dDestroy_LU(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.dDestroy_LU(arg1::int_t, arg2::Ptr{gridinfo_t{Int64}}, arg3::Ptr{dLUstruct_t{Int64}})::Cvoid
end
function dDestroy_Tree(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.dDestroy_Tree(arg1::int_t, arg2::Ptr{gridinfo_t{Int64}}, arg3::Ptr{dLUstruct_t{Int64}})::Cvoid
end
function dscatter_l(ib, ljb, nsupc, iukp, xsup, klst, nbrow, lptr, temp_nbrow, usub, lsub, tempv, indirect_thread, indirect2, Lrowind_bc_ptr, Lnzval_bc_ptr, grid)
@ccall libsuperlu_dist_Int64.dscatter_l(ib::Cint, ljb::Cint, nsupc::Cint, iukp::int_t, xsup::Ptr{int_t}, klst::Cint, nbrow::Cint, lptr::int_t, temp_nbrow::Cint, usub::Ptr{int_t}, lsub::Ptr{int_t}, tempv::Ptr{Cdouble}, indirect_thread::Ptr{Cint}, indirect2::Ptr{Cint}, Lrowind_bc_ptr::Ptr{Ptr{int_t}}, Lnzval_bc_ptr::Ptr{Ptr{Cdouble}}, grid::Ptr{gridinfo_t{Int64}})::Cvoid
end
function dscatter_u(ib, jb, nsupc, iukp, xsup, klst, nbrow, lptr, temp_nbrow, lsub, usub, tempv, Ufstnz_br_ptr, Unzval_br_ptr, grid)
@ccall libsuperlu_dist_Int64.dscatter_u(ib::Cint, jb::Cint, nsupc::Cint, iukp::int_t, xsup::Ptr{int_t}, klst::Cint, nbrow::Cint, lptr::int_t, temp_nbrow::Cint, lsub::Ptr{int_t}, usub::Ptr{int_t}, tempv::Ptr{Cdouble}, Ufstnz_br_ptr::Ptr{Ptr{int_t}}, Unzval_br_ptr::Ptr{Ptr{Cdouble}}, grid::Ptr{gridinfo_t{Int64}})::Cvoid
end
function pdgstrf(arg1, arg2, arg3, anorm, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.pdgstrf(arg1::Ptr{superlu_dist_options_t}, arg2::Cint, arg3::Cint, anorm::Cdouble, arg5::Ptr{dLUstruct_t{Int64}}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{SuperLUStat_t{Int64}}, arg8::Ptr{Cint})::int_t
end
function pdgstrs_Bglobal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.pdgstrs_Bglobal(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{dLUstruct_t{Int64}}, arg4::Ptr{gridinfo_t{Int64}}, arg5::Ptr{Cdouble}, arg6::int_t, arg7::Cint, arg8::Ptr{SuperLUStat_t{Int64}}, arg9::Ptr{Cint})::Cvoid
end
function pdgstrs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13)
@ccall libsuperlu_dist_Int64.pdgstrs(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{dLUstruct_t{Int64}}, arg4::Ptr{dScalePermstruct_t{Int64}}, arg5::Ptr{gridinfo_t{Int64}}, arg6::Ptr{Cdouble}, arg7::int_t, arg8::int_t, arg9::int_t, arg10::Cint, arg11::Ptr{dSOLVEstruct_t{Int64}}, arg12::Ptr{SuperLUStat_t{Int64}}, arg13::Ptr{Cint})::Cvoid
end
function pdgstrf2_trsm(options, k0, k, thresh, arg5, arg6, arg7, arg8, tag_ub, arg10, info)
@ccall libsuperlu_dist_Int64.pdgstrf2_trsm(options::Ptr{superlu_dist_options_t}, k0::int_t, k::int_t, thresh::Cdouble, arg5::Ptr{Glu_persist_t}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{dLocalLU_t{Int64}}, arg8::Ptr{MPI_Request}, tag_ub::Cint, arg10::Ptr{SuperLUStat_t{Int64}}, info::Ptr{Cint})::Cvoid
end
function pdgstrs2_omp(k0, k, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.pdgstrs2_omp(k0::int_t, k::int_t, arg3::Ptr{Glu_persist_t}, arg4::Ptr{gridinfo_t{Int64}}, arg5::Ptr{dLocalLU_t{Int64}}, arg6::Ptr{Ublock_info_t}, arg7::Ptr{SuperLUStat_t{Int64}})::Cvoid
end
function pdReDistribute_B_to_X(B, m_loc, nrhs, ldb, fst_row, ilsum, x, arg8, arg9, arg10, arg11)
@ccall libsuperlu_dist_Int64.pdReDistribute_B_to_X(B::Ptr{Cdouble}, m_loc::int_t, nrhs::Cint, ldb::int_t, fst_row::int_t, ilsum::Ptr{int_t}, x::Ptr{Cdouble}, arg8::Ptr{dScalePermstruct_t{Int64}}, arg9::Ptr{Glu_persist_t}, arg10::Ptr{gridinfo_t{Int64}}, arg11::Ptr{dSOLVEstruct_t{Int64}})::int_t
end
function dlsum_fmod(arg1, arg2, arg3, arg4, arg5, arg6, arg7, fmod, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16)
@ccall libsuperlu_dist_Int64.dlsum_fmod(arg1::Ptr{Cdouble}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::int_t, fmod::Ptr{Cint}, arg9::int_t, arg10::int_t, arg11::int_t, arg12::Ptr{int_t}, arg13::Ptr{gridinfo_t{Int64}}, arg14::Ptr{dLocalLU_t{Int64}}, arg15::Ptr{MPI_Request}, arg16::Ptr{SuperLUStat_t{Int64}})::Cvoid
end
function dlsum_bmod(arg1, arg2, arg3, arg4, arg5, bmod, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14)
@ccall libsuperlu_dist_Int64.dlsum_bmod(arg1::Ptr{Cdouble}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Cint, arg5::int_t, bmod::Ptr{Cint}, arg7::Ptr{int_t}, arg8::Ptr{Ptr{Ucb_indptr_t}}, arg9::Ptr{Ptr{int_t}}, arg10::Ptr{int_t}, arg11::Ptr{gridinfo_t{Int64}}, arg12::Ptr{dLocalLU_t{Int64}}, arg13::Ptr{MPI_Request}, arg14::Ptr{SuperLUStat_t{Int64}})::Cvoid
end
function dlsum_fmod_inv(arg1, arg2, arg3, arg4, arg5, arg6, fmod, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19)
@ccall libsuperlu_dist_Int64.dlsum_fmod_inv(arg1::Ptr{Cdouble}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::int_t, fmod::Ptr{Cint}, arg8::Ptr{int_t}, arg9::Ptr{gridinfo_t{Int64}}, arg10::Ptr{dLocalLU_t{Int64}}, arg11::Ptr{Ptr{SuperLUStat_t{Int64}}}, arg12::Ptr{int_t}, arg13::Ptr{int_t}, arg14::int_t, arg15::int_t, arg16::int_t, arg17::int_t, arg18::Cint, arg19::Cint)::Cvoid
end
function dlsum_fmod_inv_master(arg1, arg2, arg3, arg4, arg5, arg6, arg7, fmod, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19)
@ccall libsuperlu_dist_Int64.dlsum_fmod_inv_master(arg1::Ptr{Cdouble}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::int_t, fmod::Ptr{Cint}, arg9::int_t, arg10::Ptr{int_t}, arg11::Ptr{gridinfo_t{Int64}}, arg12::Ptr{dLocalLU_t{Int64}}, arg13::Ptr{Ptr{SuperLUStat_t{Int64}}}, arg14::int_t, arg15::int_t, arg16::int_t, arg17::int_t, arg18::Cint, arg19::Cint)::Cvoid
end
function dlsum_bmod_inv(arg1, arg2, arg3, arg4, arg5, arg6, bmod, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20)
@ccall libsuperlu_dist_Int64.dlsum_bmod_inv(arg1::Ptr{Cdouble}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::int_t, bmod::Ptr{Cint}, arg8::Ptr{int_t}, arg9::Ptr{Ptr{Ucb_indptr_t}}, arg10::Ptr{Ptr{int_t}}, arg11::Ptr{int_t}, arg12::Ptr{gridinfo_t{Int64}}, arg13::Ptr{dLocalLU_t{Int64}}, arg14::Ptr{Ptr{SuperLUStat_t{Int64}}}, arg15::Ptr{int_t}, arg16::Ptr{int_t}, arg17::int_t, arg18::int_t, arg19::Cint, arg20::Cint)::Cvoid
end
function dlsum_bmod_inv_master(arg1, arg2, arg3, arg4, arg5, arg6, bmod, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18)
@ccall libsuperlu_dist_Int64.dlsum_bmod_inv_master(arg1::Ptr{Cdouble}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::int_t, bmod::Ptr{Cint}, arg8::Ptr{int_t}, arg9::Ptr{Ptr{Ucb_indptr_t}}, arg10::Ptr{Ptr{int_t}}, arg11::Ptr{int_t}, arg12::Ptr{gridinfo_t{Int64}}, arg13::Ptr{dLocalLU_t{Int64}}, arg14::Ptr{Ptr{SuperLUStat_t{Int64}}}, arg15::int_t, arg16::int_t, arg17::Cint, arg18::Cint)::Cvoid
end
function dComputeLevelsets(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.dComputeLevelsets(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{dLocalLU_t{Int64}}, arg6::Ptr{int_t})::Cvoid
end
function pdgsrfs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16)
@ccall libsuperlu_dist_Int64.pdgsrfs(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int64}}, arg4::Cdouble, arg5::Ptr{dLUstruct_t{Int64}}, arg6::Ptr{dScalePermstruct_t{Int64}}, arg7::Ptr{gridinfo_t{Int64}}, arg8::Ptr{Cdouble}, arg9::int_t, arg10::Ptr{Cdouble}, arg11::int_t, arg12::Cint, arg13::Ptr{dSOLVEstruct_t{Int64}}, arg14::Ptr{Cdouble}, arg15::Ptr{SuperLUStat_t{Int64}}, arg16::Ptr{Cint})::Cvoid
end
function pdgsrfs_ABXglobal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14)
@ccall libsuperlu_dist_Int64.pdgsrfs_ABXglobal(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int64}}, arg4::Cdouble, arg5::Ptr{dLUstruct_t{Int64}}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{Cdouble}, arg8::int_t, arg9::Ptr{Cdouble}, arg10::int_t, arg11::Cint, arg12::Ptr{Cdouble}, arg13::Ptr{SuperLUStat_t{Int64}}, arg14::Ptr{Cint})::Cvoid
end
function pdgsmv_AXglobal_setup(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.pdgsmv_AXglobal_setup(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{Glu_persist_t}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{int_t}}, arg6::Ptr{Ptr{Cdouble}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{int_t})::Cint
end
function pdgsmv_AXglobal(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.pdgsmv_AXglobal(arg1::int_t, arg2::Ptr{int_t}, arg3::Ptr{Cdouble}, arg4::Ptr{int_t}, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble})::Cint
end
function pdgsmv_AXglobal_abs(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.pdgsmv_AXglobal_abs(arg1::int_t, arg2::Ptr{int_t}, arg3::Ptr{Cdouble}, arg4::Ptr{int_t}, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble})::Cint
end
function pdgsmv_init(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.pdgsmv_init(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{int_t}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{pdgsmv_comm_t})::Cvoid
end
function pdgsmv(arg1, arg2, arg3, arg4, x, ax)
@ccall libsuperlu_dist_Int64.pdgsmv(arg1::int_t, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{pdgsmv_comm_t}, x::Ptr{Cdouble}, ax::Ptr{Cdouble})::Cvoid
end
function pdgsmv_finalize(arg1)
@ccall libsuperlu_dist_Int64.pdgsmv_finalize(arg1::Ptr{pdgsmv_comm_t})::Cvoid
end
function doubleMalloc_dist(arg1)
@ccall libsuperlu_dist_Int64.doubleMalloc_dist(arg1::int_t)::Ptr{Cdouble}
end
function doubleCalloc_dist(arg1)
@ccall libsuperlu_dist_Int64.doubleCalloc_dist(arg1::int_t)::Ptr{Cdouble}
end
function duser_malloc_dist(arg1, arg2)
@ccall libsuperlu_dist_Int64.duser_malloc_dist(arg1::int_t, arg2::int_t)::Ptr{Cvoid}
end
function duser_free_dist(arg1, arg2)
@ccall libsuperlu_dist_Int64.duser_free_dist(arg1::int_t, arg2::int_t)::Cvoid
end
function dQuerySpace_dist(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int64.dQuerySpace_dist(arg1::int_t, arg2::Ptr{dLUstruct_t{Int64}}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{SuperLUStat_t{Int64}}, arg5::Ptr{superlu_dist_mem_usage_t})::int_t
end
function dClone_CompRowLoc_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int64.dClone_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{SuperMatrix{Int64}})::Cvoid
end
function dCopy_CompRowLoc_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int64.dCopy_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{SuperMatrix{Int64}})::Cvoid
end
function dZero_CompRowLoc_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int64.dZero_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}})::Cvoid
end
function dScaleAddId_CompRowLoc_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int64.dScaleAddId_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::Cdouble)::Cvoid
end
function dScaleAdd_CompRowLoc_Matrix_dist(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.dScaleAdd_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{SuperMatrix{Int64}}, arg3::Cdouble)::Cvoid
end
function dZeroLblocks(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.dZeroLblocks(arg1::Cint, arg2::Cint, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{dLUstruct_t{Int64}})::Cvoid
end
function dZeroUblocks(iam, n, arg3, arg4)
@ccall libsuperlu_dist_Int64.dZeroUblocks(iam::Cint, n::Cint, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{dLUstruct_t{Int64}})::Cvoid
end
function dfill_dist(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.dfill_dist(arg1::Ptr{Cdouble}, arg2::int_t, arg3::Cdouble)::Cvoid
end
function dinf_norm_error_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.dinf_norm_error_dist(arg1::int_t, arg2::int_t, arg3::Ptr{Cdouble}, arg4::int_t, arg5::Ptr{Cdouble}, arg6::int_t, arg7::Ptr{gridinfo_t{Int64}})::Cvoid
end
function pdinf_norm_error(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.pdinf_norm_error(arg1::Cint, arg2::int_t, arg3::int_t, arg4::Ptr{Cdouble}, arg5::int_t, arg6::Ptr{Cdouble}, arg7::int_t, arg8::MPI_Comm)::Cvoid
end
function dreadhb_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.dreadhb_dist(arg1::Cint, arg2::Ptr{Libc.FILE}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{Ptr{Cdouble}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}})::Cvoid
end
function dreadtriple_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.dreadtriple_dist(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{Cdouble}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cvoid
end
function dreadtriple_noheader(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.dreadtriple_noheader(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{Cdouble}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cvoid
end
function dreadrb_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.dreadrb_dist(arg1::Cint, arg2::Ptr{Libc.FILE}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{Ptr{Cdouble}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}})::Cvoid
end
function dreadMM_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.dreadMM_dist(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{Cdouble}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cvoid
end
function dread_binary(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.dread_binary(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{Cdouble}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cint
end
function ddist_psymbtonum(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.ddist_psymbtonum(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int64}}, arg4::Ptr{dScalePermstruct_t{Int64}}, arg5::Ptr{Pslu_freeable_t}, arg6::Ptr{dLUstruct_t{Int64}}, arg7::Ptr{gridinfo_t{Int64}})::Cfloat
end
function pdGetDiagU(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.pdGetDiagU(arg1::int_t, arg2::Ptr{dLUstruct_t{Int64}}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{Cdouble})::Cvoid
end
function d_c2cpp_GetHWPM(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.d_c2cpp_GetHWPM(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{gridinfo_t{Int64}}, arg3::Ptr{dScalePermstruct_t{Int64}})::Cint
end
function dPrintLblocks(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int64.dPrintLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{dLocalLU_t{Int64}})::Cvoid
end
function dPrintUblocks(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int64.dPrintUblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{dLocalLU_t{Int64}})::Cvoid
end
function dPrint_CompCol_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int64.dPrint_CompCol_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}})::Cvoid
end
function dPrint_Dense_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int64.dPrint_Dense_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}})::Cvoid
end
function dPrint_CompRowLoc_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int64.dPrint_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}})::Cint
end
function file_dPrint_CompRowLoc_Matrix_dist(fp, A)
@ccall libsuperlu_dist_Int64.file_dPrint_CompRowLoc_Matrix_dist(fp::Ptr{Libc.FILE}, A::Ptr{SuperMatrix{Int64}})::Cint
end
function Printdouble5(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.Printdouble5(arg1::Ptr{Cchar}, arg2::int_t, arg3::Ptr{Cdouble})::Cvoid
end
function file_Printdouble5(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.file_Printdouble5(arg1::Ptr{Libc.FILE}, arg2::Ptr{Cchar}, arg3::int_t, arg4::Ptr{Cdouble})::Cint
end
function dGenCOOLblocks(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int64.dGenCOOLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{dLocalLU_t{Int64}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{Cdouble}}, arg9::Ptr{int_t}, arg10::Ptr{int_t})::Cvoid
end
function dGenCSCLblocks(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int64.dGenCSCLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{dLocalLU_t{Int64}}, arg6::Ptr{Ptr{Cdouble}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}}, arg9::Ptr{int_t}, arg10::Ptr{int_t})::Cvoid
end
function dGenCSRLblocks(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int64.dGenCSRLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{dLocalLU_t{Int64}}, arg6::Ptr{Ptr{Cdouble}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}}, arg9::Ptr{int_t}, arg10::Ptr{int_t})::Cvoid
end
function superlu_dgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
@ccall libsuperlu_dist_Int64.superlu_dgemm(transa::Ptr{Cchar}, transb::Ptr{Cchar}, m::Cint, n::Cint, k::Cint, alpha::Cdouble, a::Ptr{Cdouble}, lda::Cint, b::Ptr{Cdouble}, ldb::Cint, beta::Cdouble, c::Ptr{Cdouble}, ldc::Cint)::Cint
end
function superlu_dtrsm(sideRL, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
@ccall libsuperlu_dist_Int64.superlu_dtrsm(sideRL::Ptr{Cchar}, uplo::Ptr{Cchar}, transa::Ptr{Cchar}, diag::Ptr{Cchar}, m::Cint, n::Cint, alpha::Cdouble, a::Ptr{Cdouble}, lda::Cint, b::Ptr{Cdouble}, ldb::Cint)::Cint
end
function superlu_dger(m, n, alpha, x, incx, y, incy, a, lda)
@ccall libsuperlu_dist_Int64.superlu_dger(m::Cint, n::Cint, alpha::Cdouble, x::Ptr{Cdouble}, incx::Cint, y::Ptr{Cdouble}, incy::Cint, a::Ptr{Cdouble}, lda::Cint)::Cint
end
function superlu_dscal(n, alpha, x, incx)
@ccall libsuperlu_dist_Int64.superlu_dscal(n::Cint, alpha::Cdouble, x::Ptr{Cdouble}, incx::Cint)::Cint
end
function superlu_daxpy(n, alpha, x, incx, y, incy)
@ccall libsuperlu_dist_Int64.superlu_daxpy(n::Cint, alpha::Cdouble, x::Ptr{Cdouble}, incx::Cint, y::Ptr{Cdouble}, incy::Cint)::Cint
end
function superlu_dgemv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy)
@ccall libsuperlu_dist_Int64.superlu_dgemv(trans::Ptr{Cchar}, m::Cint, n::Cint, alpha::Cdouble, a::Ptr{Cdouble}, lda::Cint, x::Ptr{Cdouble}, incx::Cint, beta::Cdouble, y::Ptr{Cdouble}, incy::Cint)::Cint
end
function superlu_dtrsv(uplo, trans, diag, n, a, lda, x, incx)
@ccall libsuperlu_dist_Int64.superlu_dtrsv(uplo::Ptr{Cchar}, trans::Ptr{Cchar}, diag::Ptr{Cchar}, n::Cint, a::Ptr{Cdouble}, lda::Cint, x::Ptr{Cdouble}, incx::Cint)::Cint
end
function dcreate_matrix3d(A, nrhs, rhs, ldb, x, ldx, fp, grid3d)
@ccall libsuperlu_dist_Int64.dcreate_matrix3d(A::Ptr{SuperMatrix{Int64}}, nrhs::Cint, rhs::Ptr{Ptr{Cdouble}}, ldb::Ptr{Cint}, x::Ptr{Ptr{Cdouble}}, ldx::Ptr{Cint}, fp::Ptr{Libc.FILE}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cint
end
function dcreate_matrix_postfix3d(A, nrhs, rhs, ldb, x, ldx, fp, postfix, grid3d)
@ccall libsuperlu_dist_Int64.dcreate_matrix_postfix3d(A::Ptr{SuperMatrix{Int64}}, nrhs::Cint, rhs::Ptr{Ptr{Cdouble}}, ldb::Ptr{Cint}, x::Ptr{Ptr{Cdouble}}, ldx::Ptr{Cint}, fp::Ptr{Libc.FILE}, postfix::Ptr{Cchar}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cint
end
function dGatherNRformat_loc3d(Fact, A, B, ldb, nrhs, grid3d, arg7)
@ccall libsuperlu_dist_Int64.dGatherNRformat_loc3d(Fact::fact_t, A::Ptr{NRformat_loc{Int64}}, B::Ptr{Cdouble}, ldb::Cint, nrhs::Cint, grid3d::Ptr{gridinfo3d_t{Int64}}, arg7::Ptr{Ptr{NRformat_loc3d{Int64}}})::Cvoid
end
function dScatter_B3d(A3d, grid3d)
@ccall libsuperlu_dist_Int64.dScatter_B3d(A3d::Ptr{NRformat_loc3d{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cint
end
function pdgssvx3d(arg1, arg2, arg3, B, ldb, nrhs, arg7, arg8, arg9, berr, arg11, info)
@ccall libsuperlu_dist_Int64.pdgssvx3d(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{dScalePermstruct_t{Int64}}, B::Ptr{Cdouble}, ldb::Cint, nrhs::Cint, arg7::Ptr{gridinfo3d_t{Int64}}, arg8::Ptr{dLUstruct_t{Int64}}, arg9::Ptr{dSOLVEstruct_t{Int64}}, berr::Ptr{Cdouble}, arg11::Ptr{SuperLUStat_t{Int64}}, info::Ptr{Cint})::Cvoid
end
function pdgstrf3d(arg1, m, n, anorm, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int64.pdgstrf3d(arg1::Ptr{superlu_dist_options_t}, m::Cint, n::Cint, anorm::Cdouble, arg5::Ptr{dtrf3Dpartition_t{Int64}}, arg6::Ptr{SCT_t}, arg7::Ptr{dLUstruct_t{Int64}}, arg8::Ptr{gridinfo3d_t{Int64}}, arg9::Ptr{SuperLUStat_t{Int64}}, arg10::Ptr{Cint})::int_t
end
function dInit_HyP(HyP, Llu, mcb, mrb)
@ccall libsuperlu_dist_Int64.dInit_HyP(HyP::Ptr{HyP_t}, Llu::Ptr{dLocalLU_t{Int64}}, mcb::int_t, mrb::int_t)::Cvoid
end
function Free_HyP(HyP)
@ccall libsuperlu_dist_Int64.Free_HyP(HyP::Ptr{HyP_t})::Cvoid
end
function updateDirtyBit(k0, HyP, grid)
@ccall libsuperlu_dist_Int64.updateDirtyBit(k0::int_t, HyP::Ptr{HyP_t}, grid::Ptr{gridinfo_t{Int64}})::Cint
end
function dblock_gemm_scatter(lb, j, Ublock_info, Remain_info, L_mat, ldl, U_mat, ldu, bigV, knsupc, klst, lsub, usub, ldt, thread_id, indirect, indirect2, Lrowind_bc_ptr, Lnzval_bc_ptr, Ufstnz_br_ptr, Unzval_br_ptr, xsup, arg23, arg24)
@ccall libsuperlu_dist_Int64.dblock_gemm_scatter(lb::int_t, j::int_t, Ublock_info::Ptr{Ublock_info_t}, Remain_info::Ptr{Remain_info_t}, L_mat::Ptr{Cdouble}, ldl::Cint, U_mat::Ptr{Cdouble}, ldu::Cint, bigV::Ptr{Cdouble}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, thread_id::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, Lrowind_bc_ptr::Ptr{Ptr{int_t}}, Lnzval_bc_ptr::Ptr{Ptr{Cdouble}}, Ufstnz_br_ptr::Ptr{Ptr{int_t}}, Unzval_br_ptr::Ptr{Ptr{Cdouble}}, xsup::Ptr{int_t}, arg23::Ptr{gridinfo_t{Int64}}, arg24::Ptr{SuperLUStat_t{Int64}})::Cvoid
end
function dblock_gemm_scatterTopLeft(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int64.dblock_gemm_scatterTopLeft(lb::int_t, j::int_t, bigV::Ptr{Cdouble}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{dLUstruct_t{Int64}}, arg13::Ptr{gridinfo_t{Int64}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int64}})::int_t
end
function dblock_gemm_scatterTopRight(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int64.dblock_gemm_scatterTopRight(lb::int_t, j::int_t, bigV::Ptr{Cdouble}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{dLUstruct_t{Int64}}, arg13::Ptr{gridinfo_t{Int64}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int64}})::int_t
end
function dblock_gemm_scatterBottomLeft(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int64.dblock_gemm_scatterBottomLeft(lb::int_t, j::int_t, bigV::Ptr{Cdouble}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{dLUstruct_t{Int64}}, arg13::Ptr{gridinfo_t{Int64}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int64}})::int_t
end
function dblock_gemm_scatterBottomRight(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int64.dblock_gemm_scatterBottomRight(lb::int_t, j::int_t, bigV::Ptr{Cdouble}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{dLUstruct_t{Int64}}, arg13::Ptr{gridinfo_t{Int64}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int64}})::int_t
end
function dgather_u(num_u_blks, Ublock_info, usub, uval, bigU, ldu, xsup, klst)
@ccall libsuperlu_dist_Int64.dgather_u(num_u_blks::int_t, Ublock_info::Ptr{Ublock_info_t}, usub::Ptr{int_t}, uval::Ptr{Cdouble}, bigU::Ptr{Cdouble}, ldu::int_t, xsup::Ptr{int_t}, klst::int_t)::Cvoid
end
function dgather_l(num_LBlk, knsupc, L_info, lval, LD_lval, L_buff)
@ccall libsuperlu_dist_Int64.dgather_l(num_LBlk::int_t, knsupc::int_t, L_info::Ptr{Remain_info_t}, lval::Ptr{Cdouble}, LD_lval::int_t, L_buff::Ptr{Cdouble})::Cvoid
end
function dRgather_L(k, lsub, lusup, arg4, arg5, arg6, arg7, myIperm, iperm_c_supno)
@ccall libsuperlu_dist_Int64.dRgather_L(k::int_t, lsub::Ptr{int_t}, lusup::Ptr{Cdouble}, arg4::Ptr{gEtreeInfo_t{Int64}}, arg5::Ptr{Glu_persist_t}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{HyP_t}, myIperm::Ptr{int_t}, iperm_c_supno::Ptr{int_t})::Cvoid
end
function dRgather_U(k, jj0, usub, uval, bigU, arg6, arg7, arg8, arg9, myIperm, iperm_c_supno, perm_u)
@ccall libsuperlu_dist_Int64.dRgather_U(k::int_t, jj0::int_t, usub::Ptr{int_t}, uval::Ptr{Cdouble}, bigU::Ptr{Cdouble}, arg6::Ptr{gEtreeInfo_t{Int64}}, arg7::Ptr{Glu_persist_t}, arg8::Ptr{gridinfo_t{Int64}}, arg9::Ptr{HyP_t}, myIperm::Ptr{int_t}, iperm_c_supno::Ptr{int_t}, perm_u::Ptr{int_t})::Cvoid
end
function dinitTrf3Dpartition(nsupers, options, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.dinitTrf3Dpartition(nsupers::int_t, options::Ptr{superlu_dist_options_t}, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::Ptr{dtrf3Dpartition_t{Int64}}
end
function dDestroy_trf3Dpartition(trf3Dpartition, grid3d)
@ccall libsuperlu_dist_Int64.dDestroy_trf3Dpartition(trf3Dpartition::Ptr{dtrf3Dpartition_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cvoid
end
function d3D_printMemUse(trf3Dpartition, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.d3D_printMemUse(trf3Dpartition::Ptr{dtrf3Dpartition_t{Int64}}, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cvoid
end
function dinit3DLUstructForest(myTreeIdxs, myZeroTrIdxs, sForests, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.dinit3DLUstructForest(myTreeIdxs::Ptr{int_t}, myZeroTrIdxs::Ptr{int_t}, sForests::Ptr{Ptr{sForest_t{Int64}}}, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cvoid
end
function dgatherAllFactoredLUFr(myZeroTrIdxs, sForests, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.dgatherAllFactoredLUFr(myZeroTrIdxs::Ptr{int_t}, sForests::Ptr{sForest_t{Int64}}, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function dLpanelUpdate(off0, nsupc, ublk_ptr, ld_ujrow, lusup, nsupr, arg7)
@ccall libsuperlu_dist_Int64.dLpanelUpdate(off0::int_t, nsupc::int_t, ublk_ptr::Ptr{Cdouble}, ld_ujrow::int_t, lusup::Ptr{Cdouble}, nsupr::int_t, arg7::Ptr{SCT_t})::int_t
end
function Local_Dgstrf2(options, k, thresh, BlockUFactor, arg5, arg6, arg7, arg8, info, arg10)
@ccall libsuperlu_dist_Int64.Local_Dgstrf2(options::Ptr{superlu_dist_options_t}, k::int_t, thresh::Cdouble, BlockUFactor::Ptr{Cdouble}, arg5::Ptr{Glu_persist_t}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{dLocalLU_t{Int64}}, arg8::Ptr{SuperLUStat_t{Int64}}, info::Ptr{Cint}, arg10::Ptr{SCT_t})::Cvoid
end
function dTrs2_GatherU(iukp, rukp, klst, nsupc, ldu, usub, uval, tempv)
@ccall libsuperlu_dist_Int64.dTrs2_GatherU(iukp::int_t, rukp::int_t, klst::int_t, nsupc::int_t, ldu::int_t, usub::Ptr{int_t}, uval::Ptr{Cdouble}, tempv::Ptr{Cdouble})::int_t
end
function dTrs2_ScatterU(iukp, rukp, klst, nsupc, ldu, usub, uval, tempv)
@ccall libsuperlu_dist_Int64.dTrs2_ScatterU(iukp::int_t, rukp::int_t, klst::int_t, nsupc::int_t, ldu::int_t, usub::Ptr{int_t}, uval::Ptr{Cdouble}, tempv::Ptr{Cdouble})::int_t
end
function dTrs2_GatherTrsmScatter(klst, iukp, rukp, usub, uval, tempv, knsupc, nsupr, lusup, Glu_persist)
@ccall libsuperlu_dist_Int64.dTrs2_GatherTrsmScatter(klst::int_t, iukp::int_t, rukp::int_t, usub::Ptr{int_t}, uval::Ptr{Cdouble}, tempv::Ptr{Cdouble}, knsupc::int_t, nsupr::Cint, lusup::Ptr{Cdouble}, Glu_persist::Ptr{Glu_persist_t})::int_t
end
function pdgstrs2(m, k0, k, Glu_persist, grid, Llu, stat)
@ccall libsuperlu_dist_Int64.pdgstrs2(m::int_t, k0::int_t, k::int_t, Glu_persist::Ptr{Glu_persist_t}, grid::Ptr{gridinfo_t{Int64}}, Llu::Ptr{dLocalLU_t{Int64}}, stat::Ptr{SuperLUStat_t{Int64}})::Cvoid
end
function pdgstrf2(arg1, nsupers, k0, k, thresh, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int64.pdgstrf2(arg1::Ptr{superlu_dist_options_t}, nsupers::int_t, k0::int_t, k::int_t, thresh::Cdouble, arg6::Ptr{Glu_persist_t}, arg7::Ptr{gridinfo_t{Int64}}, arg8::Ptr{dLocalLU_t{Int64}}, arg9::Ptr{MPI_Request}, arg10::Cint, arg11::Ptr{SuperLUStat_t{Int64}}, arg12::Ptr{Cint})::Cvoid
end
function dAllocLlu_3d(nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.dAllocLlu_3d(nsupers::int_t, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function dp3dScatter(n, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.dp3dScatter(n::int_t, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function dscatter3dLPanels(nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.dscatter3dLPanels(nsupers::int_t, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function dscatter3dUPanels(nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.dscatter3dUPanels(nsupers::int_t, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function dcollect3dLpanels(layer, nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.dcollect3dLpanels(layer::int_t, nsupers::int_t, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function dcollect3dUpanels(layer, nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.dcollect3dUpanels(layer::int_t, nsupers::int_t, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function dp3dCollect(layer, n, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.dp3dCollect(layer::int_t, n::int_t, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function dzeroSetLU(nnodes, nodeList, arg3, arg4)
@ccall libsuperlu_dist_Int64.dzeroSetLU(nnodes::int_t, nodeList::Ptr{int_t}, arg3::Ptr{dLUstruct_t{Int64}}, arg4::Ptr{gridinfo3d_t{Int64}})::int_t
end
function dAllocGlu_3d(n, nsupers, arg3)
@ccall libsuperlu_dist_Int64.dAllocGlu_3d(n::int_t, nsupers::int_t, arg3::Ptr{dLUstruct_t{Int64}})::Cint
end
function dDeAllocLlu_3d(n, arg2, arg3)
@ccall libsuperlu_dist_Int64.dDeAllocLlu_3d(n::int_t, arg2::Ptr{dLUstruct_t{Int64}}, arg3::Ptr{gridinfo3d_t{Int64}})::Cint
end
function dDeAllocGlu_3d(arg1)
@ccall libsuperlu_dist_Int64.dDeAllocGlu_3d(arg1::Ptr{dLUstruct_t{Int64}})::Cint
end
function dreduceAncestors3d(sender, receiver, nnodes, nodeList, Lval_buf, Uval_buf, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.dreduceAncestors3d(sender::int_t, receiver::int_t, nnodes::int_t, nodeList::Ptr{int_t}, Lval_buf::Ptr{Cdouble}, Uval_buf::Ptr{Cdouble}, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function dreduceAllAncestors3d(ilvl, myNodeCount, treePerm, LUvsb, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.dreduceAllAncestors3d(ilvl::int_t, myNodeCount::Ptr{int_t}, treePerm::Ptr{Ptr{int_t}}, LUvsb::Ptr{dLUValSubBuf_t{Int64}}, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::Cint
end
function dgatherFactoredLU(sender, receiver, nnodes, nodeList, LUvsb, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.dgatherFactoredLU(sender::int_t, receiver::int_t, nnodes::int_t, nodeList::Ptr{int_t}, LUvsb::Ptr{dLUValSubBuf_t{Int64}}, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function dgatherAllFactoredLU(trf3Dpartition, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.dgatherAllFactoredLU(trf3Dpartition::Ptr{dtrf3Dpartition_t{Int64}}, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function dinit3DLUstruct(myTreeIdxs, myZeroTrIdxs, nodeCount, nodeList, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.dinit3DLUstruct(myTreeIdxs::Ptr{int_t}, myZeroTrIdxs::Ptr{int_t}, nodeCount::Ptr{int_t}, nodeList::Ptr{Ptr{int_t}}, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function dzSendLPanel(k, receiver, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.dzSendLPanel(k::int_t, receiver::int_t, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function dzRecvLPanel(k, sender, alpha, beta, Lval_buf, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.dzRecvLPanel(k::int_t, sender::int_t, alpha::Cdouble, beta::Cdouble, Lval_buf::Ptr{Cdouble}, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function dzSendUPanel(k, receiver, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.dzSendUPanel(k::int_t, receiver::int_t, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function dzRecvUPanel(k, sender, alpha, beta, Uval_buf, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.dzRecvUPanel(k::int_t, sender::int_t, alpha::Cdouble, beta::Cdouble, Uval_buf::Ptr{Cdouble}, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function dIBcast_LPanel(k, k0, lsub, lusup, arg5, msgcnt, arg7, ToSendR, xsup, arg10)
@ccall libsuperlu_dist_Int64.dIBcast_LPanel(k::int_t, k0::int_t, lsub::Ptr{int_t}, lusup::Ptr{Cdouble}, arg5::Ptr{gridinfo_t{Int64}}, msgcnt::Ptr{Cint}, arg7::Ptr{MPI_Request}, ToSendR::Ptr{Ptr{Cint}}, xsup::Ptr{int_t}, arg10::Cint)::int_t
end
function dBcast_LPanel(k, k0, lsub, lusup, arg5, msgcnt, ToSendR, xsup, arg9, arg10)
@ccall libsuperlu_dist_Int64.dBcast_LPanel(k::int_t, k0::int_t, lsub::Ptr{int_t}, lusup::Ptr{Cdouble}, arg5::Ptr{gridinfo_t{Int64}}, msgcnt::Ptr{Cint}, ToSendR::Ptr{Ptr{Cint}}, xsup::Ptr{int_t}, arg9::Ptr{SCT_t}, arg10::Cint)::int_t
end
function dIBcast_UPanel(k, k0, usub, uval, arg5, msgcnt, arg7, ToSendD, arg9)
@ccall libsuperlu_dist_Int64.dIBcast_UPanel(k::int_t, k0::int_t, usub::Ptr{int_t}, uval::Ptr{Cdouble}, arg5::Ptr{gridinfo_t{Int64}}, msgcnt::Ptr{Cint}, arg7::Ptr{MPI_Request}, ToSendD::Ptr{Cint}, arg9::Cint)::int_t
end
function dBcast_UPanel(k, k0, usub, uval, arg5, msgcnt, ToSendD, arg8, arg9)
@ccall libsuperlu_dist_Int64.dBcast_UPanel(k::int_t, k0::int_t, usub::Ptr{int_t}, uval::Ptr{Cdouble}, arg5::Ptr{gridinfo_t{Int64}}, msgcnt::Ptr{Cint}, ToSendD::Ptr{Cint}, arg8::Ptr{SCT_t}, arg9::Cint)::int_t
end
function dIrecv_LPanel(k, k0, Lsub_buf, Lval_buf, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.dIrecv_LPanel(k::int_t, k0::int_t, Lsub_buf::Ptr{int_t}, Lval_buf::Ptr{Cdouble}, arg5::Ptr{gridinfo_t{Int64}}, arg6::Ptr{MPI_Request}, arg7::Ptr{dLocalLU_t{Int64}}, arg8::Cint)::int_t
end
function dIrecv_UPanel(k, k0, Usub_buf, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.dIrecv_UPanel(k::int_t, k0::int_t, Usub_buf::Ptr{int_t}, arg4::Ptr{Cdouble}, arg5::Ptr{dLocalLU_t{Int64}}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{MPI_Request}, arg8::Cint)::int_t
end
function dWait_URecv(arg1, msgcnt, arg3)
@ccall libsuperlu_dist_Int64.dWait_URecv(arg1::Ptr{MPI_Request}, msgcnt::Ptr{Cint}, arg3::Ptr{SCT_t})::int_t
end
function dWait_LRecv(arg1, msgcnt, msgcntsU, arg4, arg5)
@ccall libsuperlu_dist_Int64.dWait_LRecv(arg1::Ptr{MPI_Request}, msgcnt::Ptr{Cint}, msgcntsU::Ptr{Cint}, arg4::Ptr{gridinfo_t{Int64}}, arg5::Ptr{SCT_t})::int_t
end
function dISend_UDiagBlock(k0, ublk_ptr, size, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.dISend_UDiagBlock(k0::int_t, ublk_ptr::Ptr{Cdouble}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int64}}, arg6::Cint)::int_t
end
function dRecv_UDiagBlock(k0, ublk_ptr, size, src, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.dRecv_UDiagBlock(k0::int_t, ublk_ptr::Ptr{Cdouble}, size::int_t, src::int_t, arg5::Ptr{gridinfo_t{Int64}}, arg6::Ptr{SCT_t}, arg7::Cint)::int_t
end
function dPackLBlock(k, Dest, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int64.dPackLBlock(k::int_t, Dest::Ptr{Cdouble}, arg3::Ptr{Glu_persist_t}, arg4::Ptr{gridinfo_t{Int64}}, arg5::Ptr{dLocalLU_t{Int64}})::int_t
end
function dISend_LDiagBlock(k0, lblk_ptr, size, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.dISend_LDiagBlock(k0::int_t, lblk_ptr::Ptr{Cdouble}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int64}}, arg6::Cint)::int_t
end
function dIRecv_UDiagBlock(k0, ublk_ptr, size, src, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.dIRecv_UDiagBlock(k0::int_t, ublk_ptr::Ptr{Cdouble}, size::int_t, src::int_t, arg5::Ptr{MPI_Request}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{SCT_t}, arg8::Cint)::int_t
end
function dIRecv_LDiagBlock(k0, L_blk_ptr, size, src, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.dIRecv_LDiagBlock(k0::int_t, L_blk_ptr::Ptr{Cdouble}, size::int_t, src::int_t, arg5::Ptr{MPI_Request}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{SCT_t}, arg8::Cint)::int_t
end
function dUDiagBlockRecvWait(k, IrecvPlcd_D, factored_L, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.dUDiagBlockRecvWait(k::int_t, IrecvPlcd_D::Ptr{int_t}, factored_L::Ptr{int_t}, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int64}}, arg6::Ptr{dLUstruct_t{Int64}}, arg7::Ptr{SCT_t})::int_t
end
function LDiagBlockRecvWait(k, factored_U, arg3, arg4)
@ccall libsuperlu_dist_Int64.LDiagBlockRecvWait(k::int_t, factored_U::Ptr{int_t}, arg3::Ptr{MPI_Request}, arg4::Ptr{gridinfo_t{Int64}})::int_t
end
function dIBcast_UDiagBlock(k, ublk_ptr, size, arg4, arg5)
@ccall libsuperlu_dist_Int64.dIBcast_UDiagBlock(k::int_t, ublk_ptr::Ptr{Cdouble}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int64}})::int_t
end
function dIBcast_LDiagBlock(k, lblk_ptr, size, arg4, arg5)
@ccall libsuperlu_dist_Int64.dIBcast_LDiagBlock(k::int_t, lblk_ptr::Ptr{Cdouble}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int64}})::int_t
end
function dDiagFactIBCast(k, k0, BlockUFactor, BlockLFactor, IrecvPlcd_D, arg6, arg7, arg8, arg9, arg10, arg11, thresh, LUstruct, arg14, info, arg16, tag_ub)
@ccall libsuperlu_dist_Int64.dDiagFactIBCast(k::int_t, k0::int_t, BlockUFactor::Ptr{Cdouble}, BlockLFactor::Ptr{Cdouble}, IrecvPlcd_D::Ptr{int_t}, arg6::Ptr{MPI_Request}, arg7::Ptr{MPI_Request}, arg8::Ptr{MPI_Request}, arg9::Ptr{MPI_Request}, arg10::Ptr{gridinfo_t{Int64}}, arg11::Ptr{superlu_dist_options_t}, thresh::Cdouble, LUstruct::Ptr{dLUstruct_t{Int64}}, arg14::Ptr{SuperLUStat_t{Int64}}, info::Ptr{Cint}, arg16::Ptr{SCT_t}, tag_ub::Cint)::int_t
end
function dUPanelTrSolve(k, BlockLFactor, bigV, ldt, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.dUPanelTrSolve(k::int_t, BlockLFactor::Ptr{Cdouble}, bigV::Ptr{Cdouble}, ldt::int_t, arg5::Ptr{Ublock_info_t}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{dLUstruct_t{Int64}}, arg8::Ptr{SuperLUStat_t{Int64}}, arg9::Ptr{SCT_t})::int_t
end
function dLPanelUpdate(k, IrecvPlcd_D, factored_L, arg4, BlockUFactor, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.dLPanelUpdate(k::int_t, IrecvPlcd_D::Ptr{int_t}, factored_L::Ptr{int_t}, arg4::Ptr{MPI_Request}, BlockUFactor::Ptr{Cdouble}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{dLUstruct_t{Int64}}, arg8::Ptr{SCT_t})::int_t
end
function dUPanelUpdate(k, factored_U, arg3, BlockLFactor, bigV, ldt, arg7, arg8, arg9, arg10, arg11)
@ccall libsuperlu_dist_Int64.dUPanelUpdate(k::int_t, factored_U::Ptr{int_t}, arg3::Ptr{MPI_Request}, BlockLFactor::Ptr{Cdouble}, bigV::Ptr{Cdouble}, ldt::int_t, arg7::Ptr{Ublock_info_t}, arg8::Ptr{gridinfo_t{Int64}}, arg9::Ptr{dLUstruct_t{Int64}}, arg10::Ptr{SuperLUStat_t{Int64}}, arg11::Ptr{SCT_t})::int_t
end
function dIBcastRecvLPanel(k, k0, msgcnt, arg4, arg5, Lsub_buf, Lval_buf, factored, arg9, arg10, arg11, tag_ub)
@ccall libsuperlu_dist_Int64.dIBcastRecvLPanel(k::int_t, k0::int_t, msgcnt::Ptr{Cint}, arg4::Ptr{MPI_Request}, arg5::Ptr{MPI_Request}, Lsub_buf::Ptr{int_t}, Lval_buf::Ptr{Cdouble}, factored::Ptr{int_t}, arg9::Ptr{gridinfo_t{Int64}}, arg10::Ptr{dLUstruct_t{Int64}}, arg11::Ptr{SCT_t}, tag_ub::Cint)::int_t
end
function dIBcastRecvUPanel(k, k0, msgcnt, arg4, arg5, Usub_buf, Uval_buf, arg8, arg9, arg10, tag_ub)
@ccall libsuperlu_dist_Int64.dIBcastRecvUPanel(k::int_t, k0::int_t, msgcnt::Ptr{Cint}, arg4::Ptr{MPI_Request}, arg5::Ptr{MPI_Request}, Usub_buf::Ptr{int_t}, Uval_buf::Ptr{Cdouble}, arg8::Ptr{gridinfo_t{Int64}}, arg9::Ptr{dLUstruct_t{Int64}}, arg10::Ptr{SCT_t}, tag_ub::Cint)::int_t
end
function dWaitL(k, msgcnt, msgcntU, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.dWaitL(k::int_t, msgcnt::Ptr{Cint}, msgcntU::Ptr{Cint}, arg4::Ptr{MPI_Request}, arg5::Ptr{MPI_Request}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{dLUstruct_t{Int64}}, arg8::Ptr{SCT_t})::int_t
end
function dWaitU(k, msgcnt, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.dWaitU(k::int_t, msgcnt::Ptr{Cint}, arg3::Ptr{MPI_Request}, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int64}}, arg6::Ptr{dLUstruct_t{Int64}}, arg7::Ptr{SCT_t})::int_t
end
function dLPanelTrSolve(k, factored_L, BlockUFactor, arg4, arg5)
@ccall libsuperlu_dist_Int64.dLPanelTrSolve(k::int_t, factored_L::Ptr{int_t}, BlockUFactor::Ptr{Cdouble}, arg4::Ptr{gridinfo_t{Int64}}, arg5::Ptr{dLUstruct_t{Int64}})::int_t
end
function getNsupers(arg1, arg2)
@ccall libsuperlu_dist_Int64.getNsupers(arg1::Cint, arg2::Ptr{Glu_persist_t})::Cint
end
function initPackLUInfo(nsupers, packLUInfo)
@ccall libsuperlu_dist_Int64.initPackLUInfo(nsupers::int_t, packLUInfo::Ptr{packLUInfo_t{Int64}})::int_t
end
function freePackLUInfo(packLUInfo)
@ccall libsuperlu_dist_Int64.freePackLUInfo(packLUInfo::Ptr{packLUInfo_t{Int64}})::Cint
end
function dSchurComplementSetup(k, msgcnt, arg3, arg4, arg5, arg6, arg7, arg8, arg9, bigU, Lsub_buf, Lval_buf, Usub_buf, Uval_buf, arg15, arg16)
@ccall libsuperlu_dist_Int64.dSchurComplementSetup(k::int_t, msgcnt::Ptr{Cint}, arg3::Ptr{Ublock_info_t}, arg4::Ptr{Remain_info_t}, arg5::Ptr{uPanelInfo_t{Int64}}, arg6::Ptr{lPanelInfo_t{Int64}}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{int_t}, bigU::Ptr{Cdouble}, Lsub_buf::Ptr{int_t}, Lval_buf::Ptr{Cdouble}, Usub_buf::Ptr{int_t}, Uval_buf::Ptr{Cdouble}, arg15::Ptr{gridinfo_t{Int64}}, arg16::Ptr{dLUstruct_t{Int64}})::int_t
end
function dSchurComplementSetupGPU(k, msgs, arg3, arg4, arg5, arg6, arg7, arg8, arg9, LUvsb, arg11, arg12, arg13)
@ccall libsuperlu_dist_Int64.dSchurComplementSetupGPU(k::int_t, msgs::Ptr{msgs_t}, arg3::Ptr{packLUInfo_t{Int64}}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{int_t}, arg7::Ptr{gEtreeInfo_t{Int64}}, arg8::Ptr{factNodelists_t{Int64}}, arg9::Ptr{dscuBufs_t}, LUvsb::Ptr{dLUValSubBuf_t{Int64}}, arg11::Ptr{gridinfo_t{Int64}}, arg12::Ptr{dLUstruct_t{Int64}}, arg13::Ptr{HyP_t})::int_t
end
function dgetBigV(arg1, arg2)
@ccall libsuperlu_dist_Int64.dgetBigV(arg1::int_t, arg2::int_t)::Ptr{Cdouble}
end
function dgetBigU(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.dgetBigU(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{dLUstruct_t{Int64}})::Ptr{Cdouble}
end
function dLluBufInit(arg1, arg2)
@ccall libsuperlu_dist_Int64.dLluBufInit(arg1::Ptr{dLUValSubBuf_t{Int64}}, arg2::Ptr{dLUstruct_t{Int64}})::int_t
end
function dinitScuBufs(arg1, ldt, num_threads, nsupers, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.dinitScuBufs(arg1::Ptr{superlu_dist_options_t}, ldt::int_t, num_threads::int_t, nsupers::int_t, arg5::Ptr{dscuBufs_t}, arg6::Ptr{dLUstruct_t{Int64}}, arg7::Ptr{gridinfo_t{Int64}})::int_t
end
function dfreeScuBufs(scuBufs)
@ccall libsuperlu_dist_Int64.dfreeScuBufs(scuBufs::Ptr{dscuBufs_t})::Cint
end
function dsparseTreeFactor(nnodes, perm_c_supno, treeTopoInfo, comReqs, scuBufs, packLUInfo, msgs, LUvsb, dFBuf, factStat, fNlists, options, gIperm_c_supno, ldt, LUstruct, grid3d, stat, thresh, SCT, info)
@ccall libsuperlu_dist_Int64.dsparseTreeFactor(nnodes::int_t, perm_c_supno::Ptr{int_t}, treeTopoInfo::Ptr{treeTopoInfo_t{Int64}}, comReqs::Ptr{commRequests_t}, scuBufs::Ptr{dscuBufs_t}, packLUInfo::Ptr{packLUInfo_t{Int64}}, msgs::Ptr{msgs_t}, LUvsb::Ptr{dLUValSubBuf_t{Int64}}, dFBuf::Ptr{ddiagFactBufs_t}, factStat::Ptr{factStat_t{Int64}}, fNlists::Ptr{factNodelists_t{Int64}}, options::Ptr{superlu_dist_options_t}, gIperm_c_supno::Ptr{int_t}, ldt::int_t, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, stat::Ptr{SuperLUStat_t{Int64}}, thresh::Cdouble, SCT::Ptr{SCT_t}, info::Ptr{Cint})::int_t
end
function ddenseTreeFactor(nnnodes, perm_c_supno, comReqs, scuBufs, packLUInfo, msgs, LUvsb, dFBuf, factStat, fNlists, options, gIperm_c_supno, ldt, LUstruct, grid3d, stat, thresh, SCT, tag_ub, info)
@ccall libsuperlu_dist_Int64.ddenseTreeFactor(nnnodes::int_t, perm_c_supno::Ptr{int_t}, comReqs::Ptr{commRequests_t}, scuBufs::Ptr{dscuBufs_t}, packLUInfo::Ptr{packLUInfo_t{Int64}}, msgs::Ptr{msgs_t}, LUvsb::Ptr{dLUValSubBuf_t{Int64}}, dFBuf::Ptr{ddiagFactBufs_t}, factStat::Ptr{factStat_t{Int64}}, fNlists::Ptr{factNodelists_t{Int64}}, options::Ptr{superlu_dist_options_t}, gIperm_c_supno::Ptr{int_t}, ldt::int_t, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, stat::Ptr{SuperLUStat_t{Int64}}, thresh::Cdouble, SCT::Ptr{SCT_t}, tag_ub::Cint, info::Ptr{Cint})::int_t
end
function dsparseTreeFactor_ASYNC(sforest, comReqss, scuBufs, packLUInfo, msgss, LUvsbs, dFBufs, factStat, fNlists, gEtreeInfo, options, gIperm_c_supno, ldt, HyP, LUstruct, grid3d, stat, thresh, SCT, tag_ub, info)
@ccall libsuperlu_dist_Int64.dsparseTreeFactor_ASYNC(sforest::Ptr{sForest_t{Int64}}, comReqss::Ptr{Ptr{commRequests_t}}, scuBufs::Ptr{dscuBufs_t}, packLUInfo::Ptr{packLUInfo_t{Int64}}, msgss::Ptr{Ptr{msgs_t}}, LUvsbs::Ptr{Ptr{dLUValSubBuf_t{Int64}}}, dFBufs::Ptr{Ptr{ddiagFactBufs_t}}, factStat::Ptr{factStat_t{Int64}}, fNlists::Ptr{factNodelists_t{Int64}}, gEtreeInfo::Ptr{gEtreeInfo_t{Int64}}, options::Ptr{superlu_dist_options_t}, gIperm_c_supno::Ptr{int_t}, ldt::int_t, HyP::Ptr{HyP_t}, LUstruct::Ptr{dLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, stat::Ptr{SuperLUStat_t{Int64}}, thresh::Cdouble, SCT::Ptr{SCT_t}, tag_ub::Cint, info::Ptr{Cint})::int_t
end
function dLluBufInitArr(numLA, LUstruct)
@ccall libsuperlu_dist_Int64.dLluBufInitArr(numLA::int_t, LUstruct::Ptr{dLUstruct_t{Int64}})::Ptr{Ptr{dLUValSubBuf_t{Int64}}}
end
function dLluBufFreeArr(numLA, LUvsbs)
@ccall libsuperlu_dist_Int64.dLluBufFreeArr(numLA::int_t, LUvsbs::Ptr{Ptr{dLUValSubBuf_t{Int64}}})::Cint
end
function dinitDiagFactBufsArr(mxLeafNode, ldt, grid)
@ccall libsuperlu_dist_Int64.dinitDiagFactBufsArr(mxLeafNode::int_t, ldt::int_t, grid::Ptr{gridinfo_t{Int64}})::Ptr{Ptr{ddiagFactBufs_t}}
end
function dfreeDiagFactBufsArr(mxLeafNode, dFBufs)
@ccall libsuperlu_dist_Int64.dfreeDiagFactBufsArr(mxLeafNode::int_t, dFBufs::Ptr{Ptr{ddiagFactBufs_t}})::Cint
end
function dinitDiagFactBufs(ldt, dFBuf)
@ccall libsuperlu_dist_Int64.dinitDiagFactBufs(ldt::int_t, dFBuf::Ptr{ddiagFactBufs_t})::int_t
end
function checkRecvUDiag(k, comReqs, grid, SCT)
@ccall libsuperlu_dist_Int64.checkRecvUDiag(k::int_t, comReqs::Ptr{commRequests_t}, grid::Ptr{gridinfo_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function checkRecvLDiag(k, comReqs, arg3, arg4)
@ccall libsuperlu_dist_Int64.checkRecvLDiag(k::int_t, comReqs::Ptr{commRequests_t}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{SCT_t})::int_t
end
# no prototype is found for this function at superlu_defs.h:1122:15, please use with caution
function SuperLU_timer_dist_()
@ccall libsuperlu_dist_Int64.SuperLU_timer_dist_()::Cdouble
end
function superlu_gridinit(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.superlu_gridinit(arg1::MPI_Comm, arg2::Cint, arg3::Cint, arg4::Ptr{gridinfo_t{Int64}})::Cvoid
end
function superlu_gridmap(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.superlu_gridmap(arg1::MPI_Comm, arg2::Cint, arg3::Cint, arg4::Ptr{Cint}, arg5::Cint, arg6::Ptr{gridinfo_t{Int64}})::Cvoid
end
function superlu_gridexit(arg1)
@ccall libsuperlu_dist_Int64.superlu_gridexit(arg1::Ptr{gridinfo_t{Int64}})::Cvoid
end
function superlu_gridinit3d(Bcomm, nprow, npcol, npdep, grid)
@ccall libsuperlu_dist_Int64.superlu_gridinit3d(Bcomm::MPI_Comm, nprow::Cint, npcol::Cint, npdep::Cint, grid::Ptr{gridinfo3d_t{Int64}})::Cvoid
end
function superlu_gridmap3d(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.superlu_gridmap3d(arg1::MPI_Comm, arg2::Cint, arg3::Cint, arg4::Cint, arg5::Ptr{Cint}, arg6::Ptr{gridinfo3d_t{Int64}})::Cvoid
end
function superlu_gridexit3d(grid)
@ccall libsuperlu_dist_Int64.superlu_gridexit3d(grid::Ptr{gridinfo3d_t{Int64}})::Cvoid
end
function set_default_options_dist(arg1)
@ccall libsuperlu_dist_Int64.set_default_options_dist(arg1::Ptr{superlu_dist_options_t})::Cvoid
end
function print_options_dist(arg1)
@ccall libsuperlu_dist_Int64.print_options_dist(arg1::Ptr{superlu_dist_options_t})::Cvoid
end
function print_sp_ienv_dist(arg1)
@ccall libsuperlu_dist_Int64.print_sp_ienv_dist(arg1::Ptr{superlu_dist_options_t})::Cvoid
end
function Destroy_CompCol_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int64.Destroy_CompCol_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}})::Cvoid
end
function Destroy_SuperNode_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int64.Destroy_SuperNode_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}})::Cvoid
end
function Destroy_SuperMatrix_Store_dist(arg1)
@ccall libsuperlu_dist_Int64.Destroy_SuperMatrix_Store_dist(arg1::Ptr{SuperMatrix{Int64}})::Cvoid
end
function Destroy_CompCol_Permuted_dist(arg1)
@ccall libsuperlu_dist_Int64.Destroy_CompCol_Permuted_dist(arg1::Ptr{SuperMatrix{Int64}})::Cvoid
end
function Destroy_CompRowLoc_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int64.Destroy_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}})::Cvoid
end
function Destroy_CompRow_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int64.Destroy_CompRow_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}})::Cvoid
end
function sp_colorder(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int64.sp_colorder(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{SuperMatrix{Int64}})::Cvoid
end
function sp_symetree_dist(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int64.sp_symetree_dist(arg1::Ptr{int_t}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::int_t, arg5::Ptr{int_t})::Cint
end
function sp_coletree_dist(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.sp_coletree_dist(arg1::Ptr{int_t}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::int_t, arg5::int_t, arg6::Ptr{int_t})::Cint
end
function get_perm_c_dist(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.get_perm_c_dist(arg1::int_t, arg2::int_t, arg3::Ptr{SuperMatrix{Int64}}, arg4::Ptr{int_t})::Cvoid
end
function at_plus_a_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.at_plus_a_dist(arg1::int_t, arg2::int_t, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cvoid
end
function genmmd_dist_(arg1, arg2, a, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int64.genmmd_dist_(arg1::Ptr{int_t}, arg2::Ptr{int_t}, a::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{int_t}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{int_t}, arg10::Ptr{int_t}, arg11::Ptr{int_t}, arg12::Ptr{int_t})::Cint
end
function bcast_tree(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.bcast_tree(arg1::Ptr{Cvoid}, arg2::Cint, arg3::MPI_Datatype, arg4::Cint, arg5::Cint, arg6::Ptr{gridinfo_t{Int64}}, arg7::Cint, arg8::Ptr{Cint})::Cvoid
end
function symbfact(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.symbfact(arg1::Ptr{superlu_dist_options_t}, arg2::Cint, arg3::Ptr{SuperMatrix{Int64}}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{Glu_persist_t}, arg7::Ptr{Glu_freeable_t{Int64}})::int_t
end
function symbfact_SubInit(options, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.symbfact_SubInit(options::Ptr{superlu_dist_options_t}, arg2::fact_t, arg3::Ptr{Cvoid}, arg4::int_t, arg5::int_t, arg6::int_t, arg7::int_t, arg8::Ptr{Glu_persist_t}, arg9::Ptr{Glu_freeable_t{Int64}})::int_t
end
function symbfact_SubXpand(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.symbfact_SubXpand(arg1::int_t, arg2::int_t, arg3::int_t, arg4::MemType, arg5::Ptr{int_t}, arg6::Ptr{Glu_freeable_t{Int64}})::int_t
end
function symbfact_SubFree(arg1)
@ccall libsuperlu_dist_Int64.symbfact_SubFree(arg1::Ptr{Glu_freeable_t{Int64}})::int_t
end
function countnz_dist(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.countnz_dist(arg1::int_t, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Glu_persist_t}, arg6::Ptr{Glu_freeable_t{Int64}})::Cvoid
end
function fixupL_dist(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.fixupL_dist(arg1::int_t, arg2::Ptr{int_t}, arg3::Ptr{Glu_persist_t}, arg4::Ptr{Glu_freeable_t{Int64}})::Int64
end
function TreePostorder_dist(arg1, arg2)
@ccall libsuperlu_dist_Int64.TreePostorder_dist(arg1::int_t, arg2::Ptr{int_t})::Ptr{int_t}
end
function smach_dist(arg1)
@ccall libsuperlu_dist_Int64.smach_dist(arg1::Ptr{Cchar})::Cfloat
end
function dmach_dist(arg1)
@ccall libsuperlu_dist_Int64.dmach_dist(arg1::Ptr{Cchar})::Cdouble
end
function int32Malloc_dist(arg1)
@ccall libsuperlu_dist_Int64.int32Malloc_dist(arg1::Cint)::Ptr{Cint}
end
function int32Calloc_dist(arg1)
@ccall libsuperlu_dist_Int64.int32Calloc_dist(arg1::Cint)::Ptr{Cint}
end
function intMalloc_dist(arg1)
@ccall libsuperlu_dist_Int64.intMalloc_dist(arg1::int_t)::Ptr{int_t}
end
function intCalloc_dist(arg1)
@ccall libsuperlu_dist_Int64.intCalloc_dist(arg1::int_t)::Ptr{int_t}
end
function mc64id_dist(arg1)
@ccall libsuperlu_dist_Int64.mc64id_dist(arg1::Ptr{Cint})::Cint
end
function arrive_at_ublock(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int64.arrive_at_ublock(arg1::int_t, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{int_t}, arg7::int_t, arg8::int_t, arg9::Ptr{int_t}, arg10::Ptr{int_t}, arg11::Ptr{int_t}, arg12::Ptr{gridinfo_t{Int64}})::Cvoid
end
function estimate_bigu_size(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.estimate_bigu_size(arg1::int_t, arg2::Ptr{Ptr{int_t}}, arg3::Ptr{Glu_persist_t}, arg4::Ptr{gridinfo_t{Int64}}, arg5::Ptr{int_t}, arg6::Ptr{int_t})::int_t
end
function sp_ienv_dist(arg1, arg2)
@ccall libsuperlu_dist_Int64.sp_ienv_dist(arg1::Cint, arg2::Ptr{superlu_dist_options_t})::Cint
end
function ifill_dist(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.ifill_dist(arg1::Ptr{int_t}, arg2::int_t, arg3::int_t)::Cvoid
end
function super_stats_dist(arg1, arg2)
@ccall libsuperlu_dist_Int64.super_stats_dist(arg1::int_t, arg2::Ptr{int_t})::Cvoid
end
function get_diag_procs(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.get_diag_procs(arg1::int_t, arg2::Ptr{Glu_persist_t}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{int_t}}, arg6::Ptr{Ptr{int_t}})::Cvoid
end
function QuerySpace_dist(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.QuerySpace_dist(arg1::int_t, arg2::int_t, arg3::Ptr{Glu_freeable_t{Int64}}, arg4::Ptr{superlu_dist_mem_usage_t})::int_t
end
function xerr_dist(arg1, arg2)
@ccall libsuperlu_dist_Int64.xerr_dist(arg1::Ptr{Cchar}, arg2::Ptr{Cint})::Cint
end
function pxerr_dist(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.pxerr_dist(arg1::Ptr{Cchar}, arg2::Ptr{gridinfo_t{Int64}}, arg3::int_t)::Cvoid
end
function PStatInit(arg1)
@ccall libsuperlu_dist_Int64.PStatInit(arg1::Ptr{SuperLUStat_t{Int64}})::Cvoid
end
function PStatFree(arg1)
@ccall libsuperlu_dist_Int64.PStatFree(arg1::Ptr{SuperLUStat_t{Int64}})::Cvoid
end
function PStatPrint(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.PStatPrint(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperLUStat_t{Int64}}, arg3::Ptr{gridinfo_t{Int64}})::Cvoid
end
function log_memory(arg1, arg2)
@ccall libsuperlu_dist_Int64.log_memory(arg1::Int64, arg2::Ptr{SuperLUStat_t{Int64}})::Cvoid
end
function print_memorylog(arg1, arg2)
@ccall libsuperlu_dist_Int64.print_memorylog(arg1::Ptr{SuperLUStat_t{Int64}}, arg2::Ptr{Cchar})::Cvoid
end
function superlu_dist_GetVersionNumber(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.superlu_dist_GetVersionNumber(arg1::Ptr{Cint}, arg2::Ptr{Cint}, arg3::Ptr{Cint})::Cint
end
function quickSort(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.quickSort(arg1::Ptr{int_t}, arg2::int_t, arg3::int_t, arg4::int_t)::Cvoid
end
function quickSortM(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.quickSortM(arg1::Ptr{int_t}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::int_t, arg6::int_t)::Cvoid
end
function partition(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.partition(arg1::Ptr{int_t}, arg2::int_t, arg3::int_t, arg4::int_t)::int_t
end
function partitionM(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.partitionM(arg1::Ptr{int_t}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::int_t, arg6::int_t)::int_t
end
function symbfact_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int64.symbfact_dist(arg1::Ptr{superlu_dist_options_t}, arg2::Cint, arg3::Cint, arg4::Ptr{SuperMatrix{Int64}}, arg5::Ptr{int_t}, arg6::Ptr{int_t}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{Pslu_freeable_t}, arg10::Ptr{MPI_Comm}, arg11::Ptr{MPI_Comm}, arg12::Ptr{superlu_dist_mem_usage_t})::Cfloat
end
function get_perm_c_parmetis(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.get_perm_c_parmetis(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Cint, arg5::Cint, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{gridinfo_t{Int64}}, arg9::Ptr{MPI_Comm})::Cfloat
end
function psymbfact_LUXpandMem(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int64.psymbfact_LUXpandMem(arg1::Cint, arg2::int_t, arg3::int_t, arg4::int_t, arg5::int_t, arg6::Cint, arg7::Cint, arg8::Cint, arg9::Ptr{Pslu_freeable_t}, arg10::Ptr{Llu_symbfact_t}, arg11::Ptr{vtcsInfo_symbfact_t}, arg12::Ptr{psymbfact_stat_t})::int_t
end
function psymbfact_LUXpand(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13)
@ccall libsuperlu_dist_Int64.psymbfact_LUXpand(arg1::int_t, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{int_t}, arg6::int_t, arg7::int_t, arg8::int_t, arg9::int_t, arg10::Ptr{Pslu_freeable_t}, arg11::Ptr{Llu_symbfact_t}, arg12::Ptr{vtcsInfo_symbfact_t}, arg13::Ptr{psymbfact_stat_t})::int_t
end
function psymbfact_LUXpand_RL(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int64.psymbfact_LUXpand_RL(arg1::int_t, arg2::int_t, arg3::int_t, arg4::int_t, arg5::int_t, arg6::int_t, arg7::Ptr{Pslu_freeable_t}, arg8::Ptr{Llu_symbfact_t}, arg9::Ptr{vtcsInfo_symbfact_t}, arg10::Ptr{psymbfact_stat_t})::int_t
end
function psymbfact_prLUXpand(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int64.psymbfact_prLUXpand(arg1::int_t, arg2::int_t, arg3::Cint, arg4::Ptr{Llu_symbfact_t}, arg5::Ptr{psymbfact_stat_t})::int_t
end
function isort(N, ARRAY1, ARRAY2)
@ccall libsuperlu_dist_Int64.isort(N::int_t, ARRAY1::Ptr{int_t}, ARRAY2::Ptr{int_t})::Cvoid
end
function isort1(N, ARRAY)
@ccall libsuperlu_dist_Int64.isort1(N::int_t, ARRAY::Ptr{int_t})::Cvoid
end
function estimate_cpu_time(m, n, k)
@ccall libsuperlu_dist_Int64.estimate_cpu_time(m::Cint, n::Cint, k::Cint)::Cdouble
end
# no prototype is found for this function at superlu_defs.h:1198:12, please use with caution
function get_thread_per_process()
@ccall libsuperlu_dist_Int64.get_thread_per_process()::Cint
end
# no prototype is found for this function at superlu_defs.h:1199:14, please use with caution
function get_max_buffer_size()
@ccall libsuperlu_dist_Int64.get_max_buffer_size()::int_t
end
function get_min(arg1, arg2)
@ccall libsuperlu_dist_Int64.get_min(arg1::Ptr{int_t}, arg2::int_t)::int_t
end
function compare_pair(arg1, arg2)
@ccall libsuperlu_dist_Int64.compare_pair(arg1::Ptr{Cvoid}, arg2::Ptr{Cvoid})::Cint
end
function static_partition(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.static_partition(arg1::Ptr{superlu_pair}, arg2::int_t, arg3::Ptr{int_t}, arg4::int_t, arg5::Ptr{int_t}, arg6::Ptr{int_t}, arg7::Cint)::int_t
end
# no prototype is found for this function at superlu_defs.h:1204:12, please use with caution
function get_acc_offload()
@ccall libsuperlu_dist_Int64.get_acc_offload()::Cint
end
function print_panel_seg_dist(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.print_panel_seg_dist(arg1::int_t, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{int_t}, arg6::Ptr{int_t})::Cvoid
end
function check_repfnz_dist(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.check_repfnz_dist(arg1::int_t, arg2::int_t, arg3::int_t, arg4::Ptr{int_t})::Cvoid
end
function CheckZeroDiagonal(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.CheckZeroDiagonal(arg1::int_t, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t})::int_t
end
function check_perm_dist(what, n, perm)
@ccall libsuperlu_dist_Int64.check_perm_dist(what::Ptr{Cchar}, n::int_t, perm::Ptr{int_t})::Cint
end
function PrintDouble5(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.PrintDouble5(arg1::Ptr{Cchar}, arg2::int_t, arg3::Ptr{Cdouble})::Cvoid
end
function PrintInt10(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.PrintInt10(arg1::Ptr{Cchar}, arg2::int_t, arg3::Ptr{int_t})::Cvoid
end
function PrintInt32(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.PrintInt32(arg1::Ptr{Cchar}, arg2::Cint, arg3::Ptr{Cint})::Cvoid
end
function file_PrintInt10(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.file_PrintInt10(arg1::Ptr{Libc.FILE}, arg2::Ptr{Cchar}, arg3::int_t, arg4::Ptr{int_t})::Cint
end
function file_PrintInt32(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.file_PrintInt32(arg1::Ptr{Libc.FILE}, arg2::Ptr{Cchar}, arg3::Cint, arg4::Ptr{Cint})::Cint
end
function file_PrintLong10(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.file_PrintLong10(arg1::Ptr{Libc.FILE}, arg2::Ptr{Cchar}, arg3::int_t, arg4::Ptr{int_t})::Cint
end
function C_RdTree_Create(tree, comm, ranks, rank_cnt, msgSize, precision)
@ccall libsuperlu_dist_Int64.C_RdTree_Create(tree::Ptr{C_Tree}, comm::MPI_Comm, ranks::Ptr{Cint}, rank_cnt::Cint, msgSize::Cint, precision::Cchar)::Cvoid
end
function C_RdTree_Nullify(tree)
@ccall libsuperlu_dist_Int64.C_RdTree_Nullify(tree::Ptr{C_Tree})::Cvoid
end
function C_RdTree_IsRoot(tree)
@ccall libsuperlu_dist_Int64.C_RdTree_IsRoot(tree::Ptr{C_Tree})::yes_no_t
end
function C_RdTree_forwardMessageSimple(Tree, localBuffer, msgSize)
@ccall libsuperlu_dist_Int64.C_RdTree_forwardMessageSimple(Tree::Ptr{C_Tree}, localBuffer::Ptr{Cvoid}, msgSize::Cint)::Cvoid
end
function C_RdTree_waitSendRequest(Tree)
@ccall libsuperlu_dist_Int64.C_RdTree_waitSendRequest(Tree::Ptr{C_Tree})::Cvoid
end
function C_BcTree_Create(tree, comm, ranks, rank_cnt, msgSize, precision)
@ccall libsuperlu_dist_Int64.C_BcTree_Create(tree::Ptr{C_Tree}, comm::MPI_Comm, ranks::Ptr{Cint}, rank_cnt::Cint, msgSize::Cint, precision::Cchar)::Cvoid
end
function C_BcTree_Nullify(tree)
@ccall libsuperlu_dist_Int64.C_BcTree_Nullify(tree::Ptr{C_Tree})::Cvoid
end
function C_BcTree_IsRoot(tree)
@ccall libsuperlu_dist_Int64.C_BcTree_IsRoot(tree::Ptr{C_Tree})::yes_no_t
end
function C_BcTree_forwardMessageSimple(tree, localBuffer, msgSize)
@ccall libsuperlu_dist_Int64.C_BcTree_forwardMessageSimple(tree::Ptr{C_Tree}, localBuffer::Ptr{Cvoid}, msgSize::Cint)::Cvoid
end
function C_BcTree_waitSendRequest(tree)
@ccall libsuperlu_dist_Int64.C_BcTree_waitSendRequest(tree::Ptr{C_Tree})::Cvoid
end
function DistPrint(function_name, value, Units, grid)
@ccall libsuperlu_dist_Int64.DistPrint(function_name::Ptr{Cchar}, value::Cdouble, Units::Ptr{Cchar}, grid::Ptr{gridinfo_t{Int64}})::Cvoid
end
function DistPrint3D(function_name, value, Units, grid3d)
@ccall libsuperlu_dist_Int64.DistPrint3D(function_name::Ptr{Cchar}, value::Cdouble, Units::Ptr{Cchar}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cvoid
end
function treeImbalance3D(grid3d, SCT)
@ccall libsuperlu_dist_Int64.treeImbalance3D(grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::Cvoid
end
function SCT_printComm3D(grid3d, SCT)
@ccall libsuperlu_dist_Int64.SCT_printComm3D(grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::Cvoid
end
function getPerm_c_supno(nsupers, arg2, etree, Glu_persist, Lrowind_bc_ptr, Ufstnz_br_ptr, arg7)
@ccall libsuperlu_dist_Int64.getPerm_c_supno(nsupers::int_t, arg2::Ptr{superlu_dist_options_t}, etree::Ptr{int_t}, Glu_persist::Ptr{Glu_persist_t}, Lrowind_bc_ptr::Ptr{Ptr{int_t}}, Ufstnz_br_ptr::Ptr{Ptr{int_t}}, arg7::Ptr{gridinfo_t{Int64}})::Ptr{int_t}
end
function SCT_init(arg1)
@ccall libsuperlu_dist_Int64.SCT_init(arg1::Ptr{SCT_t})::Cvoid
end
function SCT_print(grid, SCT)
@ccall libsuperlu_dist_Int64.SCT_print(grid::Ptr{gridinfo_t{Int64}}, SCT::Ptr{SCT_t})::Cvoid
end
function SCT_print3D(grid3d, SCT)
@ccall libsuperlu_dist_Int64.SCT_print3D(grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::Cvoid
end
function SCT_free(arg1)
@ccall libsuperlu_dist_Int64.SCT_free(arg1::Ptr{SCT_t})::Cvoid
end
function setree2list(nsuper, setree)
@ccall libsuperlu_dist_Int64.setree2list(nsuper::int_t, setree::Ptr{int_t})::Ptr{treeList_t{Int64}}
end
function free_treelist(nsuper, treeList)
@ccall libsuperlu_dist_Int64.free_treelist(nsuper::int_t, treeList::Ptr{treeList_t{Int64}})::Cint
end
function calcTreeWeight(nsupers, setree, treeList, xsup)
@ccall libsuperlu_dist_Int64.calcTreeWeight(nsupers::int_t, setree::Ptr{int_t}, treeList::Ptr{treeList_t{Int64}}, xsup::Ptr{int_t})::int_t
end
function getDescendList(k, dlist, treeList)
@ccall libsuperlu_dist_Int64.getDescendList(k::int_t, dlist::Ptr{int_t}, treeList::Ptr{treeList_t{Int64}})::int_t
end
function getCommonAncestorList(k, alist, seTree, treeList)
@ccall libsuperlu_dist_Int64.getCommonAncestorList(k::int_t, alist::Ptr{int_t}, seTree::Ptr{int_t}, treeList::Ptr{treeList_t{Int64}})::int_t
end
function getCommonAncsCount(k, treeList)
@ccall libsuperlu_dist_Int64.getCommonAncsCount(k::int_t, treeList::Ptr{treeList_t{Int64}})::int_t
end
function getPermNodeList(nnode, nlist, perm_c_sup, iperm_c_sup)
@ccall libsuperlu_dist_Int64.getPermNodeList(nnode::int_t, nlist::Ptr{int_t}, perm_c_sup::Ptr{int_t}, iperm_c_sup::Ptr{int_t})::Ptr{int_t}
end
function getEtreeLB(nnodes, perm_l, gTopOrder)
@ccall libsuperlu_dist_Int64.getEtreeLB(nnodes::int_t, perm_l::Ptr{int_t}, gTopOrder::Ptr{int_t})::Ptr{int_t}
end
function getSubTreeRoots(k, treeList)
@ccall libsuperlu_dist_Int64.getSubTreeRoots(k::int_t, treeList::Ptr{treeList_t{Int64}})::Ptr{int_t}
end
function merg_perms(nperms, nnodes, perms)
@ccall libsuperlu_dist_Int64.merg_perms(nperms::int_t, nnodes::Ptr{int_t}, perms::Ptr{Ptr{int_t}})::Ptr{int_t}
end
function getGlobal_iperm(nsupers, nperms, perms, nnodes)
@ccall libsuperlu_dist_Int64.getGlobal_iperm(nsupers::int_t, nperms::int_t, perms::Ptr{Ptr{int_t}}, nnodes::Ptr{int_t})::Ptr{int_t}
end
function log2i(index)
@ccall libsuperlu_dist_Int64.log2i(index::int_t)::int_t
end
function supernodal_etree(nsuper, etree, supno, xsup)
@ccall libsuperlu_dist_Int64.supernodal_etree(nsuper::int_t, etree::Ptr{int_t}, supno::Ptr{int_t}, xsup::Ptr{int_t})::Ptr{int_t}
end
function testSubtreeNodelist(nsupers, numList, nodeList, nodeCount)
@ccall libsuperlu_dist_Int64.testSubtreeNodelist(nsupers::int_t, numList::int_t, nodeList::Ptr{Ptr{int_t}}, nodeCount::Ptr{int_t})::int_t
end
function testListPerm(nodeCount, nodeList, permList, gTopLevel)
@ccall libsuperlu_dist_Int64.testListPerm(nodeCount::int_t, nodeList::Ptr{int_t}, permList::Ptr{int_t}, gTopLevel::Ptr{int_t})::int_t
end
function topological_ordering(nsuper, setree)
@ccall libsuperlu_dist_Int64.topological_ordering(nsuper::int_t, setree::Ptr{int_t})::Ptr{int_t}
end
function Etree_LevelBoundry(perm, tsort_etree, nsuper)
@ccall libsuperlu_dist_Int64.Etree_LevelBoundry(perm::Ptr{int_t}, tsort_etree::Ptr{int_t}, nsuper::int_t)::Ptr{int_t}
end
function calculate_num_children(nsuper, setree)
@ccall libsuperlu_dist_Int64.calculate_num_children(nsuper::int_t, setree::Ptr{int_t})::Ptr{int_t}
end
function Print_EtreeLevelBoundry(Etree_LvlBdry, max_level, nsuper)
@ccall libsuperlu_dist_Int64.Print_EtreeLevelBoundry(Etree_LvlBdry::Ptr{int_t}, max_level::int_t, nsuper::int_t)::Cvoid
end
function print_etree_leveled(setree, tsort_etree, nsuper)
@ccall libsuperlu_dist_Int64.print_etree_leveled(setree::Ptr{int_t}, tsort_etree::Ptr{int_t}, nsuper::int_t)::Cvoid
end
function print_etree(setree, iperm, nsuper)
@ccall libsuperlu_dist_Int64.print_etree(setree::Ptr{int_t}, iperm::Ptr{int_t}, nsuper::int_t)::Cvoid
end
function printFileList(sname, nnodes, dlist, setree)
@ccall libsuperlu_dist_Int64.printFileList(sname::Ptr{Cchar}, nnodes::int_t, dlist::Ptr{int_t}, setree::Ptr{int_t})::int_t
end
function getLastDepBtree(nsupers, treeList)
@ccall libsuperlu_dist_Int64.getLastDepBtree(nsupers::int_t, treeList::Ptr{treeList_t{Int64}})::Ptr{Cint}
end
function getReplicatedTrees(grid3d)
@ccall libsuperlu_dist_Int64.getReplicatedTrees(grid3d::Ptr{gridinfo3d_t{Int64}})::Ptr{int_t}
end
function getGridTrees(grid3d)
@ccall libsuperlu_dist_Int64.getGridTrees(grid3d::Ptr{gridinfo3d_t{Int64}})::Ptr{int_t}
end
function getNodeList(maxLvl, setree, nnodes, treeHeads, treeList)
@ccall libsuperlu_dist_Int64.getNodeList(maxLvl::int_t, setree::Ptr{int_t}, nnodes::Ptr{int_t}, treeHeads::Ptr{int_t}, treeList::Ptr{treeList_t{Int64}})::Ptr{Ptr{int_t}}
end
function calcNumNodes(maxLvl, treeHeads, treeList)
@ccall libsuperlu_dist_Int64.calcNumNodes(maxLvl::int_t, treeHeads::Ptr{int_t}, treeList::Ptr{treeList_t{Int64}})::Ptr{int_t}
end
function getTreeHeads(maxLvl, nsupers, treeList)
@ccall libsuperlu_dist_Int64.getTreeHeads(maxLvl::int_t, nsupers::int_t, treeList::Ptr{treeList_t{Int64}})::Ptr{int_t}
end
function getMyIperm(nnodes, nsupers, myPerm)
@ccall libsuperlu_dist_Int64.getMyIperm(nnodes::int_t, nsupers::int_t, myPerm::Ptr{int_t})::Ptr{int_t}
end
function getMyTopOrder(nnodes, myPerm, myIperm, setree)
@ccall libsuperlu_dist_Int64.getMyTopOrder(nnodes::int_t, myPerm::Ptr{int_t}, myIperm::Ptr{int_t}, setree::Ptr{int_t})::Ptr{int_t}
end
function getMyEtLims(nnodes, myTopOrder)
@ccall libsuperlu_dist_Int64.getMyEtLims(nnodes::int_t, myTopOrder::Ptr{int_t})::Ptr{int_t}
end
function getMyTreeTopoInfo(nnodes, nsupers, myPerm, setree)
@ccall libsuperlu_dist_Int64.getMyTreeTopoInfo(nnodes::int_t, nsupers::int_t, myPerm::Ptr{int_t}, setree::Ptr{int_t})::treeTopoInfo_t{Int64}
end
function getNestDissForests(maxLvl, nsupers, setree, treeList)
@ccall libsuperlu_dist_Int64.getNestDissForests(maxLvl::int_t, nsupers::int_t, setree::Ptr{int_t}, treeList::Ptr{treeList_t{Int64}})::Ptr{Ptr{sForest_t{Int64}}}
end
function getTreePermForest(myTreeIdxs, myZeroTrIdxs, sForests, perm_c_supno, iperm_c_supno, grid3d)
@ccall libsuperlu_dist_Int64.getTreePermForest(myTreeIdxs::Ptr{int_t}, myZeroTrIdxs::Ptr{int_t}, sForests::Ptr{sForest_t{Int64}}, perm_c_supno::Ptr{int_t}, iperm_c_supno::Ptr{int_t}, grid3d::Ptr{gridinfo3d_t{Int64}})::Ptr{Ptr{int_t}}
end
function getTreePermFr(myTreeIdxs, sForests, grid3d)
@ccall libsuperlu_dist_Int64.getTreePermFr(myTreeIdxs::Ptr{int_t}, sForests::Ptr{Ptr{sForest_t{Int64}}}, grid3d::Ptr{gridinfo3d_t{Int64}})::Ptr{Ptr{int_t}}
end
function getMyNodeCountsFr(maxLvl, myTreeIdxs, sForests)
@ccall libsuperlu_dist_Int64.getMyNodeCountsFr(maxLvl::int_t, myTreeIdxs::Ptr{int_t}, sForests::Ptr{Ptr{sForest_t{Int64}}})::Ptr{int_t}
end
function getNodeListFr(maxLvl, sForests)
@ccall libsuperlu_dist_Int64.getNodeListFr(maxLvl::int_t, sForests::Ptr{Ptr{sForest_t{Int64}}})::Ptr{Ptr{int_t}}
end
function getNodeCountsFr(maxLvl, sForests)
@ccall libsuperlu_dist_Int64.getNodeCountsFr(maxLvl::int_t, sForests::Ptr{Ptr{sForest_t{Int64}}})::Ptr{int_t}
end
function getIsNodeInMyGrid(nsupers, maxLvl, myNodeCount, treePerm)
@ccall libsuperlu_dist_Int64.getIsNodeInMyGrid(nsupers::int_t, maxLvl::int_t, myNodeCount::Ptr{int_t}, treePerm::Ptr{Ptr{int_t}})::Ptr{Cint}
end
function printForestWeightCost(sForests, SCT, grid3d)
@ccall libsuperlu_dist_Int64.printForestWeightCost(sForests::Ptr{Ptr{sForest_t{Int64}}}, SCT::Ptr{SCT_t}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cvoid
end
function getGreedyLoadBalForests(maxLvl, nsupers, setree, treeList)
@ccall libsuperlu_dist_Int64.getGreedyLoadBalForests(maxLvl::int_t, nsupers::int_t, setree::Ptr{int_t}, treeList::Ptr{treeList_t{Int64}})::Ptr{Ptr{sForest_t{Int64}}}
end
function getForests(maxLvl, nsupers, setree, treeList)
@ccall libsuperlu_dist_Int64.getForests(maxLvl::int_t, nsupers::int_t, setree::Ptr{int_t}, treeList::Ptr{treeList_t{Int64}})::Ptr{Ptr{sForest_t{Int64}}}
end
function getBigUSize(arg1, nsupers, grid, Lrowind_bc_ptr)
@ccall libsuperlu_dist_Int64.getBigUSize(arg1::Ptr{superlu_dist_options_t}, nsupers::int_t, grid::Ptr{gridinfo_t{Int64}}, Lrowind_bc_ptr::Ptr{Ptr{int_t}})::int_t
end
function getSCUweight(nsupers, treeList, xsup, Lrowind_bc_ptr, Ufstnz_br_ptr, grid3d)
@ccall libsuperlu_dist_Int64.getSCUweight(nsupers::int_t, treeList::Ptr{treeList_t{Int64}}, xsup::Ptr{int_t}, Lrowind_bc_ptr::Ptr{Ptr{int_t}}, Ufstnz_br_ptr::Ptr{Ptr{int_t}}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cvoid
end
function Wait_LUDiagSend(k, U_diag_blk_send_req, L_diag_blk_send_req, grid, SCT)
@ccall libsuperlu_dist_Int64.Wait_LUDiagSend(k::int_t, U_diag_blk_send_req::Ptr{MPI_Request}, L_diag_blk_send_req::Ptr{MPI_Request}, grid::Ptr{gridinfo_t{Int64}}, SCT::Ptr{SCT_t})::Cint
end
# no prototype is found for this function at superlu_defs.h:1368:12, please use with caution
function set_tag_ub()
@ccall libsuperlu_dist_Int64.set_tag_ub()::Cint
end
function getNumThreads(arg1)
@ccall libsuperlu_dist_Int64.getNumThreads(arg1::Cint)::Cint
end
function num_full_cols_U(kk, Ufstnz_br_ptr, xsup, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.num_full_cols_U(kk::int_t, Ufstnz_br_ptr::Ptr{Ptr{int_t}}, xsup::Ptr{int_t}, arg4::Ptr{gridinfo_t{Int64}}, arg5::Ptr{int_t}, arg6::Ptr{int_t})::int_t
end
function getFactPerm(arg1)
@ccall libsuperlu_dist_Int64.getFactPerm(arg1::int_t)::Ptr{int_t}
end
function getFactIperm(arg1, arg2)
@ccall libsuperlu_dist_Int64.getFactIperm(arg1::Ptr{int_t}, arg2::int_t)::Ptr{int_t}
end
function initCommRequests(comReqs, grid)
@ccall libsuperlu_dist_Int64.initCommRequests(comReqs::Ptr{commRequests_t}, grid::Ptr{gridinfo_t{Int64}})::int_t
end
function initFactStat(nsupers, factStat)
@ccall libsuperlu_dist_Int64.initFactStat(nsupers::int_t, factStat::Ptr{factStat_t{Int64}})::int_t
end
function freeFactStat(factStat)
@ccall libsuperlu_dist_Int64.freeFactStat(factStat::Ptr{factStat_t{Int64}})::Cint
end
function initFactNodelists(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.initFactNodelists(arg1::int_t, arg2::int_t, arg3::int_t, arg4::Ptr{factNodelists_t{Int64}})::int_t
end
function freeFactNodelists(fNlists)
@ccall libsuperlu_dist_Int64.freeFactNodelists(fNlists::Ptr{factNodelists_t{Int64}})::Cint
end
function initMsgs(msgs)
@ccall libsuperlu_dist_Int64.initMsgs(msgs::Ptr{msgs_t})::int_t
end
function getNumLookAhead(arg1)
@ccall libsuperlu_dist_Int64.getNumLookAhead(arg1::Ptr{superlu_dist_options_t})::int_t
end
function initCommRequestsArr(mxLeafNode, ldt, grid)
@ccall libsuperlu_dist_Int64.initCommRequestsArr(mxLeafNode::int_t, ldt::int_t, grid::Ptr{gridinfo_t{Int64}})::Ptr{Ptr{commRequests_t}}
end
function freeCommRequestsArr(mxLeafNode, comReqss)
@ccall libsuperlu_dist_Int64.freeCommRequestsArr(mxLeafNode::int_t, comReqss::Ptr{Ptr{commRequests_t}})::Cint
end
function initMsgsArr(numLA)
@ccall libsuperlu_dist_Int64.initMsgsArr(numLA::int_t)::Ptr{Ptr{msgs_t}}
end
function freeMsgsArr(numLA, msgss)
@ccall libsuperlu_dist_Int64.freeMsgsArr(numLA::int_t, msgss::Ptr{Ptr{msgs_t}})::Cint
end
function Trs2_InitUblock_info(klst, nb, arg3, usub, arg5, arg6)
@ccall libsuperlu_dist_Int64.Trs2_InitUblock_info(klst::int_t, nb::int_t, arg3::Ptr{Ublock_info_t}, usub::Ptr{int_t}, arg5::Ptr{Glu_persist_t}, arg6::Ptr{SuperLUStat_t{Int64}})::int_t
end
function Cmpfunc_R_info(a, b)
@ccall libsuperlu_dist_Int64.Cmpfunc_R_info(a::Ptr{Cvoid}, b::Ptr{Cvoid})::Cint
end
function Cmpfunc_U_info(a, b)
@ccall libsuperlu_dist_Int64.Cmpfunc_U_info(a::Ptr{Cvoid}, b::Ptr{Cvoid})::Cint
end
function sort_R_info(Remain_info, n)
@ccall libsuperlu_dist_Int64.sort_R_info(Remain_info::Ptr{Remain_info_t}, n::Cint)::Cint
end
function sort_U_info(Ublock_info, n)
@ccall libsuperlu_dist_Int64.sort_U_info(Ublock_info::Ptr{Ublock_info_t}, n::Cint)::Cint
end
function sort_R_info_elm(Remain_info, n)
@ccall libsuperlu_dist_Int64.sort_R_info_elm(Remain_info::Ptr{Remain_info_t}, n::Cint)::Cint
end
function sort_U_info_elm(Ublock_info, n)
@ccall libsuperlu_dist_Int64.sort_U_info_elm(Ublock_info::Ptr{Ublock_info_t}, n::Cint)::Cint
end
function printTRStimer(xtrsTimer, grid3d)
@ccall libsuperlu_dist_Int64.printTRStimer(xtrsTimer::Ptr{xtrsTimer_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cvoid
end
function initTRStimer(xtrsTimer, grid)
@ccall libsuperlu_dist_Int64.initTRStimer(xtrsTimer::Ptr{xtrsTimer_t{Int64}}, grid::Ptr{gridinfo_t{Int64}})::Cvoid
end
function getTreePerm(myTreeIdxs, myZeroTrIdxs, nodeCount, nodeList, perm_c_supno, iperm_c_supno, grid3d)
@ccall libsuperlu_dist_Int64.getTreePerm(myTreeIdxs::Ptr{int_t}, myZeroTrIdxs::Ptr{int_t}, nodeCount::Ptr{int_t}, nodeList::Ptr{Ptr{int_t}}, perm_c_supno::Ptr{int_t}, iperm_c_supno::Ptr{int_t}, grid3d::Ptr{gridinfo3d_t{Int64}})::Ptr{Ptr{int_t}}
end
function getMyNodeCounts(maxLvl, myTreeIdxs, gNodeCount)
@ccall libsuperlu_dist_Int64.getMyNodeCounts(maxLvl::int_t, myTreeIdxs::Ptr{int_t}, gNodeCount::Ptr{int_t})::Ptr{int_t}
end
function checkIntVector3d(vec, len, grid3d)
@ccall libsuperlu_dist_Int64.checkIntVector3d(vec::Ptr{int_t}, len::int_t, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function reduceStat(PHASE, stat, grid3d)
@ccall libsuperlu_dist_Int64.reduceStat(PHASE::PhaseType, stat::Ptr{SuperLUStat_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function Wait_LSend(k, grid, ToSendR, s, arg5)
@ccall libsuperlu_dist_Int64.Wait_LSend(k::int_t, grid::Ptr{gridinfo_t{Int64}}, ToSendR::Ptr{Ptr{Cint}}, s::Ptr{MPI_Request}, arg5::Ptr{SCT_t})::int_t
end
function Wait_USend(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.Wait_USend(arg1::Ptr{MPI_Request}, arg2::Ptr{gridinfo_t{Int64}}, arg3::Ptr{SCT_t})::int_t
end
function Check_LRecv(arg1, msgcnt)
@ccall libsuperlu_dist_Int64.Check_LRecv(arg1::Ptr{MPI_Request}, msgcnt::Ptr{Cint})::int_t
end
function Wait_UDiagBlockSend(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.Wait_UDiagBlockSend(arg1::Ptr{MPI_Request}, arg2::Ptr{gridinfo_t{Int64}}, arg3::Ptr{SCT_t})::int_t
end
function Wait_LDiagBlockSend(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.Wait_LDiagBlockSend(arg1::Ptr{MPI_Request}, arg2::Ptr{gridinfo_t{Int64}}, arg3::Ptr{SCT_t})::int_t
end
function Wait_UDiagBlock_Recv(arg1, arg2)
@ccall libsuperlu_dist_Int64.Wait_UDiagBlock_Recv(arg1::Ptr{MPI_Request}, arg2::Ptr{SCT_t})::int_t
end
function Test_UDiagBlock_Recv(arg1, arg2)
@ccall libsuperlu_dist_Int64.Test_UDiagBlock_Recv(arg1::Ptr{MPI_Request}, arg2::Ptr{SCT_t})::int_t
end
function Wait_LDiagBlock_Recv(arg1, arg2)
@ccall libsuperlu_dist_Int64.Wait_LDiagBlock_Recv(arg1::Ptr{MPI_Request}, arg2::Ptr{SCT_t})::int_t
end
function Test_LDiagBlock_Recv(arg1, arg2)
@ccall libsuperlu_dist_Int64.Test_LDiagBlock_Recv(arg1::Ptr{MPI_Request}, arg2::Ptr{SCT_t})::int_t
end
function sCreate_CompCol_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int64.sCreate_CompCol_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{Cfloat}, arg6::Ptr{int_t}, arg7::Ptr{int_t}, arg8::Stype_t, arg9::Dtype_t, arg10::Mtype_t)::Cvoid
end
function sCreate_CompRowLoc_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int64.sCreate_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::int_t, arg6::int_t, arg7::Ptr{Cfloat}, arg8::Ptr{int_t}, arg9::Ptr{int_t}, arg10::Stype_t, arg11::Dtype_t, arg12::Mtype_t)::Cvoid
end
function sCompRow_to_CompCol_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.sCompRow_to_CompCol_dist(arg1::int_t, arg2::int_t, arg3::int_t, arg4::Ptr{Cfloat}, arg5::Ptr{int_t}, arg6::Ptr{int_t}, arg7::Ptr{Ptr{Cfloat}}, arg8::Ptr{Ptr{int_t}}, arg9::Ptr{Ptr{int_t}})::Cvoid
end
function psCompRow_loc_to_CompCol_global(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.psCompRow_loc_to_CompCol_global(arg1::int_t, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{SuperMatrix{Int64}})::Cint
end
function sCopy_CompCol_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int64.sCopy_CompCol_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{SuperMatrix{Int64}})::Cvoid
end
function sCreate_Dense_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.sCreate_Dense_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::int_t, arg3::int_t, arg4::Ptr{Cfloat}, arg5::int_t, arg6::Stype_t, arg7::Dtype_t, arg8::Mtype_t)::Cvoid
end
function sCreate_SuperNode_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13)
@ccall libsuperlu_dist_Int64.sCreate_SuperNode_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{Cfloat}, arg6::Ptr{int_t}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{int_t}, arg10::Ptr{int_t}, arg11::Stype_t, arg12::Dtype_t, arg13::Mtype_t)::Cvoid
end
function sCopy_Dense_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.sCopy_Dense_Matrix_dist(arg1::int_t, arg2::int_t, arg3::Ptr{Cfloat}, arg4::int_t, arg5::Ptr{Cfloat}, arg6::int_t)::Cvoid
end
function sallocateA_dist(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int64.sallocateA_dist(arg1::int_t, arg2::int_t, arg3::Ptr{Ptr{Cfloat}}, arg4::Ptr{Ptr{int_t}}, arg5::Ptr{Ptr{int_t}})::Cvoid
end
function sGenXtrue_dist(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.sGenXtrue_dist(arg1::int_t, arg2::int_t, arg3::Ptr{Cfloat}, arg4::int_t)::Cvoid
end
function sFillRHS_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.sFillRHS_dist(arg1::Ptr{Cchar}, arg2::int_t, arg3::Ptr{Cfloat}, arg4::int_t, arg5::Ptr{SuperMatrix{Int64}}, arg6::Ptr{Cfloat}, arg7::int_t)::Cvoid
end
function screate_matrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.screate_matrix(arg1::Ptr{SuperMatrix{Int64}}, arg2::Cint, arg3::Ptr{Ptr{Cfloat}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{Cfloat}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{gridinfo_t{Int64}})::Cint
end
function screate_matrix_rb(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.screate_matrix_rb(arg1::Ptr{SuperMatrix{Int64}}, arg2::Cint, arg3::Ptr{Ptr{Cfloat}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{Cfloat}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{gridinfo_t{Int64}})::Cint
end
function screate_matrix_dat(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.screate_matrix_dat(arg1::Ptr{SuperMatrix{Int64}}, arg2::Cint, arg3::Ptr{Ptr{Cfloat}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{Cfloat}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{gridinfo_t{Int64}})::Cint
end
function screate_matrix_postfix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.screate_matrix_postfix(arg1::Ptr{SuperMatrix{Int64}}, arg2::Cint, arg3::Ptr{Ptr{Cfloat}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{Cfloat}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{Cchar}, arg9::Ptr{gridinfo_t{Int64}})::Cint
end
function sScalePermstructInit(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.sScalePermstructInit(arg1::int_t, arg2::int_t, arg3::Ptr{sScalePermstruct_t{Int64}})::Cvoid
end
function sScalePermstructFree(arg1)
@ccall libsuperlu_dist_Int64.sScalePermstructFree(arg1::Ptr{sScalePermstruct_t{Int64}})::Cvoid
end
function sgsequ_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.sgsequ_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{Cfloat}, arg3::Ptr{Cfloat}, arg4::Ptr{Cfloat}, arg5::Ptr{Cfloat}, arg6::Ptr{Cfloat}, arg7::Ptr{int_t})::Cvoid
end
function slangs_dist(arg1, arg2)
@ccall libsuperlu_dist_Int64.slangs_dist(arg1::Ptr{Cchar}, arg2::Ptr{SuperMatrix{Int64}})::Cfloat
end
function slaqgs_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.slaqgs_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{Cfloat}, arg3::Ptr{Cfloat}, arg4::Cfloat, arg5::Cfloat, arg6::Cfloat, arg7::Ptr{Cchar})::Cvoid
end
function psgsequ(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.psgsequ(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{Cfloat}, arg3::Ptr{Cfloat}, arg4::Ptr{Cfloat}, arg5::Ptr{Cfloat}, arg6::Ptr{Cfloat}, arg7::Ptr{int_t}, arg8::Ptr{gridinfo_t{Int64}})::Cvoid
end
function pslangs(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.pslangs(arg1::Ptr{Cchar}, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{gridinfo_t{Int64}})::Cfloat
end
function pslaqgs(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.pslaqgs(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{Cfloat}, arg3::Ptr{Cfloat}, arg4::Cfloat, arg5::Cfloat, arg6::Cfloat, arg7::Ptr{Cchar})::Cvoid
end
function psPermute_Dense_Matrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int64.psPermute_Dense_Matrix(arg1::int_t, arg2::int_t, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Cfloat}, arg6::Cint, arg7::Ptr{Cfloat}, arg8::Cint, arg9::Cint, arg10::Ptr{gridinfo_t{Int64}})::Cint
end
function sp_strsv_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.sp_strsv_dist(arg1::Ptr{Cchar}, arg2::Ptr{Cchar}, arg3::Ptr{Cchar}, arg4::Ptr{SuperMatrix{Int64}}, arg5::Ptr{SuperMatrix{Int64}}, arg6::Ptr{Cfloat}, arg7::Ptr{Cint})::Cint
end
function sp_sgemv_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.sp_sgemv_dist(arg1::Ptr{Cchar}, arg2::Cfloat, arg3::Ptr{SuperMatrix{Int64}}, arg4::Ptr{Cfloat}, arg5::Cint, arg6::Cfloat, arg7::Ptr{Cfloat}, arg8::Cint)::Cint
end
function sp_sgemm_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.sp_sgemm_dist(arg1::Ptr{Cchar}, arg2::Cint, arg3::Cfloat, arg4::Ptr{SuperMatrix{Int64}}, arg5::Ptr{Cfloat}, arg6::Cint, arg7::Cfloat, arg8::Ptr{Cfloat}, arg9::Cint)::Cint
end
function sdistribute(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.sdistribute(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int64}}, arg4::Ptr{Glu_freeable_t{Int64}}, arg5::Ptr{sLUstruct_t{Int64}}, arg6::Ptr{gridinfo_t{Int64}})::Cfloat
end
function psgssvx_ABglobal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
@ccall libsuperlu_dist_Int64.psgssvx_ABglobal(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{sScalePermstruct_t{Int64}}, arg4::Ptr{Cfloat}, arg5::Cint, arg6::Cint, arg7::Ptr{gridinfo_t{Int64}}, arg8::Ptr{sLUstruct_t{Int64}}, arg9::Ptr{Cfloat}, arg10::Ptr{SuperLUStat_t{Int64}}, arg11::Ptr{Cint})::Cvoid
end
function psdistribute(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.psdistribute(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int64}}, arg4::Ptr{sScalePermstruct_t{Int64}}, arg5::Ptr{Glu_freeable_t{Int64}}, arg6::Ptr{sLUstruct_t{Int64}}, arg7::Ptr{gridinfo_t{Int64}})::Cfloat
end
function psgssvx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int64.psgssvx(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{sScalePermstruct_t{Int64}}, arg4::Ptr{Cfloat}, arg5::Cint, arg6::Cint, arg7::Ptr{gridinfo_t{Int64}}, arg8::Ptr{sLUstruct_t{Int64}}, arg9::Ptr{sSOLVEstruct_t{Int64}}, arg10::Ptr{Cfloat}, arg11::Ptr{SuperLUStat_t{Int64}}, arg12::Ptr{Cint})::Cvoid
end
function psCompute_Diag_Inv(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int64.psCompute_Diag_Inv(arg1::int_t, arg2::Ptr{sLUstruct_t{Int64}}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{SuperLUStat_t{Int64}}, arg5::Ptr{Cint})::Cvoid
end
function sSolveInit(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.sSolveInit(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::int_t, arg6::Ptr{sLUstruct_t{Int64}}, arg7::Ptr{gridinfo_t{Int64}}, arg8::Ptr{sSOLVEstruct_t{Int64}})::Cint
end
function sSolveFinalize(arg1, arg2)
@ccall libsuperlu_dist_Int64.sSolveFinalize(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{sSOLVEstruct_t{Int64}})::Cvoid
end
function sDestroy_A3d_gathered_on_2d(arg1, arg2)
@ccall libsuperlu_dist_Int64.sDestroy_A3d_gathered_on_2d(arg1::Ptr{sSOLVEstruct_t{Int64}}, arg2::Ptr{gridinfo3d_t{Int64}})::Cvoid
end
function psgstrs_init(arg1, arg2, arg3, arg4, arg5, arg6, grid, arg8, arg9)
@ccall libsuperlu_dist_Int64.psgstrs_init(arg1::int_t, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{int_t}, arg6::Ptr{int_t}, grid::Ptr{gridinfo_t{Int64}}, arg8::Ptr{Glu_persist_t}, arg9::Ptr{sSOLVEstruct_t{Int64}})::int_t
end
function sldperm_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.sldperm_dist(arg1::Cint, arg2::Cint, arg3::int_t, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{Cfloat}, arg7::Ptr{int_t}, arg8::Ptr{Cfloat}, arg9::Ptr{Cfloat})::Cint
end
function sstatic_schedule(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.sstatic_schedule(arg1::Ptr{superlu_dist_options_t}, arg2::Cint, arg3::Cint, arg4::Ptr{sLUstruct_t{Int64}}, arg5::Ptr{gridinfo_t{Int64}}, arg6::Ptr{SuperLUStat_t{Int64}}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{Cint})::Cint
end
function sLUstructInit(arg1, arg2)
@ccall libsuperlu_dist_Int64.sLUstructInit(arg1::int_t, arg2::Ptr{sLUstruct_t{Int64}})::Cvoid
end
function sLUstructFree(arg1)
@ccall libsuperlu_dist_Int64.sLUstructFree(arg1::Ptr{sLUstruct_t{Int64}})::Cvoid
end
function sDestroy_LU(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.sDestroy_LU(arg1::int_t, arg2::Ptr{gridinfo_t{Int64}}, arg3::Ptr{sLUstruct_t{Int64}})::Cvoid
end
function sDestroy_Tree(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.sDestroy_Tree(arg1::int_t, arg2::Ptr{gridinfo_t{Int64}}, arg3::Ptr{sLUstruct_t{Int64}})::Cvoid
end
function sscatter_l(ib, ljb, nsupc, iukp, xsup, klst, nbrow, lptr, temp_nbrow, usub, lsub, tempv, indirect_thread, indirect2, Lrowind_bc_ptr, Lnzval_bc_ptr, grid)
@ccall libsuperlu_dist_Int64.sscatter_l(ib::Cint, ljb::Cint, nsupc::Cint, iukp::int_t, xsup::Ptr{int_t}, klst::Cint, nbrow::Cint, lptr::int_t, temp_nbrow::Cint, usub::Ptr{int_t}, lsub::Ptr{int_t}, tempv::Ptr{Cfloat}, indirect_thread::Ptr{Cint}, indirect2::Ptr{Cint}, Lrowind_bc_ptr::Ptr{Ptr{int_t}}, Lnzval_bc_ptr::Ptr{Ptr{Cfloat}}, grid::Ptr{gridinfo_t{Int64}})::Cvoid
end
function sscatter_u(ib, jb, nsupc, iukp, xsup, klst, nbrow, lptr, temp_nbrow, lsub, usub, tempv, Ufstnz_br_ptr, Unzval_br_ptr, grid)
@ccall libsuperlu_dist_Int64.sscatter_u(ib::Cint, jb::Cint, nsupc::Cint, iukp::int_t, xsup::Ptr{int_t}, klst::Cint, nbrow::Cint, lptr::int_t, temp_nbrow::Cint, lsub::Ptr{int_t}, usub::Ptr{int_t}, tempv::Ptr{Cfloat}, Ufstnz_br_ptr::Ptr{Ptr{int_t}}, Unzval_br_ptr::Ptr{Ptr{Cfloat}}, grid::Ptr{gridinfo_t{Int64}})::Cvoid
end
function psgstrf(arg1, arg2, arg3, anorm, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.psgstrf(arg1::Ptr{superlu_dist_options_t}, arg2::Cint, arg3::Cint, anorm::Cfloat, arg5::Ptr{sLUstruct_t{Int64}}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{SuperLUStat_t{Int64}}, arg8::Ptr{Cint})::int_t
end
function psgstrs_Bglobal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.psgstrs_Bglobal(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{sLUstruct_t{Int64}}, arg4::Ptr{gridinfo_t{Int64}}, arg5::Ptr{Cfloat}, arg6::int_t, arg7::Cint, arg8::Ptr{SuperLUStat_t{Int64}}, arg9::Ptr{Cint})::Cvoid
end
function psgstrs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13)
@ccall libsuperlu_dist_Int64.psgstrs(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{sLUstruct_t{Int64}}, arg4::Ptr{sScalePermstruct_t{Int64}}, arg5::Ptr{gridinfo_t{Int64}}, arg6::Ptr{Cfloat}, arg7::int_t, arg8::int_t, arg9::int_t, arg10::Cint, arg11::Ptr{sSOLVEstruct_t{Int64}}, arg12::Ptr{SuperLUStat_t{Int64}}, arg13::Ptr{Cint})::Cvoid
end
function psgstrf2_trsm(options, k0, k, thresh, arg5, arg6, arg7, arg8, tag_ub, arg10, info)
@ccall libsuperlu_dist_Int64.psgstrf2_trsm(options::Ptr{superlu_dist_options_t}, k0::int_t, k::int_t, thresh::Cdouble, arg5::Ptr{Glu_persist_t}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{sLocalLU_t{Int64}}, arg8::Ptr{MPI_Request}, tag_ub::Cint, arg10::Ptr{SuperLUStat_t{Int64}}, info::Ptr{Cint})::Cvoid
end
function psgstrs2_omp(k0, k, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.psgstrs2_omp(k0::int_t, k::int_t, arg3::Ptr{Glu_persist_t}, arg4::Ptr{gridinfo_t{Int64}}, arg5::Ptr{sLocalLU_t{Int64}}, arg6::Ptr{Ublock_info_t}, arg7::Ptr{SuperLUStat_t{Int64}})::Cvoid
end
function psReDistribute_B_to_X(B, m_loc, nrhs, ldb, fst_row, ilsum, x, arg8, arg9, arg10, arg11)
@ccall libsuperlu_dist_Int64.psReDistribute_B_to_X(B::Ptr{Cfloat}, m_loc::int_t, nrhs::Cint, ldb::int_t, fst_row::int_t, ilsum::Ptr{int_t}, x::Ptr{Cfloat}, arg8::Ptr{sScalePermstruct_t{Int64}}, arg9::Ptr{Glu_persist_t}, arg10::Ptr{gridinfo_t{Int64}}, arg11::Ptr{sSOLVEstruct_t{Int64}})::int_t
end
function slsum_fmod(arg1, arg2, arg3, arg4, arg5, arg6, arg7, fmod, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16)
@ccall libsuperlu_dist_Int64.slsum_fmod(arg1::Ptr{Cfloat}, arg2::Ptr{Cfloat}, arg3::Ptr{Cfloat}, arg4::Ptr{Cfloat}, arg5::Cint, arg6::Cint, arg7::int_t, fmod::Ptr{Cint}, arg9::int_t, arg10::int_t, arg11::int_t, arg12::Ptr{int_t}, arg13::Ptr{gridinfo_t{Int64}}, arg14::Ptr{sLocalLU_t{Int64}}, arg15::Ptr{MPI_Request}, arg16::Ptr{SuperLUStat_t{Int64}})::Cvoid
end
function slsum_bmod(arg1, arg2, arg3, arg4, arg5, bmod, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14)
@ccall libsuperlu_dist_Int64.slsum_bmod(arg1::Ptr{Cfloat}, arg2::Ptr{Cfloat}, arg3::Ptr{Cfloat}, arg4::Cint, arg5::int_t, bmod::Ptr{Cint}, arg7::Ptr{int_t}, arg8::Ptr{Ptr{Ucb_indptr_t}}, arg9::Ptr{Ptr{int_t}}, arg10::Ptr{int_t}, arg11::Ptr{gridinfo_t{Int64}}, arg12::Ptr{sLocalLU_t{Int64}}, arg13::Ptr{MPI_Request}, arg14::Ptr{SuperLUStat_t{Int64}})::Cvoid
end
function slsum_fmod_inv(arg1, arg2, arg3, arg4, arg5, arg6, fmod, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19)
@ccall libsuperlu_dist_Int64.slsum_fmod_inv(arg1::Ptr{Cfloat}, arg2::Ptr{Cfloat}, arg3::Ptr{Cfloat}, arg4::Ptr{Cfloat}, arg5::Cint, arg6::int_t, fmod::Ptr{Cint}, arg8::Ptr{int_t}, arg9::Ptr{gridinfo_t{Int64}}, arg10::Ptr{sLocalLU_t{Int64}}, arg11::Ptr{Ptr{SuperLUStat_t{Int64}}}, arg12::Ptr{int_t}, arg13::Ptr{int_t}, arg14::int_t, arg15::int_t, arg16::int_t, arg17::int_t, arg18::Cint, arg19::Cint)::Cvoid
end
function slsum_fmod_inv_master(arg1, arg2, arg3, arg4, arg5, arg6, arg7, fmod, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19)
@ccall libsuperlu_dist_Int64.slsum_fmod_inv_master(arg1::Ptr{Cfloat}, arg2::Ptr{Cfloat}, arg3::Ptr{Cfloat}, arg4::Ptr{Cfloat}, arg5::Cint, arg6::Cint, arg7::int_t, fmod::Ptr{Cint}, arg9::int_t, arg10::Ptr{int_t}, arg11::Ptr{gridinfo_t{Int64}}, arg12::Ptr{sLocalLU_t{Int64}}, arg13::Ptr{Ptr{SuperLUStat_t{Int64}}}, arg14::int_t, arg15::int_t, arg16::int_t, arg17::int_t, arg18::Cint, arg19::Cint)::Cvoid
end
function slsum_bmod_inv(arg1, arg2, arg3, arg4, arg5, arg6, bmod, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20)
@ccall libsuperlu_dist_Int64.slsum_bmod_inv(arg1::Ptr{Cfloat}, arg2::Ptr{Cfloat}, arg3::Ptr{Cfloat}, arg4::Ptr{Cfloat}, arg5::Cint, arg6::int_t, bmod::Ptr{Cint}, arg8::Ptr{int_t}, arg9::Ptr{Ptr{Ucb_indptr_t}}, arg10::Ptr{Ptr{int_t}}, arg11::Ptr{int_t}, arg12::Ptr{gridinfo_t{Int64}}, arg13::Ptr{sLocalLU_t{Int64}}, arg14::Ptr{Ptr{SuperLUStat_t{Int64}}}, arg15::Ptr{int_t}, arg16::Ptr{int_t}, arg17::int_t, arg18::int_t, arg19::Cint, arg20::Cint)::Cvoid
end
function slsum_bmod_inv_master(arg1, arg2, arg3, arg4, arg5, arg6, bmod, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18)
@ccall libsuperlu_dist_Int64.slsum_bmod_inv_master(arg1::Ptr{Cfloat}, arg2::Ptr{Cfloat}, arg3::Ptr{Cfloat}, arg4::Ptr{Cfloat}, arg5::Cint, arg6::int_t, bmod::Ptr{Cint}, arg8::Ptr{int_t}, arg9::Ptr{Ptr{Ucb_indptr_t}}, arg10::Ptr{Ptr{int_t}}, arg11::Ptr{int_t}, arg12::Ptr{gridinfo_t{Int64}}, arg13::Ptr{sLocalLU_t{Int64}}, arg14::Ptr{Ptr{SuperLUStat_t{Int64}}}, arg15::int_t, arg16::int_t, arg17::Cint, arg18::Cint)::Cvoid
end
function sComputeLevelsets(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.sComputeLevelsets(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{sLocalLU_t{Int64}}, arg6::Ptr{int_t})::Cvoid
end
function psgsrfs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16)
@ccall libsuperlu_dist_Int64.psgsrfs(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int64}}, arg4::Cfloat, arg5::Ptr{sLUstruct_t{Int64}}, arg6::Ptr{sScalePermstruct_t{Int64}}, arg7::Ptr{gridinfo_t{Int64}}, arg8::Ptr{Cfloat}, arg9::int_t, arg10::Ptr{Cfloat}, arg11::int_t, arg12::Cint, arg13::Ptr{sSOLVEstruct_t{Int64}}, arg14::Ptr{Cfloat}, arg15::Ptr{SuperLUStat_t{Int64}}, arg16::Ptr{Cint})::Cvoid
end
function psgsrfs_ABXglobal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14)
@ccall libsuperlu_dist_Int64.psgsrfs_ABXglobal(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int64}}, arg4::Cfloat, arg5::Ptr{sLUstruct_t{Int64}}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{Cfloat}, arg8::int_t, arg9::Ptr{Cfloat}, arg10::int_t, arg11::Cint, arg12::Ptr{Cfloat}, arg13::Ptr{SuperLUStat_t{Int64}}, arg14::Ptr{Cint})::Cvoid
end
function psgsmv_AXglobal_setup(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.psgsmv_AXglobal_setup(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{Glu_persist_t}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{int_t}}, arg6::Ptr{Ptr{Cfloat}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{int_t})::Cint
end
function psgsmv_AXglobal(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.psgsmv_AXglobal(arg1::int_t, arg2::Ptr{int_t}, arg3::Ptr{Cfloat}, arg4::Ptr{int_t}, arg5::Ptr{Cfloat}, arg6::Ptr{Cfloat})::Cint
end
function psgsmv_AXglobal_abs(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.psgsmv_AXglobal_abs(arg1::int_t, arg2::Ptr{int_t}, arg3::Ptr{Cfloat}, arg4::Ptr{int_t}, arg5::Ptr{Cfloat}, arg6::Ptr{Cfloat})::Cint
end
function psgsmv_init(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.psgsmv_init(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{int_t}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{psgsmv_comm_t{Int64}})::Cvoid
end
function psgsmv(arg1, arg2, arg3, arg4, x, ax)
@ccall libsuperlu_dist_Int64.psgsmv(arg1::int_t, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{psgsmv_comm_t{Int64}}, x::Ptr{Cfloat}, ax::Ptr{Cfloat})::Cvoid
end
function psgsmv_finalize(arg1)
@ccall libsuperlu_dist_Int64.psgsmv_finalize(arg1::Ptr{psgsmv_comm_t{Int64}})::Cvoid
end
function floatMalloc_dist(arg1)
@ccall libsuperlu_dist_Int64.floatMalloc_dist(arg1::int_t)::Ptr{Cfloat}
end
function floatCalloc_dist(arg1)
@ccall libsuperlu_dist_Int64.floatCalloc_dist(arg1::int_t)::Ptr{Cfloat}
end
function sQuerySpace_dist(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int64.sQuerySpace_dist(arg1::int_t, arg2::Ptr{sLUstruct_t{Int64}}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{SuperLUStat_t{Int64}}, arg5::Ptr{superlu_dist_mem_usage_t})::int_t
end
function sClone_CompRowLoc_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int64.sClone_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{SuperMatrix{Int64}})::Cvoid
end
function sCopy_CompRowLoc_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int64.sCopy_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{SuperMatrix{Int64}})::Cvoid
end
function sZero_CompRowLoc_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int64.sZero_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}})::Cvoid
end
function sScaleAddId_CompRowLoc_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int64.sScaleAddId_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::Cfloat)::Cvoid
end
function sScaleAdd_CompRowLoc_Matrix_dist(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.sScaleAdd_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{SuperMatrix{Int64}}, arg3::Cfloat)::Cvoid
end
function sZeroLblocks(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.sZeroLblocks(arg1::Cint, arg2::Cint, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{sLUstruct_t{Int64}})::Cvoid
end
function sZeroUblocks(iam, n, arg3, arg4)
@ccall libsuperlu_dist_Int64.sZeroUblocks(iam::Cint, n::Cint, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{sLUstruct_t{Int64}})::Cvoid
end
function sfill_dist(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.sfill_dist(arg1::Ptr{Cfloat}, arg2::int_t, arg3::Cfloat)::Cvoid
end
function sinf_norm_error_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.sinf_norm_error_dist(arg1::int_t, arg2::int_t, arg3::Ptr{Cfloat}, arg4::int_t, arg5::Ptr{Cfloat}, arg6::int_t, arg7::Ptr{gridinfo_t{Int64}})::Cvoid
end
function psinf_norm_error(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.psinf_norm_error(arg1::Cint, arg2::int_t, arg3::int_t, arg4::Ptr{Cfloat}, arg5::int_t, arg6::Ptr{Cfloat}, arg7::int_t, arg8::MPI_Comm)::Cvoid
end
function sreadhb_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.sreadhb_dist(arg1::Cint, arg2::Ptr{Libc.FILE}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{Ptr{Cfloat}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}})::Cvoid
end
function sreadtriple_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.sreadtriple_dist(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{Cfloat}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cvoid
end
function sreadtriple_noheader(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.sreadtriple_noheader(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{Cfloat}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cvoid
end
function sreadrb_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.sreadrb_dist(arg1::Cint, arg2::Ptr{Libc.FILE}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{Ptr{Cfloat}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}})::Cvoid
end
function sreadMM_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.sreadMM_dist(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{Cfloat}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cvoid
end
function sread_binary(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.sread_binary(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{Cfloat}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cint
end
function sdist_psymbtonum(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.sdist_psymbtonum(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int64}}, arg4::Ptr{sScalePermstruct_t{Int64}}, arg5::Ptr{Pslu_freeable_t}, arg6::Ptr{sLUstruct_t{Int64}}, arg7::Ptr{gridinfo_t{Int64}})::Cfloat
end
function psGetDiagU(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.psGetDiagU(arg1::int_t, arg2::Ptr{sLUstruct_t{Int64}}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{Cfloat})::Cvoid
end
function s_c2cpp_GetHWPM(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.s_c2cpp_GetHWPM(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{gridinfo_t{Int64}}, arg3::Ptr{sScalePermstruct_t{Int64}})::Cint
end
function sPrintLblocks(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int64.sPrintLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{sLocalLU_t{Int64}})::Cvoid
end
function sPrintUblocks(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int64.sPrintUblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{sLocalLU_t{Int64}})::Cvoid
end
function sPrint_CompCol_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int64.sPrint_CompCol_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}})::Cvoid
end
function sPrint_Dense_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int64.sPrint_Dense_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}})::Cvoid
end
function sPrint_CompRowLoc_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int64.sPrint_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}})::Cint
end
function file_sPrint_CompRowLoc_Matrix_dist(fp, A)
@ccall libsuperlu_dist_Int64.file_sPrint_CompRowLoc_Matrix_dist(fp::Ptr{Libc.FILE}, A::Ptr{SuperMatrix{Int64}})::Cint
end
function Printfloat5(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.Printfloat5(arg1::Ptr{Cchar}, arg2::int_t, arg3::Ptr{Cfloat})::Cvoid
end
function file_Printfloat5(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.file_Printfloat5(arg1::Ptr{Libc.FILE}, arg2::Ptr{Cchar}, arg3::int_t, arg4::Ptr{Cfloat})::Cint
end
function sGenCOOLblocks(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int64.sGenCOOLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{sLocalLU_t{Int64}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{Cfloat}}, arg9::Ptr{int_t}, arg10::Ptr{int_t})::Cvoid
end
function sGenCSCLblocks(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int64.sGenCSCLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{sLocalLU_t{Int64}}, arg6::Ptr{Ptr{Cfloat}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}}, arg9::Ptr{int_t}, arg10::Ptr{int_t})::Cvoid
end
function sGenCSRLblocks(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int64.sGenCSRLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{sLocalLU_t{Int64}}, arg6::Ptr{Ptr{Cfloat}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}}, arg9::Ptr{int_t}, arg10::Ptr{int_t})::Cvoid
end
function superlu_sgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
@ccall libsuperlu_dist_Int64.superlu_sgemm(transa::Ptr{Cchar}, transb::Ptr{Cchar}, m::Cint, n::Cint, k::Cint, alpha::Cfloat, a::Ptr{Cfloat}, lda::Cint, b::Ptr{Cfloat}, ldb::Cint, beta::Cfloat, c::Ptr{Cfloat}, ldc::Cint)::Cint
end
function superlu_strsm(sideRL, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
@ccall libsuperlu_dist_Int64.superlu_strsm(sideRL::Ptr{Cchar}, uplo::Ptr{Cchar}, transa::Ptr{Cchar}, diag::Ptr{Cchar}, m::Cint, n::Cint, alpha::Cfloat, a::Ptr{Cfloat}, lda::Cint, b::Ptr{Cfloat}, ldb::Cint)::Cint
end
function superlu_sger(m, n, alpha, x, incx, y, incy, a, lda)
@ccall libsuperlu_dist_Int64.superlu_sger(m::Cint, n::Cint, alpha::Cfloat, x::Ptr{Cfloat}, incx::Cint, y::Ptr{Cfloat}, incy::Cint, a::Ptr{Cfloat}, lda::Cint)::Cint
end
function superlu_sscal(n, alpha, x, incx)
@ccall libsuperlu_dist_Int64.superlu_sscal(n::Cint, alpha::Cfloat, x::Ptr{Cfloat}, incx::Cint)::Cint
end
function superlu_saxpy(n, alpha, x, incx, y, incy)
@ccall libsuperlu_dist_Int64.superlu_saxpy(n::Cint, alpha::Cfloat, x::Ptr{Cfloat}, incx::Cint, y::Ptr{Cfloat}, incy::Cint)::Cint
end
function superlu_sgemv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy)
@ccall libsuperlu_dist_Int64.superlu_sgemv(trans::Ptr{Cchar}, m::Cint, n::Cint, alpha::Cfloat, a::Ptr{Cfloat}, lda::Cint, x::Ptr{Cfloat}, incx::Cint, beta::Cfloat, y::Ptr{Cfloat}, incy::Cint)::Cint
end
function superlu_strsv(uplo, trans, diag, n, a, lda, x, incx)
@ccall libsuperlu_dist_Int64.superlu_strsv(uplo::Ptr{Cchar}, trans::Ptr{Cchar}, diag::Ptr{Cchar}, n::Cint, a::Ptr{Cfloat}, lda::Cint, x::Ptr{Cfloat}, incx::Cint)::Cint
end
function screate_matrix3d(A, nrhs, rhs, ldb, x, ldx, fp, grid3d)
@ccall libsuperlu_dist_Int64.screate_matrix3d(A::Ptr{SuperMatrix{Int64}}, nrhs::Cint, rhs::Ptr{Ptr{Cfloat}}, ldb::Ptr{Cint}, x::Ptr{Ptr{Cfloat}}, ldx::Ptr{Cint}, fp::Ptr{Libc.FILE}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cint
end
function screate_matrix_postfix3d(A, nrhs, rhs, ldb, x, ldx, fp, postfix, grid3d)
@ccall libsuperlu_dist_Int64.screate_matrix_postfix3d(A::Ptr{SuperMatrix{Int64}}, nrhs::Cint, rhs::Ptr{Ptr{Cfloat}}, ldb::Ptr{Cint}, x::Ptr{Ptr{Cfloat}}, ldx::Ptr{Cint}, fp::Ptr{Libc.FILE}, postfix::Ptr{Cchar}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cint
end
function sGatherNRformat_loc3d(Fact, A, B, ldb, nrhs, grid3d, arg7)
@ccall libsuperlu_dist_Int64.sGatherNRformat_loc3d(Fact::fact_t, A::Ptr{NRformat_loc{Int64}}, B::Ptr{Cfloat}, ldb::Cint, nrhs::Cint, grid3d::Ptr{gridinfo3d_t{Int64}}, arg7::Ptr{Ptr{NRformat_loc3d{Int64}}})::Cvoid
end
function sScatter_B3d(A3d, grid3d)
@ccall libsuperlu_dist_Int64.sScatter_B3d(A3d::Ptr{NRformat_loc3d{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cint
end
function psgssvx3d(arg1, arg2, arg3, B, ldb, nrhs, arg7, arg8, arg9, berr, arg11, info)
@ccall libsuperlu_dist_Int64.psgssvx3d(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{sScalePermstruct_t{Int64}}, B::Ptr{Cfloat}, ldb::Cint, nrhs::Cint, arg7::Ptr{gridinfo3d_t{Int64}}, arg8::Ptr{sLUstruct_t{Int64}}, arg9::Ptr{sSOLVEstruct_t{Int64}}, berr::Ptr{Cfloat}, arg11::Ptr{SuperLUStat_t{Int64}}, info::Ptr{Cint})::Cvoid
end
function psgstrf3d(arg1, m, n, anorm, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int64.psgstrf3d(arg1::Ptr{superlu_dist_options_t}, m::Cint, n::Cint, anorm::Cfloat, arg5::Ptr{strf3Dpartition_t{Int64}}, arg6::Ptr{SCT_t}, arg7::Ptr{sLUstruct_t{Int64}}, arg8::Ptr{gridinfo3d_t{Int64}}, arg9::Ptr{SuperLUStat_t{Int64}}, arg10::Ptr{Cint})::int_t
end
function sInit_HyP(HyP, Llu, mcb, mrb)
@ccall libsuperlu_dist_Int64.sInit_HyP(HyP::Ptr{HyP_t}, Llu::Ptr{sLocalLU_t{Int64}}, mcb::int_t, mrb::int_t)::Cvoid
end
function sblock_gemm_scatter(lb, j, Ublock_info, Remain_info, L_mat, ldl, U_mat, ldu, bigV, knsupc, klst, lsub, usub, ldt, thread_id, indirect, indirect2, Lrowind_bc_ptr, Lnzval_bc_ptr, Ufstnz_br_ptr, Unzval_br_ptr, xsup, arg23, arg24)
@ccall libsuperlu_dist_Int64.sblock_gemm_scatter(lb::int_t, j::int_t, Ublock_info::Ptr{Ublock_info_t}, Remain_info::Ptr{Remain_info_t}, L_mat::Ptr{Cfloat}, ldl::Cint, U_mat::Ptr{Cfloat}, ldu::Cint, bigV::Ptr{Cfloat}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, thread_id::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, Lrowind_bc_ptr::Ptr{Ptr{int_t}}, Lnzval_bc_ptr::Ptr{Ptr{Cfloat}}, Ufstnz_br_ptr::Ptr{Ptr{int_t}}, Unzval_br_ptr::Ptr{Ptr{Cfloat}}, xsup::Ptr{int_t}, arg23::Ptr{gridinfo_t{Int64}}, arg24::Ptr{SuperLUStat_t{Int64}})::Cvoid
end
function sblock_gemm_scatterTopLeft(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int64.sblock_gemm_scatterTopLeft(lb::int_t, j::int_t, bigV::Ptr{Cfloat}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{sLUstruct_t{Int64}}, arg13::Ptr{gridinfo_t{Int64}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int64}})::int_t
end
function sblock_gemm_scatterTopRight(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int64.sblock_gemm_scatterTopRight(lb::int_t, j::int_t, bigV::Ptr{Cfloat}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{sLUstruct_t{Int64}}, arg13::Ptr{gridinfo_t{Int64}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int64}})::int_t
end
function sblock_gemm_scatterBottomLeft(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int64.sblock_gemm_scatterBottomLeft(lb::int_t, j::int_t, bigV::Ptr{Cfloat}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{sLUstruct_t{Int64}}, arg13::Ptr{gridinfo_t{Int64}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int64}})::int_t
end
function sblock_gemm_scatterBottomRight(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int64.sblock_gemm_scatterBottomRight(lb::int_t, j::int_t, bigV::Ptr{Cfloat}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{sLUstruct_t{Int64}}, arg13::Ptr{gridinfo_t{Int64}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int64}})::int_t
end
function sgather_u(num_u_blks, Ublock_info, usub, uval, bigU, ldu, xsup, klst)
@ccall libsuperlu_dist_Int64.sgather_u(num_u_blks::int_t, Ublock_info::Ptr{Ublock_info_t}, usub::Ptr{int_t}, uval::Ptr{Cfloat}, bigU::Ptr{Cfloat}, ldu::int_t, xsup::Ptr{int_t}, klst::int_t)::Cvoid
end
function sgather_l(num_LBlk, knsupc, L_info, lval, LD_lval, L_buff)
@ccall libsuperlu_dist_Int64.sgather_l(num_LBlk::int_t, knsupc::int_t, L_info::Ptr{Remain_info_t}, lval::Ptr{Cfloat}, LD_lval::int_t, L_buff::Ptr{Cfloat})::Cvoid
end
function sRgather_L(k, lsub, lusup, arg4, arg5, arg6, arg7, myIperm, iperm_c_supno)
@ccall libsuperlu_dist_Int64.sRgather_L(k::int_t, lsub::Ptr{int_t}, lusup::Ptr{Cfloat}, arg4::Ptr{gEtreeInfo_t{Int64}}, arg5::Ptr{Glu_persist_t}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{HyP_t}, myIperm::Ptr{int_t}, iperm_c_supno::Ptr{int_t})::Cvoid
end
function sRgather_U(k, jj0, usub, uval, bigU, arg6, arg7, arg8, arg9, myIperm, iperm_c_supno, perm_u)
@ccall libsuperlu_dist_Int64.sRgather_U(k::int_t, jj0::int_t, usub::Ptr{int_t}, uval::Ptr{Cfloat}, bigU::Ptr{Cfloat}, arg6::Ptr{gEtreeInfo_t{Int64}}, arg7::Ptr{Glu_persist_t}, arg8::Ptr{gridinfo_t{Int64}}, arg9::Ptr{HyP_t}, myIperm::Ptr{int_t}, iperm_c_supno::Ptr{int_t}, perm_u::Ptr{int_t})::Cvoid
end
function sinitTrf3Dpartition(nsupers, options, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.sinitTrf3Dpartition(nsupers::int_t, options::Ptr{superlu_dist_options_t}, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::Ptr{strf3Dpartition_t{Int64}}
end
function sDestroy_trf3Dpartition(trf3Dpartition, grid3d)
@ccall libsuperlu_dist_Int64.sDestroy_trf3Dpartition(trf3Dpartition::Ptr{strf3Dpartition_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cvoid
end
function s3D_printMemUse(trf3Dpartition, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.s3D_printMemUse(trf3Dpartition::Ptr{strf3Dpartition_t{Int64}}, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cvoid
end
function sinit3DLUstructForest(myTreeIdxs, myZeroTrIdxs, sForests, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.sinit3DLUstructForest(myTreeIdxs::Ptr{int_t}, myZeroTrIdxs::Ptr{int_t}, sForests::Ptr{Ptr{sForest_t{Int64}}}, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cvoid
end
function sgatherAllFactoredLUFr(myZeroTrIdxs, sForests, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.sgatherAllFactoredLUFr(myZeroTrIdxs::Ptr{int_t}, sForests::Ptr{sForest_t{Int64}}, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function sLpanelUpdate(off0, nsupc, ublk_ptr, ld_ujrow, lusup, nsupr, arg7)
@ccall libsuperlu_dist_Int64.sLpanelUpdate(off0::int_t, nsupc::int_t, ublk_ptr::Ptr{Cfloat}, ld_ujrow::int_t, lusup::Ptr{Cfloat}, nsupr::int_t, arg7::Ptr{SCT_t})::int_t
end
function Local_Sgstrf2(options, k, thresh, BlockUFactor, arg5, arg6, arg7, arg8, info, arg10)
@ccall libsuperlu_dist_Int64.Local_Sgstrf2(options::Ptr{superlu_dist_options_t}, k::int_t, thresh::Cdouble, BlockUFactor::Ptr{Cfloat}, arg5::Ptr{Glu_persist_t}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{sLocalLU_t{Int64}}, arg8::Ptr{SuperLUStat_t{Int64}}, info::Ptr{Cint}, arg10::Ptr{SCT_t})::Cvoid
end
function sTrs2_GatherU(iukp, rukp, klst, nsupc, ldu, usub, uval, tempv)
@ccall libsuperlu_dist_Int64.sTrs2_GatherU(iukp::int_t, rukp::int_t, klst::int_t, nsupc::int_t, ldu::int_t, usub::Ptr{int_t}, uval::Ptr{Cfloat}, tempv::Ptr{Cfloat})::int_t
end
function sTrs2_ScatterU(iukp, rukp, klst, nsupc, ldu, usub, uval, tempv)
@ccall libsuperlu_dist_Int64.sTrs2_ScatterU(iukp::int_t, rukp::int_t, klst::int_t, nsupc::int_t, ldu::int_t, usub::Ptr{int_t}, uval::Ptr{Cfloat}, tempv::Ptr{Cfloat})::int_t
end
function sTrs2_GatherTrsmScatter(klst, iukp, rukp, usub, uval, tempv, knsupc, nsupr, lusup, Glu_persist)
@ccall libsuperlu_dist_Int64.sTrs2_GatherTrsmScatter(klst::int_t, iukp::int_t, rukp::int_t, usub::Ptr{int_t}, uval::Ptr{Cfloat}, tempv::Ptr{Cfloat}, knsupc::int_t, nsupr::Cint, lusup::Ptr{Cfloat}, Glu_persist::Ptr{Glu_persist_t})::int_t
end
function psgstrs2(m, k0, k, Glu_persist, grid, Llu, stat)
@ccall libsuperlu_dist_Int64.psgstrs2(m::int_t, k0::int_t, k::int_t, Glu_persist::Ptr{Glu_persist_t}, grid::Ptr{gridinfo_t{Int64}}, Llu::Ptr{sLocalLU_t{Int64}}, stat::Ptr{SuperLUStat_t{Int64}})::Cvoid
end
function psgstrf2(arg1, nsupers, k0, k, thresh, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int64.psgstrf2(arg1::Ptr{superlu_dist_options_t}, nsupers::int_t, k0::int_t, k::int_t, thresh::Cdouble, arg6::Ptr{Glu_persist_t}, arg7::Ptr{gridinfo_t{Int64}}, arg8::Ptr{sLocalLU_t{Int64}}, arg9::Ptr{MPI_Request}, arg10::Cint, arg11::Ptr{SuperLUStat_t{Int64}}, arg12::Ptr{Cint})::Cvoid
end
function sAllocLlu_3d(nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.sAllocLlu_3d(nsupers::int_t, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function sp3dScatter(n, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.sp3dScatter(n::int_t, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function sscatter3dLPanels(nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.sscatter3dLPanels(nsupers::int_t, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function sscatter3dUPanels(nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.sscatter3dUPanels(nsupers::int_t, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function scollect3dLpanels(layer, nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.scollect3dLpanels(layer::int_t, nsupers::int_t, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function scollect3dUpanels(layer, nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.scollect3dUpanels(layer::int_t, nsupers::int_t, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function sp3dCollect(layer, n, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.sp3dCollect(layer::int_t, n::int_t, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function szeroSetLU(nnodes, nodeList, arg3, arg4)
@ccall libsuperlu_dist_Int64.szeroSetLU(nnodes::int_t, nodeList::Ptr{int_t}, arg3::Ptr{sLUstruct_t{Int64}}, arg4::Ptr{gridinfo3d_t{Int64}})::int_t
end
function sAllocGlu_3d(n, nsupers, arg3)
@ccall libsuperlu_dist_Int64.sAllocGlu_3d(n::int_t, nsupers::int_t, arg3::Ptr{sLUstruct_t{Int64}})::Cint
end
function sDeAllocLlu_3d(n, arg2, arg3)
@ccall libsuperlu_dist_Int64.sDeAllocLlu_3d(n::int_t, arg2::Ptr{sLUstruct_t{Int64}}, arg3::Ptr{gridinfo3d_t{Int64}})::Cint
end
function sDeAllocGlu_3d(arg1)
@ccall libsuperlu_dist_Int64.sDeAllocGlu_3d(arg1::Ptr{sLUstruct_t{Int64}})::Cint
end
function sreduceAncestors3d(sender, receiver, nnodes, nodeList, Lval_buf, Uval_buf, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.sreduceAncestors3d(sender::int_t, receiver::int_t, nnodes::int_t, nodeList::Ptr{int_t}, Lval_buf::Ptr{Cfloat}, Uval_buf::Ptr{Cfloat}, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function sreduceAllAncestors3d(ilvl, myNodeCount, treePerm, LUvsb, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.sreduceAllAncestors3d(ilvl::int_t, myNodeCount::Ptr{int_t}, treePerm::Ptr{Ptr{int_t}}, LUvsb::Ptr{sLUValSubBuf_t{Int64}}, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::Cint
end
function sgatherFactoredLU(sender, receiver, nnodes, nodeList, LUvsb, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.sgatherFactoredLU(sender::int_t, receiver::int_t, nnodes::int_t, nodeList::Ptr{int_t}, LUvsb::Ptr{sLUValSubBuf_t{Int64}}, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function sgatherAllFactoredLU(trf3Dpartition, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.sgatherAllFactoredLU(trf3Dpartition::Ptr{strf3Dpartition_t{Int64}}, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function sinit3DLUstruct(myTreeIdxs, myZeroTrIdxs, nodeCount, nodeList, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.sinit3DLUstruct(myTreeIdxs::Ptr{int_t}, myZeroTrIdxs::Ptr{int_t}, nodeCount::Ptr{int_t}, nodeList::Ptr{Ptr{int_t}}, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function szSendLPanel(k, receiver, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.szSendLPanel(k::int_t, receiver::int_t, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function szRecvLPanel(k, sender, alpha, beta, Lval_buf, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.szRecvLPanel(k::int_t, sender::int_t, alpha::Cfloat, beta::Cfloat, Lval_buf::Ptr{Cfloat}, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function szSendUPanel(k, receiver, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.szSendUPanel(k::int_t, receiver::int_t, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function szRecvUPanel(k, sender, alpha, beta, Uval_buf, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.szRecvUPanel(k::int_t, sender::int_t, alpha::Cfloat, beta::Cfloat, Uval_buf::Ptr{Cfloat}, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function sIBcast_LPanel(k, k0, lsub, lusup, arg5, msgcnt, arg7, ToSendR, xsup, arg10)
@ccall libsuperlu_dist_Int64.sIBcast_LPanel(k::int_t, k0::int_t, lsub::Ptr{int_t}, lusup::Ptr{Cfloat}, arg5::Ptr{gridinfo_t{Int64}}, msgcnt::Ptr{Cint}, arg7::Ptr{MPI_Request}, ToSendR::Ptr{Ptr{Cint}}, xsup::Ptr{int_t}, arg10::Cint)::int_t
end
function sBcast_LPanel(k, k0, lsub, lusup, arg5, msgcnt, ToSendR, xsup, arg9, arg10)
@ccall libsuperlu_dist_Int64.sBcast_LPanel(k::int_t, k0::int_t, lsub::Ptr{int_t}, lusup::Ptr{Cfloat}, arg5::Ptr{gridinfo_t{Int64}}, msgcnt::Ptr{Cint}, ToSendR::Ptr{Ptr{Cint}}, xsup::Ptr{int_t}, arg9::Ptr{SCT_t}, arg10::Cint)::int_t
end
function sIBcast_UPanel(k, k0, usub, uval, arg5, msgcnt, arg7, ToSendD, arg9)
@ccall libsuperlu_dist_Int64.sIBcast_UPanel(k::int_t, k0::int_t, usub::Ptr{int_t}, uval::Ptr{Cfloat}, arg5::Ptr{gridinfo_t{Int64}}, msgcnt::Ptr{Cint}, arg7::Ptr{MPI_Request}, ToSendD::Ptr{Cint}, arg9::Cint)::int_t
end
function sBcast_UPanel(k, k0, usub, uval, arg5, msgcnt, ToSendD, arg8, arg9)
@ccall libsuperlu_dist_Int64.sBcast_UPanel(k::int_t, k0::int_t, usub::Ptr{int_t}, uval::Ptr{Cfloat}, arg5::Ptr{gridinfo_t{Int64}}, msgcnt::Ptr{Cint}, ToSendD::Ptr{Cint}, arg8::Ptr{SCT_t}, arg9::Cint)::int_t
end
function sIrecv_LPanel(k, k0, Lsub_buf, Lval_buf, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.sIrecv_LPanel(k::int_t, k0::int_t, Lsub_buf::Ptr{int_t}, Lval_buf::Ptr{Cfloat}, arg5::Ptr{gridinfo_t{Int64}}, arg6::Ptr{MPI_Request}, arg7::Ptr{sLocalLU_t{Int64}}, arg8::Cint)::int_t
end
function sIrecv_UPanel(k, k0, Usub_buf, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.sIrecv_UPanel(k::int_t, k0::int_t, Usub_buf::Ptr{int_t}, arg4::Ptr{Cfloat}, arg5::Ptr{sLocalLU_t{Int64}}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{MPI_Request}, arg8::Cint)::int_t
end
function sWait_URecv(arg1, msgcnt, arg3)
@ccall libsuperlu_dist_Int64.sWait_URecv(arg1::Ptr{MPI_Request}, msgcnt::Ptr{Cint}, arg3::Ptr{SCT_t})::int_t
end
function sWait_LRecv(arg1, msgcnt, msgcntsU, arg4, arg5)
@ccall libsuperlu_dist_Int64.sWait_LRecv(arg1::Ptr{MPI_Request}, msgcnt::Ptr{Cint}, msgcntsU::Ptr{Cint}, arg4::Ptr{gridinfo_t{Int64}}, arg5::Ptr{SCT_t})::int_t
end
function sISend_UDiagBlock(k0, ublk_ptr, size, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.sISend_UDiagBlock(k0::int_t, ublk_ptr::Ptr{Cfloat}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int64}}, arg6::Cint)::int_t
end
function sRecv_UDiagBlock(k0, ublk_ptr, size, src, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.sRecv_UDiagBlock(k0::int_t, ublk_ptr::Ptr{Cfloat}, size::int_t, src::int_t, arg5::Ptr{gridinfo_t{Int64}}, arg6::Ptr{SCT_t}, arg7::Cint)::int_t
end
function sPackLBlock(k, Dest, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int64.sPackLBlock(k::int_t, Dest::Ptr{Cfloat}, arg3::Ptr{Glu_persist_t}, arg4::Ptr{gridinfo_t{Int64}}, arg5::Ptr{sLocalLU_t{Int64}})::int_t
end
function sISend_LDiagBlock(k0, lblk_ptr, size, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.sISend_LDiagBlock(k0::int_t, lblk_ptr::Ptr{Cfloat}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int64}}, arg6::Cint)::int_t
end
function sIRecv_UDiagBlock(k0, ublk_ptr, size, src, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.sIRecv_UDiagBlock(k0::int_t, ublk_ptr::Ptr{Cfloat}, size::int_t, src::int_t, arg5::Ptr{MPI_Request}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{SCT_t}, arg8::Cint)::int_t
end
function sIRecv_LDiagBlock(k0, L_blk_ptr, size, src, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.sIRecv_LDiagBlock(k0::int_t, L_blk_ptr::Ptr{Cfloat}, size::int_t, src::int_t, arg5::Ptr{MPI_Request}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{SCT_t}, arg8::Cint)::int_t
end
function sUDiagBlockRecvWait(k, IrecvPlcd_D, factored_L, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.sUDiagBlockRecvWait(k::int_t, IrecvPlcd_D::Ptr{int_t}, factored_L::Ptr{int_t}, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int64}}, arg6::Ptr{sLUstruct_t{Int64}}, arg7::Ptr{SCT_t})::int_t
end
function sIBcast_UDiagBlock(k, ublk_ptr, size, arg4, arg5)
@ccall libsuperlu_dist_Int64.sIBcast_UDiagBlock(k::int_t, ublk_ptr::Ptr{Cfloat}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int64}})::int_t
end
function sIBcast_LDiagBlock(k, lblk_ptr, size, arg4, arg5)
@ccall libsuperlu_dist_Int64.sIBcast_LDiagBlock(k::int_t, lblk_ptr::Ptr{Cfloat}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int64}})::int_t
end
function sDiagFactIBCast(k, k0, BlockUFactor, BlockLFactor, IrecvPlcd_D, arg6, arg7, arg8, arg9, arg10, arg11, thresh, LUstruct, arg14, info, arg16, tag_ub)
@ccall libsuperlu_dist_Int64.sDiagFactIBCast(k::int_t, k0::int_t, BlockUFactor::Ptr{Cfloat}, BlockLFactor::Ptr{Cfloat}, IrecvPlcd_D::Ptr{int_t}, arg6::Ptr{MPI_Request}, arg7::Ptr{MPI_Request}, arg8::Ptr{MPI_Request}, arg9::Ptr{MPI_Request}, arg10::Ptr{gridinfo_t{Int64}}, arg11::Ptr{superlu_dist_options_t}, thresh::Cdouble, LUstruct::Ptr{sLUstruct_t{Int64}}, arg14::Ptr{SuperLUStat_t{Int64}}, info::Ptr{Cint}, arg16::Ptr{SCT_t}, tag_ub::Cint)::int_t
end
function sUPanelTrSolve(k, BlockLFactor, bigV, ldt, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.sUPanelTrSolve(k::int_t, BlockLFactor::Ptr{Cfloat}, bigV::Ptr{Cfloat}, ldt::int_t, arg5::Ptr{Ublock_info_t}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{sLUstruct_t{Int64}}, arg8::Ptr{SuperLUStat_t{Int64}}, arg9::Ptr{SCT_t})::int_t
end
function sLPanelUpdate(k, IrecvPlcd_D, factored_L, arg4, BlockUFactor, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.sLPanelUpdate(k::int_t, IrecvPlcd_D::Ptr{int_t}, factored_L::Ptr{int_t}, arg4::Ptr{MPI_Request}, BlockUFactor::Ptr{Cfloat}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{sLUstruct_t{Int64}}, arg8::Ptr{SCT_t})::int_t
end
function sUPanelUpdate(k, factored_U, arg3, BlockLFactor, bigV, ldt, arg7, arg8, arg9, arg10, arg11)
@ccall libsuperlu_dist_Int64.sUPanelUpdate(k::int_t, factored_U::Ptr{int_t}, arg3::Ptr{MPI_Request}, BlockLFactor::Ptr{Cfloat}, bigV::Ptr{Cfloat}, ldt::int_t, arg7::Ptr{Ublock_info_t}, arg8::Ptr{gridinfo_t{Int64}}, arg9::Ptr{sLUstruct_t{Int64}}, arg10::Ptr{SuperLUStat_t{Int64}}, arg11::Ptr{SCT_t})::int_t
end
function sIBcastRecvLPanel(k, k0, msgcnt, arg4, arg5, Lsub_buf, Lval_buf, factored, arg9, arg10, arg11, tag_ub)
@ccall libsuperlu_dist_Int64.sIBcastRecvLPanel(k::int_t, k0::int_t, msgcnt::Ptr{Cint}, arg4::Ptr{MPI_Request}, arg5::Ptr{MPI_Request}, Lsub_buf::Ptr{int_t}, Lval_buf::Ptr{Cfloat}, factored::Ptr{int_t}, arg9::Ptr{gridinfo_t{Int64}}, arg10::Ptr{sLUstruct_t{Int64}}, arg11::Ptr{SCT_t}, tag_ub::Cint)::int_t
end
function sIBcastRecvUPanel(k, k0, msgcnt, arg4, arg5, Usub_buf, Uval_buf, arg8, arg9, arg10, tag_ub)
@ccall libsuperlu_dist_Int64.sIBcastRecvUPanel(k::int_t, k0::int_t, msgcnt::Ptr{Cint}, arg4::Ptr{MPI_Request}, arg5::Ptr{MPI_Request}, Usub_buf::Ptr{int_t}, Uval_buf::Ptr{Cfloat}, arg8::Ptr{gridinfo_t{Int64}}, arg9::Ptr{sLUstruct_t{Int64}}, arg10::Ptr{SCT_t}, tag_ub::Cint)::int_t
end
function sWaitL(k, msgcnt, msgcntU, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.sWaitL(k::int_t, msgcnt::Ptr{Cint}, msgcntU::Ptr{Cint}, arg4::Ptr{MPI_Request}, arg5::Ptr{MPI_Request}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{sLUstruct_t{Int64}}, arg8::Ptr{SCT_t})::int_t
end
function sWaitU(k, msgcnt, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.sWaitU(k::int_t, msgcnt::Ptr{Cint}, arg3::Ptr{MPI_Request}, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int64}}, arg6::Ptr{sLUstruct_t{Int64}}, arg7::Ptr{SCT_t})::int_t
end
function sLPanelTrSolve(k, factored_L, BlockUFactor, arg4, arg5)
@ccall libsuperlu_dist_Int64.sLPanelTrSolve(k::int_t, factored_L::Ptr{int_t}, BlockUFactor::Ptr{Cfloat}, arg4::Ptr{gridinfo_t{Int64}}, arg5::Ptr{sLUstruct_t{Int64}})::int_t
end
function sSchurComplementSetup(k, msgcnt, arg3, arg4, arg5, arg6, arg7, arg8, arg9, bigU, Lsub_buf, Lval_buf, Usub_buf, Uval_buf, arg15, arg16)
@ccall libsuperlu_dist_Int64.sSchurComplementSetup(k::int_t, msgcnt::Ptr{Cint}, arg3::Ptr{Ublock_info_t}, arg4::Ptr{Remain_info_t}, arg5::Ptr{uPanelInfo_t{Int64}}, arg6::Ptr{lPanelInfo_t{Int64}}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{int_t}, bigU::Ptr{Cfloat}, Lsub_buf::Ptr{int_t}, Lval_buf::Ptr{Cfloat}, Usub_buf::Ptr{int_t}, Uval_buf::Ptr{Cfloat}, arg15::Ptr{gridinfo_t{Int64}}, arg16::Ptr{sLUstruct_t{Int64}})::int_t
end
function sSchurComplementSetupGPU(k, msgs, arg3, arg4, arg5, arg6, arg7, arg8, arg9, LUvsb, arg11, arg12, arg13)
@ccall libsuperlu_dist_Int64.sSchurComplementSetupGPU(k::int_t, msgs::Ptr{msgs_t}, arg3::Ptr{packLUInfo_t{Int64}}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{int_t}, arg7::Ptr{gEtreeInfo_t{Int64}}, arg8::Ptr{factNodelists_t{Int64}}, arg9::Ptr{sscuBufs_t}, LUvsb::Ptr{sLUValSubBuf_t{Int64}}, arg11::Ptr{gridinfo_t{Int64}}, arg12::Ptr{sLUstruct_t{Int64}}, arg13::Ptr{HyP_t})::int_t
end
function sgetBigV(arg1, arg2)
@ccall libsuperlu_dist_Int64.sgetBigV(arg1::int_t, arg2::int_t)::Ptr{Cfloat}
end
function sgetBigU(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.sgetBigU(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{sLUstruct_t{Int64}})::Ptr{Cfloat}
end
function sLluBufInit(arg1, arg2)
@ccall libsuperlu_dist_Int64.sLluBufInit(arg1::Ptr{sLUValSubBuf_t{Int64}}, arg2::Ptr{sLUstruct_t{Int64}})::int_t
end
function sinitScuBufs(arg1, ldt, num_threads, nsupers, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.sinitScuBufs(arg1::Ptr{superlu_dist_options_t}, ldt::int_t, num_threads::int_t, nsupers::int_t, arg5::Ptr{sscuBufs_t}, arg6::Ptr{sLUstruct_t{Int64}}, arg7::Ptr{gridinfo_t{Int64}})::int_t
end
function sfreeScuBufs(scuBufs)
@ccall libsuperlu_dist_Int64.sfreeScuBufs(scuBufs::Ptr{sscuBufs_t})::Cint
end
function ssparseTreeFactor(nnodes, perm_c_supno, treeTopoInfo, comReqs, scuBufs, packLUInfo, msgs, LUvsb, dFBuf, factStat, fNlists, options, gIperm_c_supno, ldt, LUstruct, grid3d, stat, thresh, SCT, info)
@ccall libsuperlu_dist_Int64.ssparseTreeFactor(nnodes::int_t, perm_c_supno::Ptr{int_t}, treeTopoInfo::Ptr{treeTopoInfo_t{Int64}}, comReqs::Ptr{commRequests_t}, scuBufs::Ptr{sscuBufs_t}, packLUInfo::Ptr{packLUInfo_t{Int64}}, msgs::Ptr{msgs_t}, LUvsb::Ptr{sLUValSubBuf_t{Int64}}, dFBuf::Ptr{sdiagFactBufs_t}, factStat::Ptr{factStat_t{Int64}}, fNlists::Ptr{factNodelists_t{Int64}}, options::Ptr{superlu_dist_options_t}, gIperm_c_supno::Ptr{int_t}, ldt::int_t, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, stat::Ptr{SuperLUStat_t{Int64}}, thresh::Cdouble, SCT::Ptr{SCT_t}, info::Ptr{Cint})::int_t
end
function sdenseTreeFactor(nnnodes, perm_c_supno, comReqs, scuBufs, packLUInfo, msgs, LUvsb, dFBuf, factStat, fNlists, options, gIperm_c_supno, ldt, LUstruct, grid3d, stat, thresh, SCT, tag_ub, info)
@ccall libsuperlu_dist_Int64.sdenseTreeFactor(nnnodes::int_t, perm_c_supno::Ptr{int_t}, comReqs::Ptr{commRequests_t}, scuBufs::Ptr{sscuBufs_t}, packLUInfo::Ptr{packLUInfo_t{Int64}}, msgs::Ptr{msgs_t}, LUvsb::Ptr{sLUValSubBuf_t{Int64}}, dFBuf::Ptr{sdiagFactBufs_t}, factStat::Ptr{factStat_t{Int64}}, fNlists::Ptr{factNodelists_t{Int64}}, options::Ptr{superlu_dist_options_t}, gIperm_c_supno::Ptr{int_t}, ldt::int_t, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, stat::Ptr{SuperLUStat_t{Int64}}, thresh::Cdouble, SCT::Ptr{SCT_t}, tag_ub::Cint, info::Ptr{Cint})::int_t
end
function ssparseTreeFactor_ASYNC(sforest, comReqss, scuBufs, packLUInfo, msgss, LUvsbs, dFBufs, factStat, fNlists, gEtreeInfo, options, gIperm_c_supno, ldt, HyP, LUstruct, grid3d, stat, thresh, SCT, tag_ub, info)
@ccall libsuperlu_dist_Int64.ssparseTreeFactor_ASYNC(sforest::Ptr{sForest_t{Int64}}, comReqss::Ptr{Ptr{commRequests_t}}, scuBufs::Ptr{sscuBufs_t}, packLUInfo::Ptr{packLUInfo_t{Int64}}, msgss::Ptr{Ptr{msgs_t}}, LUvsbs::Ptr{Ptr{sLUValSubBuf_t{Int64}}}, dFBufs::Ptr{Ptr{sdiagFactBufs_t}}, factStat::Ptr{factStat_t{Int64}}, fNlists::Ptr{factNodelists_t{Int64}}, gEtreeInfo::Ptr{gEtreeInfo_t{Int64}}, options::Ptr{superlu_dist_options_t}, gIperm_c_supno::Ptr{int_t}, ldt::int_t, HyP::Ptr{HyP_t}, LUstruct::Ptr{sLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, stat::Ptr{SuperLUStat_t{Int64}}, thresh::Cdouble, SCT::Ptr{SCT_t}, tag_ub::Cint, info::Ptr{Cint})::int_t
end
function sLluBufInitArr(numLA, LUstruct)
@ccall libsuperlu_dist_Int64.sLluBufInitArr(numLA::int_t, LUstruct::Ptr{sLUstruct_t{Int64}})::Ptr{Ptr{sLUValSubBuf_t{Int64}}}
end
function sLluBufFreeArr(numLA, LUvsbs)
@ccall libsuperlu_dist_Int64.sLluBufFreeArr(numLA::int_t, LUvsbs::Ptr{Ptr{sLUValSubBuf_t{Int64}}})::Cint
end
function sinitDiagFactBufsArr(mxLeafNode, ldt, grid)
@ccall libsuperlu_dist_Int64.sinitDiagFactBufsArr(mxLeafNode::int_t, ldt::int_t, grid::Ptr{gridinfo_t{Int64}})::Ptr{Ptr{sdiagFactBufs_t}}
end
function sfreeDiagFactBufsArr(mxLeafNode, dFBufs)
@ccall libsuperlu_dist_Int64.sfreeDiagFactBufsArr(mxLeafNode::int_t, dFBufs::Ptr{Ptr{sdiagFactBufs_t}})::Cint
end
function sinitDiagFactBufs(ldt, dFBuf)
@ccall libsuperlu_dist_Int64.sinitDiagFactBufs(ldt::int_t, dFBuf::Ptr{sdiagFactBufs_t})::int_t
end
function slud_z_div(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.slud_z_div(arg1::Ptr{doublecomplex}, arg2::Ptr{doublecomplex}, arg3::Ptr{doublecomplex})::Cvoid
end
function slud_z_abs(arg1)
@ccall libsuperlu_dist_Int64.slud_z_abs(arg1::Ptr{doublecomplex})::Cdouble
end
function slud_z_abs1(arg1)
@ccall libsuperlu_dist_Int64.slud_z_abs1(arg1::Ptr{doublecomplex})::Cdouble
end
function zCreate_CompCol_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int64.zCreate_CompCol_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{doublecomplex}, arg6::Ptr{int_t}, arg7::Ptr{int_t}, arg8::Stype_t, arg9::Dtype_t, arg10::Mtype_t)::Cvoid
end
function zCreate_CompRowLoc_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int64.zCreate_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::int_t, arg6::int_t, arg7::Ptr{doublecomplex}, arg8::Ptr{int_t}, arg9::Ptr{int_t}, arg10::Stype_t, arg11::Dtype_t, arg12::Mtype_t)::Cvoid
end
function zCompRow_to_CompCol_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.zCompRow_to_CompCol_dist(arg1::int_t, arg2::int_t, arg3::int_t, arg4::Ptr{doublecomplex}, arg5::Ptr{int_t}, arg6::Ptr{int_t}, arg7::Ptr{Ptr{doublecomplex}}, arg8::Ptr{Ptr{int_t}}, arg9::Ptr{Ptr{int_t}})::Cvoid
end
function pzCompRow_loc_to_CompCol_global(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.pzCompRow_loc_to_CompCol_global(arg1::int_t, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{SuperMatrix{Int64}})::Cint
end
function zCopy_CompCol_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int64.zCopy_CompCol_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{SuperMatrix{Int64}})::Cvoid
end
function zCreate_Dense_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.zCreate_Dense_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::int_t, arg3::int_t, arg4::Ptr{doublecomplex}, arg5::int_t, arg6::Stype_t, arg7::Dtype_t, arg8::Mtype_t)::Cvoid
end
function zCreate_SuperNode_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13)
@ccall libsuperlu_dist_Int64.zCreate_SuperNode_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{doublecomplex}, arg6::Ptr{int_t}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{int_t}, arg10::Ptr{int_t}, arg11::Stype_t, arg12::Dtype_t, arg13::Mtype_t)::Cvoid
end
function zCopy_Dense_Matrix_dist(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.zCopy_Dense_Matrix_dist(arg1::int_t, arg2::int_t, arg3::Ptr{doublecomplex}, arg4::int_t, arg5::Ptr{doublecomplex}, arg6::int_t)::Cvoid
end
function zallocateA_dist(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int64.zallocateA_dist(arg1::int_t, arg2::int_t, arg3::Ptr{Ptr{doublecomplex}}, arg4::Ptr{Ptr{int_t}}, arg5::Ptr{Ptr{int_t}})::Cvoid
end
function zGenXtrue_dist(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.zGenXtrue_dist(arg1::int_t, arg2::int_t, arg3::Ptr{doublecomplex}, arg4::int_t)::Cvoid
end
function zFillRHS_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.zFillRHS_dist(arg1::Ptr{Cchar}, arg2::int_t, arg3::Ptr{doublecomplex}, arg4::int_t, arg5::Ptr{SuperMatrix{Int64}}, arg6::Ptr{doublecomplex}, arg7::int_t)::Cvoid
end
function zcreate_matrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.zcreate_matrix(arg1::Ptr{SuperMatrix{Int64}}, arg2::Cint, arg3::Ptr{Ptr{doublecomplex}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{doublecomplex}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{gridinfo_t{Int64}})::Cint
end
function zcreate_matrix_rb(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.zcreate_matrix_rb(arg1::Ptr{SuperMatrix{Int64}}, arg2::Cint, arg3::Ptr{Ptr{doublecomplex}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{doublecomplex}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{gridinfo_t{Int64}})::Cint
end
function zcreate_matrix_dat(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.zcreate_matrix_dat(arg1::Ptr{SuperMatrix{Int64}}, arg2::Cint, arg3::Ptr{Ptr{doublecomplex}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{doublecomplex}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{gridinfo_t{Int64}})::Cint
end
function zcreate_matrix_postfix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.zcreate_matrix_postfix(arg1::Ptr{SuperMatrix{Int64}}, arg2::Cint, arg3::Ptr{Ptr{doublecomplex}}, arg4::Ptr{Cint}, arg5::Ptr{Ptr{doublecomplex}}, arg6::Ptr{Cint}, arg7::Ptr{Libc.FILE}, arg8::Ptr{Cchar}, arg9::Ptr{gridinfo_t{Int64}})::Cint
end
function zScalePermstructInit(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.zScalePermstructInit(arg1::int_t, arg2::int_t, arg3::Ptr{zScalePermstruct_t})::Cvoid
end
function zScalePermstructFree(arg1)
@ccall libsuperlu_dist_Int64.zScalePermstructFree(arg1::Ptr{zScalePermstruct_t})::Cvoid
end
function zgsequ_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.zgsequ_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble}, arg7::Ptr{int_t})::Cvoid
end
function zlangs_dist(arg1, arg2)
@ccall libsuperlu_dist_Int64.zlangs_dist(arg1::Ptr{Cchar}, arg2::Ptr{SuperMatrix{Int64}})::Cdouble
end
function zlaqgs_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.zlaqgs_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Cdouble, arg5::Cdouble, arg6::Cdouble, arg7::Ptr{Cchar})::Cvoid
end
function pzgsequ(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.pzgsequ(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble}, arg7::Ptr{int_t}, arg8::Ptr{gridinfo_t{Int64}})::Cvoid
end
function pzlangs(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.pzlangs(arg1::Ptr{Cchar}, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{gridinfo_t{Int64}})::Cdouble
end
function pzlaqgs(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.pzlaqgs(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{Cdouble}, arg3::Ptr{Cdouble}, arg4::Cdouble, arg5::Cdouble, arg6::Cdouble, arg7::Ptr{Cchar})::Cvoid
end
function pzPermute_Dense_Matrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int64.pzPermute_Dense_Matrix(arg1::int_t, arg2::int_t, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{doublecomplex}, arg6::Cint, arg7::Ptr{doublecomplex}, arg8::Cint, arg9::Cint, arg10::Ptr{gridinfo_t{Int64}})::Cint
end
function sp_ztrsv_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.sp_ztrsv_dist(arg1::Ptr{Cchar}, arg2::Ptr{Cchar}, arg3::Ptr{Cchar}, arg4::Ptr{SuperMatrix{Int64}}, arg5::Ptr{SuperMatrix{Int64}}, arg6::Ptr{doublecomplex}, arg7::Ptr{Cint})::Cint
end
function sp_zgemv_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.sp_zgemv_dist(arg1::Ptr{Cchar}, arg2::doublecomplex, arg3::Ptr{SuperMatrix{Int64}}, arg4::Ptr{doublecomplex}, arg5::Cint, arg6::doublecomplex, arg7::Ptr{doublecomplex}, arg8::Cint)::Cint
end
function sp_zgemm_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.sp_zgemm_dist(arg1::Ptr{Cchar}, arg2::Cint, arg3::doublecomplex, arg4::Ptr{SuperMatrix{Int64}}, arg5::Ptr{doublecomplex}, arg6::Cint, arg7::doublecomplex, arg8::Ptr{doublecomplex}, arg9::Cint)::Cint
end
function zdistribute(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.zdistribute(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int64}}, arg4::Ptr{Glu_freeable_t{Int64}}, arg5::Ptr{zLUstruct_t{Int64}}, arg6::Ptr{gridinfo_t{Int64}})::Cfloat
end
function pzgssvx_ABglobal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
@ccall libsuperlu_dist_Int64.pzgssvx_ABglobal(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{zScalePermstruct_t}, arg4::Ptr{doublecomplex}, arg5::Cint, arg6::Cint, arg7::Ptr{gridinfo_t{Int64}}, arg8::Ptr{zLUstruct_t{Int64}}, arg9::Ptr{Cdouble}, arg10::Ptr{SuperLUStat_t{Int64}}, arg11::Ptr{Cint})::Cvoid
end
function pzdistribute(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.pzdistribute(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int64}}, arg4::Ptr{zScalePermstruct_t}, arg5::Ptr{Glu_freeable_t{Int64}}, arg6::Ptr{zLUstruct_t{Int64}}, arg7::Ptr{gridinfo_t{Int64}})::Cfloat
end
function pzgssvx(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int64.pzgssvx(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{zScalePermstruct_t}, arg4::Ptr{doublecomplex}, arg5::Cint, arg6::Cint, arg7::Ptr{gridinfo_t{Int64}}, arg8::Ptr{zLUstruct_t{Int64}}, arg9::Ptr{zSOLVEstruct_t{Int64}}, arg10::Ptr{Cdouble}, arg11::Ptr{SuperLUStat_t{Int64}}, arg12::Ptr{Cint})::Cvoid
end
function pzCompute_Diag_Inv(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int64.pzCompute_Diag_Inv(arg1::int_t, arg2::Ptr{zLUstruct_t{Int64}}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{SuperLUStat_t{Int64}}, arg5::Ptr{Cint})::Cvoid
end
function zSolveInit(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.zSolveInit(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::int_t, arg6::Ptr{zLUstruct_t{Int64}}, arg7::Ptr{gridinfo_t{Int64}}, arg8::Ptr{zSOLVEstruct_t{Int64}})::Cint
end
function zSolveFinalize(arg1, arg2)
@ccall libsuperlu_dist_Int64.zSolveFinalize(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{zSOLVEstruct_t{Int64}})::Cvoid
end
function zDestroy_A3d_gathered_on_2d(arg1, arg2)
@ccall libsuperlu_dist_Int64.zDestroy_A3d_gathered_on_2d(arg1::Ptr{zSOLVEstruct_t{Int64}}, arg2::Ptr{gridinfo3d_t{Int64}})::Cvoid
end
function pzgstrs_init(arg1, arg2, arg3, arg4, arg5, arg6, grid, arg8, arg9)
@ccall libsuperlu_dist_Int64.pzgstrs_init(arg1::int_t, arg2::int_t, arg3::int_t, arg4::int_t, arg5::Ptr{int_t}, arg6::Ptr{int_t}, grid::Ptr{gridinfo_t{Int64}}, arg8::Ptr{Glu_persist_t}, arg9::Ptr{zSOLVEstruct_t{Int64}})::int_t
end
function zldperm_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.zldperm_dist(arg1::Cint, arg2::Cint, arg3::int_t, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{doublecomplex}, arg7::Ptr{int_t}, arg8::Ptr{Cdouble}, arg9::Ptr{Cdouble})::Cint
end
function zstatic_schedule(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.zstatic_schedule(arg1::Ptr{superlu_dist_options_t}, arg2::Cint, arg3::Cint, arg4::Ptr{zLUstruct_t{Int64}}, arg5::Ptr{gridinfo_t{Int64}}, arg6::Ptr{SuperLUStat_t{Int64}}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{Cint})::Cint
end
function zLUstructInit(arg1, arg2)
@ccall libsuperlu_dist_Int64.zLUstructInit(arg1::int_t, arg2::Ptr{zLUstruct_t{Int64}})::Cvoid
end
function zLUstructFree(arg1)
@ccall libsuperlu_dist_Int64.zLUstructFree(arg1::Ptr{zLUstruct_t{Int64}})::Cvoid
end
function zDestroy_LU(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.zDestroy_LU(arg1::int_t, arg2::Ptr{gridinfo_t{Int64}}, arg3::Ptr{zLUstruct_t{Int64}})::Cvoid
end
function zDestroy_Tree(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.zDestroy_Tree(arg1::int_t, arg2::Ptr{gridinfo_t{Int64}}, arg3::Ptr{zLUstruct_t{Int64}})::Cvoid
end
function zscatter_l(ib, ljb, nsupc, iukp, xsup, klst, nbrow, lptr, temp_nbrow, usub, lsub, tempv, indirect_thread, indirect2, Lrowind_bc_ptr, Lnzval_bc_ptr, grid)
@ccall libsuperlu_dist_Int64.zscatter_l(ib::Cint, ljb::Cint, nsupc::Cint, iukp::int_t, xsup::Ptr{int_t}, klst::Cint, nbrow::Cint, lptr::int_t, temp_nbrow::Cint, usub::Ptr{int_t}, lsub::Ptr{int_t}, tempv::Ptr{doublecomplex}, indirect_thread::Ptr{Cint}, indirect2::Ptr{Cint}, Lrowind_bc_ptr::Ptr{Ptr{int_t}}, Lnzval_bc_ptr::Ptr{Ptr{doublecomplex}}, grid::Ptr{gridinfo_t{Int64}})::Cvoid
end
function zscatter_u(ib, jb, nsupc, iukp, xsup, klst, nbrow, lptr, temp_nbrow, lsub, usub, tempv, Ufstnz_br_ptr, Unzval_br_ptr, grid)
@ccall libsuperlu_dist_Int64.zscatter_u(ib::Cint, jb::Cint, nsupc::Cint, iukp::int_t, xsup::Ptr{int_t}, klst::Cint, nbrow::Cint, lptr::int_t, temp_nbrow::Cint, lsub::Ptr{int_t}, usub::Ptr{int_t}, tempv::Ptr{doublecomplex}, Ufstnz_br_ptr::Ptr{Ptr{int_t}}, Unzval_br_ptr::Ptr{Ptr{doublecomplex}}, grid::Ptr{gridinfo_t{Int64}})::Cvoid
end
function pzgstrf(arg1, arg2, arg3, anorm, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.pzgstrf(arg1::Ptr{superlu_dist_options_t}, arg2::Cint, arg3::Cint, anorm::Cdouble, arg5::Ptr{zLUstruct_t{Int64}}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{SuperLUStat_t{Int64}}, arg8::Ptr{Cint})::int_t
end
function pzgstrs_Bglobal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.pzgstrs_Bglobal(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{zLUstruct_t{Int64}}, arg4::Ptr{gridinfo_t{Int64}}, arg5::Ptr{doublecomplex}, arg6::int_t, arg7::Cint, arg8::Ptr{SuperLUStat_t{Int64}}, arg9::Ptr{Cint})::Cvoid
end
function pzgstrs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13)
@ccall libsuperlu_dist_Int64.pzgstrs(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{zLUstruct_t{Int64}}, arg4::Ptr{zScalePermstruct_t}, arg5::Ptr{gridinfo_t{Int64}}, arg6::Ptr{doublecomplex}, arg7::int_t, arg8::int_t, arg9::int_t, arg10::Cint, arg11::Ptr{zSOLVEstruct_t{Int64}}, arg12::Ptr{SuperLUStat_t{Int64}}, arg13::Ptr{Cint})::Cvoid
end
function pzgstrf2_trsm(options, k0, k, thresh, arg5, arg6, arg7, arg8, tag_ub, arg10, info)
@ccall libsuperlu_dist_Int64.pzgstrf2_trsm(options::Ptr{superlu_dist_options_t}, k0::int_t, k::int_t, thresh::Cdouble, arg5::Ptr{Glu_persist_t}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{zLocalLU_t{Int64}}, arg8::Ptr{MPI_Request}, tag_ub::Cint, arg10::Ptr{SuperLUStat_t{Int64}}, info::Ptr{Cint})::Cvoid
end
function pzgstrs2_omp(k0, k, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.pzgstrs2_omp(k0::int_t, k::int_t, arg3::Ptr{Glu_persist_t}, arg4::Ptr{gridinfo_t{Int64}}, arg5::Ptr{zLocalLU_t{Int64}}, arg6::Ptr{Ublock_info_t}, arg7::Ptr{SuperLUStat_t{Int64}})::Cvoid
end
function pzReDistribute_B_to_X(B, m_loc, nrhs, ldb, fst_row, ilsum, x, arg8, arg9, arg10, arg11)
@ccall libsuperlu_dist_Int64.pzReDistribute_B_to_X(B::Ptr{doublecomplex}, m_loc::int_t, nrhs::Cint, ldb::int_t, fst_row::int_t, ilsum::Ptr{int_t}, x::Ptr{doublecomplex}, arg8::Ptr{zScalePermstruct_t}, arg9::Ptr{Glu_persist_t}, arg10::Ptr{gridinfo_t{Int64}}, arg11::Ptr{zSOLVEstruct_t{Int64}})::int_t
end
function zlsum_fmod(arg1, arg2, arg3, arg4, arg5, arg6, arg7, fmod, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16)
@ccall libsuperlu_dist_Int64.zlsum_fmod(arg1::Ptr{doublecomplex}, arg2::Ptr{doublecomplex}, arg3::Ptr{doublecomplex}, arg4::Ptr{doublecomplex}, arg5::Cint, arg6::Cint, arg7::int_t, fmod::Ptr{Cint}, arg9::int_t, arg10::int_t, arg11::int_t, arg12::Ptr{int_t}, arg13::Ptr{gridinfo_t{Int64}}, arg14::Ptr{zLocalLU_t{Int64}}, arg15::Ptr{MPI_Request}, arg16::Ptr{SuperLUStat_t{Int64}})::Cvoid
end
function zlsum_bmod(arg1, arg2, arg3, arg4, arg5, bmod, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14)
@ccall libsuperlu_dist_Int64.zlsum_bmod(arg1::Ptr{doublecomplex}, arg2::Ptr{doublecomplex}, arg3::Ptr{doublecomplex}, arg4::Cint, arg5::int_t, bmod::Ptr{Cint}, arg7::Ptr{int_t}, arg8::Ptr{Ptr{Ucb_indptr_t}}, arg9::Ptr{Ptr{int_t}}, arg10::Ptr{int_t}, arg11::Ptr{gridinfo_t{Int64}}, arg12::Ptr{zLocalLU_t{Int64}}, arg13::Ptr{MPI_Request}, arg14::Ptr{SuperLUStat_t{Int64}})::Cvoid
end
function zlsum_fmod_inv(arg1, arg2, arg3, arg4, arg5, arg6, fmod, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19)
@ccall libsuperlu_dist_Int64.zlsum_fmod_inv(arg1::Ptr{doublecomplex}, arg2::Ptr{doublecomplex}, arg3::Ptr{doublecomplex}, arg4::Ptr{doublecomplex}, arg5::Cint, arg6::int_t, fmod::Ptr{Cint}, arg8::Ptr{int_t}, arg9::Ptr{gridinfo_t{Int64}}, arg10::Ptr{zLocalLU_t{Int64}}, arg11::Ptr{Ptr{SuperLUStat_t{Int64}}}, arg12::Ptr{int_t}, arg13::Ptr{int_t}, arg14::int_t, arg15::int_t, arg16::int_t, arg17::int_t, arg18::Cint, arg19::Cint)::Cvoid
end
function zlsum_fmod_inv_master(arg1, arg2, arg3, arg4, arg5, arg6, arg7, fmod, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19)
@ccall libsuperlu_dist_Int64.zlsum_fmod_inv_master(arg1::Ptr{doublecomplex}, arg2::Ptr{doublecomplex}, arg3::Ptr{doublecomplex}, arg4::Ptr{doublecomplex}, arg5::Cint, arg6::Cint, arg7::int_t, fmod::Ptr{Cint}, arg9::int_t, arg10::Ptr{int_t}, arg11::Ptr{gridinfo_t{Int64}}, arg12::Ptr{zLocalLU_t{Int64}}, arg13::Ptr{Ptr{SuperLUStat_t{Int64}}}, arg14::int_t, arg15::int_t, arg16::int_t, arg17::int_t, arg18::Cint, arg19::Cint)::Cvoid
end
function zlsum_bmod_inv(arg1, arg2, arg3, arg4, arg5, arg6, bmod, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20)
@ccall libsuperlu_dist_Int64.zlsum_bmod_inv(arg1::Ptr{doublecomplex}, arg2::Ptr{doublecomplex}, arg3::Ptr{doublecomplex}, arg4::Ptr{doublecomplex}, arg5::Cint, arg6::int_t, bmod::Ptr{Cint}, arg8::Ptr{int_t}, arg9::Ptr{Ptr{Ucb_indptr_t}}, arg10::Ptr{Ptr{int_t}}, arg11::Ptr{int_t}, arg12::Ptr{gridinfo_t{Int64}}, arg13::Ptr{zLocalLU_t{Int64}}, arg14::Ptr{Ptr{SuperLUStat_t{Int64}}}, arg15::Ptr{int_t}, arg16::Ptr{int_t}, arg17::int_t, arg18::int_t, arg19::Cint, arg20::Cint)::Cvoid
end
function zlsum_bmod_inv_master(arg1, arg2, arg3, arg4, arg5, arg6, bmod, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18)
@ccall libsuperlu_dist_Int64.zlsum_bmod_inv_master(arg1::Ptr{doublecomplex}, arg2::Ptr{doublecomplex}, arg3::Ptr{doublecomplex}, arg4::Ptr{doublecomplex}, arg5::Cint, arg6::int_t, bmod::Ptr{Cint}, arg8::Ptr{int_t}, arg9::Ptr{Ptr{Ucb_indptr_t}}, arg10::Ptr{Ptr{int_t}}, arg11::Ptr{int_t}, arg12::Ptr{gridinfo_t{Int64}}, arg13::Ptr{zLocalLU_t{Int64}}, arg14::Ptr{Ptr{SuperLUStat_t{Int64}}}, arg15::int_t, arg16::int_t, arg17::Cint, arg18::Cint)::Cvoid
end
function zComputeLevelsets(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.zComputeLevelsets(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{zLocalLU_t{Int64}}, arg6::Ptr{int_t})::Cvoid
end
function pzgsrfs(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16)
@ccall libsuperlu_dist_Int64.pzgsrfs(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int64}}, arg4::Cdouble, arg5::Ptr{zLUstruct_t{Int64}}, arg6::Ptr{zScalePermstruct_t}, arg7::Ptr{gridinfo_t{Int64}}, arg8::Ptr{doublecomplex}, arg9::int_t, arg10::Ptr{doublecomplex}, arg11::int_t, arg12::Cint, arg13::Ptr{zSOLVEstruct_t{Int64}}, arg14::Ptr{Cdouble}, arg15::Ptr{SuperLUStat_t{Int64}}, arg16::Ptr{Cint})::Cvoid
end
function pzgsrfs_ABXglobal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14)
@ccall libsuperlu_dist_Int64.pzgsrfs_ABXglobal(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int64}}, arg4::Cdouble, arg5::Ptr{zLUstruct_t{Int64}}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{doublecomplex}, arg8::int_t, arg9::Ptr{doublecomplex}, arg10::int_t, arg11::Cint, arg12::Ptr{Cdouble}, arg13::Ptr{SuperLUStat_t{Int64}}, arg14::Ptr{Cint})::Cvoid
end
function pzgsmv_AXglobal_setup(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.pzgsmv_AXglobal_setup(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{Glu_persist_t}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{int_t}}, arg6::Ptr{Ptr{doublecomplex}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{int_t})::Cint
end
function pzgsmv_AXglobal(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.pzgsmv_AXglobal(arg1::int_t, arg2::Ptr{int_t}, arg3::Ptr{doublecomplex}, arg4::Ptr{int_t}, arg5::Ptr{doublecomplex}, arg6::Ptr{doublecomplex})::Cint
end
function pzgsmv_AXglobal_abs(arg1, arg2, arg3, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.pzgsmv_AXglobal_abs(arg1::int_t, arg2::Ptr{int_t}, arg3::Ptr{doublecomplex}, arg4::Ptr{int_t}, arg5::Ptr{doublecomplex}, arg6::Ptr{Cdouble})::Cint
end
function pzgsmv_init(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.pzgsmv_init(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{int_t}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{pzgsmv_comm_t})::Cvoid
end
function pzgsmv(arg1, arg2, arg3, arg4, x, ax)
@ccall libsuperlu_dist_Int64.pzgsmv(arg1::int_t, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{pzgsmv_comm_t}, x::Ptr{doublecomplex}, ax::Ptr{doublecomplex})::Cvoid
end
function pzgsmv_finalize(arg1)
@ccall libsuperlu_dist_Int64.pzgsmv_finalize(arg1::Ptr{pzgsmv_comm_t})::Cvoid
end
function doublecomplexMalloc_dist(arg1)
@ccall libsuperlu_dist_Int64.doublecomplexMalloc_dist(arg1::int_t)::Ptr{doublecomplex}
end
function doublecomplexCalloc_dist(arg1)
@ccall libsuperlu_dist_Int64.doublecomplexCalloc_dist(arg1::int_t)::Ptr{doublecomplex}
end
function zQuerySpace_dist(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int64.zQuerySpace_dist(arg1::int_t, arg2::Ptr{zLUstruct_t{Int64}}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{SuperLUStat_t{Int64}}, arg5::Ptr{superlu_dist_mem_usage_t})::int_t
end
function zClone_CompRowLoc_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int64.zClone_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{SuperMatrix{Int64}})::Cvoid
end
function zCopy_CompRowLoc_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int64.zCopy_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{SuperMatrix{Int64}})::Cvoid
end
function zZero_CompRowLoc_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int64.zZero_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}})::Cvoid
end
function zScaleAddId_CompRowLoc_Matrix_dist(arg1, arg2)
@ccall libsuperlu_dist_Int64.zScaleAddId_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::doublecomplex)::Cvoid
end
function zScaleAdd_CompRowLoc_Matrix_dist(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.zScaleAdd_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{SuperMatrix{Int64}}, arg3::doublecomplex)::Cvoid
end
function zZeroLblocks(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.zZeroLblocks(arg1::Cint, arg2::Cint, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{zLUstruct_t{Int64}})::Cvoid
end
function zZeroUblocks(iam, n, arg3, arg4)
@ccall libsuperlu_dist_Int64.zZeroUblocks(iam::Cint, n::Cint, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{zLUstruct_t{Int64}})::Cvoid
end
function zfill_dist(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.zfill_dist(arg1::Ptr{doublecomplex}, arg2::int_t, arg3::doublecomplex)::Cvoid
end
function zinf_norm_error_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.zinf_norm_error_dist(arg1::int_t, arg2::int_t, arg3::Ptr{doublecomplex}, arg4::int_t, arg5::Ptr{doublecomplex}, arg6::int_t, arg7::Ptr{gridinfo_t{Int64}})::Cvoid
end
function pzinf_norm_error(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.pzinf_norm_error(arg1::Cint, arg2::int_t, arg3::int_t, arg4::Ptr{doublecomplex}, arg5::int_t, arg6::Ptr{doublecomplex}, arg7::int_t, arg8::MPI_Comm)::Cvoid
end
function zreadhb_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.zreadhb_dist(arg1::Cint, arg2::Ptr{Libc.FILE}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{Ptr{doublecomplex}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}})::Cvoid
end
function zreadtriple_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.zreadtriple_dist(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{doublecomplex}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cvoid
end
function zreadtriple_noheader(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.zreadtriple_noheader(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{doublecomplex}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cvoid
end
function zreadrb_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.zreadrb_dist(arg1::Cint, arg2::Ptr{Libc.FILE}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{Ptr{doublecomplex}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}})::Cvoid
end
function zreadMM_dist(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.zreadMM_dist(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{doublecomplex}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cvoid
end
function zread_binary(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.zread_binary(arg1::Ptr{Libc.FILE}, arg2::Ptr{int_t}, arg3::Ptr{int_t}, arg4::Ptr{int_t}, arg5::Ptr{Ptr{doublecomplex}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}})::Cint
end
function zdist_psymbtonum(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.zdist_psymbtonum(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{SuperMatrix{Int64}}, arg4::Ptr{zScalePermstruct_t}, arg5::Ptr{Pslu_freeable_t}, arg6::Ptr{zLUstruct_t{Int64}}, arg7::Ptr{gridinfo_t{Int64}})::Cfloat
end
function pzGetDiagU(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.pzGetDiagU(arg1::int_t, arg2::Ptr{zLUstruct_t{Int64}}, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{doublecomplex})::Cvoid
end
function z_c2cpp_GetHWPM(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.z_c2cpp_GetHWPM(arg1::Ptr{SuperMatrix{Int64}}, arg2::Ptr{gridinfo_t{Int64}}, arg3::Ptr{zScalePermstruct_t})::Cint
end
function zPrintLblocks(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int64.zPrintLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{zLocalLU_t{Int64}})::Cvoid
end
function zPrintUblocks(arg1, arg2, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int64.zPrintUblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{zLocalLU_t{Int64}})::Cvoid
end
function zPrint_CompCol_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int64.zPrint_CompCol_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}})::Cvoid
end
function zPrint_Dense_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int64.zPrint_Dense_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}})::Cvoid
end
function zPrint_CompRowLoc_Matrix_dist(arg1)
@ccall libsuperlu_dist_Int64.zPrint_CompRowLoc_Matrix_dist(arg1::Ptr{SuperMatrix{Int64}})::Cint
end
function file_zPrint_CompRowLoc_Matrix_dist(fp, A)
@ccall libsuperlu_dist_Int64.file_zPrint_CompRowLoc_Matrix_dist(fp::Ptr{Libc.FILE}, A::Ptr{SuperMatrix{Int64}})::Cint
end
function PrintDoublecomplex(arg1, arg2, arg3)
@ccall libsuperlu_dist_Int64.PrintDoublecomplex(arg1::Ptr{Cchar}, arg2::int_t, arg3::Ptr{doublecomplex})::Cvoid
end
function file_PrintDoublecomplex(fp, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.file_PrintDoublecomplex(fp::Ptr{Libc.FILE}, arg2::Ptr{Cchar}, arg3::int_t, arg4::Ptr{doublecomplex})::Cint
end
function zGenCOOLblocks(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int64.zGenCOOLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{zLocalLU_t{Int64}}, arg6::Ptr{Ptr{int_t}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{doublecomplex}}, arg9::Ptr{int_t}, arg10::Ptr{int_t})::Cvoid
end
function zGenCSCLblocks(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int64.zGenCSCLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{zLocalLU_t{Int64}}, arg6::Ptr{Ptr{doublecomplex}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}}, arg9::Ptr{int_t}, arg10::Ptr{int_t})::Cvoid
end
function zGenCSRLblocks(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int64.zGenCSRLblocks(arg1::Cint, arg2::int_t, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{Glu_persist_t}, arg5::Ptr{zLocalLU_t{Int64}}, arg6::Ptr{Ptr{doublecomplex}}, arg7::Ptr{Ptr{int_t}}, arg8::Ptr{Ptr{int_t}}, arg9::Ptr{int_t}, arg10::Ptr{int_t})::Cvoid
end
function superlu_zgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
@ccall libsuperlu_dist_Int64.superlu_zgemm(transa::Ptr{Cchar}, transb::Ptr{Cchar}, m::Cint, n::Cint, k::Cint, alpha::doublecomplex, a::Ptr{doublecomplex}, lda::Cint, b::Ptr{doublecomplex}, ldb::Cint, beta::doublecomplex, c::Ptr{doublecomplex}, ldc::Cint)::Cint
end
function superlu_ztrsm(sideRL, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
@ccall libsuperlu_dist_Int64.superlu_ztrsm(sideRL::Ptr{Cchar}, uplo::Ptr{Cchar}, transa::Ptr{Cchar}, diag::Ptr{Cchar}, m::Cint, n::Cint, alpha::doublecomplex, a::Ptr{doublecomplex}, lda::Cint, b::Ptr{doublecomplex}, ldb::Cint)::Cint
end
function superlu_zger(m, n, alpha, x, incx, y, incy, a, lda)
@ccall libsuperlu_dist_Int64.superlu_zger(m::Cint, n::Cint, alpha::doublecomplex, x::Ptr{doublecomplex}, incx::Cint, y::Ptr{doublecomplex}, incy::Cint, a::Ptr{doublecomplex}, lda::Cint)::Cint
end
function superlu_zscal(n, alpha, x, incx)
@ccall libsuperlu_dist_Int64.superlu_zscal(n::Cint, alpha::doublecomplex, x::Ptr{doublecomplex}, incx::Cint)::Cint
end
function superlu_zaxpy(n, alpha, x, incx, y, incy)
@ccall libsuperlu_dist_Int64.superlu_zaxpy(n::Cint, alpha::doublecomplex, x::Ptr{doublecomplex}, incx::Cint, y::Ptr{doublecomplex}, incy::Cint)::Cint
end
function superlu_zgemv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy)
@ccall libsuperlu_dist_Int64.superlu_zgemv(trans::Ptr{Cchar}, m::Cint, n::Cint, alpha::doublecomplex, a::Ptr{doublecomplex}, lda::Cint, x::Ptr{doublecomplex}, incx::Cint, beta::doublecomplex, y::Ptr{doublecomplex}, incy::Cint)::Cint
end
function superlu_ztrsv(uplo, trans, diag, n, a, lda, x, incx)
@ccall libsuperlu_dist_Int64.superlu_ztrsv(uplo::Ptr{Cchar}, trans::Ptr{Cchar}, diag::Ptr{Cchar}, n::Cint, a::Ptr{doublecomplex}, lda::Cint, x::Ptr{doublecomplex}, incx::Cint)::Cint
end
function zcreate_matrix3d(A, nrhs, rhs, ldb, x, ldx, fp, grid3d)
@ccall libsuperlu_dist_Int64.zcreate_matrix3d(A::Ptr{SuperMatrix{Int64}}, nrhs::Cint, rhs::Ptr{Ptr{doublecomplex}}, ldb::Ptr{Cint}, x::Ptr{Ptr{doublecomplex}}, ldx::Ptr{Cint}, fp::Ptr{Libc.FILE}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cint
end
function zcreate_matrix_postfix3d(A, nrhs, rhs, ldb, x, ldx, fp, postfix, grid3d)
@ccall libsuperlu_dist_Int64.zcreate_matrix_postfix3d(A::Ptr{SuperMatrix{Int64}}, nrhs::Cint, rhs::Ptr{Ptr{doublecomplex}}, ldb::Ptr{Cint}, x::Ptr{Ptr{doublecomplex}}, ldx::Ptr{Cint}, fp::Ptr{Libc.FILE}, postfix::Ptr{Cchar}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cint
end
function zGatherNRformat_loc3d(Fact, A, B, ldb, nrhs, grid3d, arg7)
@ccall libsuperlu_dist_Int64.zGatherNRformat_loc3d(Fact::fact_t, A::Ptr{NRformat_loc{Int64}}, B::Ptr{doublecomplex}, ldb::Cint, nrhs::Cint, grid3d::Ptr{gridinfo3d_t{Int64}}, arg7::Ptr{Ptr{NRformat_loc3d{Int64}}})::Cvoid
end
function zScatter_B3d(A3d, grid3d)
@ccall libsuperlu_dist_Int64.zScatter_B3d(A3d::Ptr{NRformat_loc3d{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cint
end
function pzgssvx3d(arg1, arg2, arg3, B, ldb, nrhs, arg7, arg8, arg9, berr, arg11, info)
@ccall libsuperlu_dist_Int64.pzgssvx3d(arg1::Ptr{superlu_dist_options_t}, arg2::Ptr{SuperMatrix{Int64}}, arg3::Ptr{zScalePermstruct_t}, B::Ptr{doublecomplex}, ldb::Cint, nrhs::Cint, arg7::Ptr{gridinfo3d_t{Int64}}, arg8::Ptr{zLUstruct_t{Int64}}, arg9::Ptr{zSOLVEstruct_t{Int64}}, berr::Ptr{Cdouble}, arg11::Ptr{SuperLUStat_t{Int64}}, info::Ptr{Cint})::Cvoid
end
function pzgstrf3d(arg1, m, n, anorm, arg5, arg6, arg7, arg8, arg9, arg10)
@ccall libsuperlu_dist_Int64.pzgstrf3d(arg1::Ptr{superlu_dist_options_t}, m::Cint, n::Cint, anorm::Cdouble, arg5::Ptr{ztrf3Dpartition_t{Int64}}, arg6::Ptr{SCT_t}, arg7::Ptr{zLUstruct_t{Int64}}, arg8::Ptr{gridinfo3d_t{Int64}}, arg9::Ptr{SuperLUStat_t{Int64}}, arg10::Ptr{Cint})::int_t
end
function zInit_HyP(HyP, Llu, mcb, mrb)
@ccall libsuperlu_dist_Int64.zInit_HyP(HyP::Ptr{HyP_t}, Llu::Ptr{zLocalLU_t{Int64}}, mcb::int_t, mrb::int_t)::Cvoid
end
function zblock_gemm_scatter(lb, j, Ublock_info, Remain_info, L_mat, ldl, U_mat, ldu, bigV, knsupc, klst, lsub, usub, ldt, thread_id, indirect, indirect2, Lrowind_bc_ptr, Lnzval_bc_ptr, Ufstnz_br_ptr, Unzval_br_ptr, xsup, arg23, arg24)
@ccall libsuperlu_dist_Int64.zblock_gemm_scatter(lb::int_t, j::int_t, Ublock_info::Ptr{Ublock_info_t}, Remain_info::Ptr{Remain_info_t}, L_mat::Ptr{doublecomplex}, ldl::Cint, U_mat::Ptr{doublecomplex}, ldu::Cint, bigV::Ptr{doublecomplex}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, thread_id::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, Lrowind_bc_ptr::Ptr{Ptr{int_t}}, Lnzval_bc_ptr::Ptr{Ptr{doublecomplex}}, Ufstnz_br_ptr::Ptr{Ptr{int_t}}, Unzval_br_ptr::Ptr{Ptr{doublecomplex}}, xsup::Ptr{int_t}, arg23::Ptr{gridinfo_t{Int64}}, arg24::Ptr{SuperLUStat_t{Int64}})::Cvoid
end
function zblock_gemm_scatterTopLeft(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int64.zblock_gemm_scatterTopLeft(lb::int_t, j::int_t, bigV::Ptr{doublecomplex}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{zLUstruct_t{Int64}}, arg13::Ptr{gridinfo_t{Int64}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int64}})::int_t
end
function zblock_gemm_scatterTopRight(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int64.zblock_gemm_scatterTopRight(lb::int_t, j::int_t, bigV::Ptr{doublecomplex}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{zLUstruct_t{Int64}}, arg13::Ptr{gridinfo_t{Int64}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int64}})::int_t
end
function zblock_gemm_scatterBottomLeft(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int64.zblock_gemm_scatterBottomLeft(lb::int_t, j::int_t, bigV::Ptr{doublecomplex}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{zLUstruct_t{Int64}}, arg13::Ptr{gridinfo_t{Int64}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int64}})::int_t
end
function zblock_gemm_scatterBottomRight(lb, j, bigV, knsupc, klst, lsub, usub, ldt, indirect, indirect2, HyP, arg12, arg13, SCT, arg15)
@ccall libsuperlu_dist_Int64.zblock_gemm_scatterBottomRight(lb::int_t, j::int_t, bigV::Ptr{doublecomplex}, knsupc::int_t, klst::int_t, lsub::Ptr{int_t}, usub::Ptr{int_t}, ldt::int_t, indirect::Ptr{Cint}, indirect2::Ptr{Cint}, HyP::Ptr{HyP_t}, arg12::Ptr{zLUstruct_t{Int64}}, arg13::Ptr{gridinfo_t{Int64}}, SCT::Ptr{SCT_t}, arg15::Ptr{SuperLUStat_t{Int64}})::int_t
end
function zgather_u(num_u_blks, Ublock_info, usub, uval, bigU, ldu, xsup, klst)
@ccall libsuperlu_dist_Int64.zgather_u(num_u_blks::int_t, Ublock_info::Ptr{Ublock_info_t}, usub::Ptr{int_t}, uval::Ptr{doublecomplex}, bigU::Ptr{doublecomplex}, ldu::int_t, xsup::Ptr{int_t}, klst::int_t)::Cvoid
end
function zgather_l(num_LBlk, knsupc, L_info, lval, LD_lval, L_buff)
@ccall libsuperlu_dist_Int64.zgather_l(num_LBlk::int_t, knsupc::int_t, L_info::Ptr{Remain_info_t}, lval::Ptr{doublecomplex}, LD_lval::int_t, L_buff::Ptr{doublecomplex})::Cvoid
end
function zRgather_L(k, lsub, lusup, arg4, arg5, arg6, arg7, myIperm, iperm_c_supno)
@ccall libsuperlu_dist_Int64.zRgather_L(k::int_t, lsub::Ptr{int_t}, lusup::Ptr{doublecomplex}, arg4::Ptr{gEtreeInfo_t{Int64}}, arg5::Ptr{Glu_persist_t}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{HyP_t}, myIperm::Ptr{int_t}, iperm_c_supno::Ptr{int_t})::Cvoid
end
function zRgather_U(k, jj0, usub, uval, bigU, arg6, arg7, arg8, arg9, myIperm, iperm_c_supno, perm_u)
@ccall libsuperlu_dist_Int64.zRgather_U(k::int_t, jj0::int_t, usub::Ptr{int_t}, uval::Ptr{doublecomplex}, bigU::Ptr{doublecomplex}, arg6::Ptr{gEtreeInfo_t{Int64}}, arg7::Ptr{Glu_persist_t}, arg8::Ptr{gridinfo_t{Int64}}, arg9::Ptr{HyP_t}, myIperm::Ptr{int_t}, iperm_c_supno::Ptr{int_t}, perm_u::Ptr{int_t})::Cvoid
end
function zinitTrf3Dpartition(nsupers, options, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.zinitTrf3Dpartition(nsupers::int_t, options::Ptr{superlu_dist_options_t}, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::Ptr{ztrf3Dpartition_t{Int64}}
end
function zDestroy_trf3Dpartition(trf3Dpartition, grid3d)
@ccall libsuperlu_dist_Int64.zDestroy_trf3Dpartition(trf3Dpartition::Ptr{ztrf3Dpartition_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cvoid
end
function z3D_printMemUse(trf3Dpartition, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.z3D_printMemUse(trf3Dpartition::Ptr{ztrf3Dpartition_t{Int64}}, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cvoid
end
function zinit3DLUstructForest(myTreeIdxs, myZeroTrIdxs, sForests, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.zinit3DLUstructForest(myTreeIdxs::Ptr{int_t}, myZeroTrIdxs::Ptr{int_t}, sForests::Ptr{Ptr{sForest_t{Int64}}}, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::Cvoid
end
function zgatherAllFactoredLUFr(myZeroTrIdxs, sForests, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.zgatherAllFactoredLUFr(myZeroTrIdxs::Ptr{int_t}, sForests::Ptr{sForest_t{Int64}}, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function zLpanelUpdate(off0, nsupc, ublk_ptr, ld_ujrow, lusup, nsupr, arg7)
@ccall libsuperlu_dist_Int64.zLpanelUpdate(off0::int_t, nsupc::int_t, ublk_ptr::Ptr{doublecomplex}, ld_ujrow::int_t, lusup::Ptr{doublecomplex}, nsupr::int_t, arg7::Ptr{SCT_t})::int_t
end
function Local_Zgstrf2(options, k, thresh, BlockUFactor, arg5, arg6, arg7, arg8, info, arg10)
@ccall libsuperlu_dist_Int64.Local_Zgstrf2(options::Ptr{superlu_dist_options_t}, k::int_t, thresh::Cdouble, BlockUFactor::Ptr{doublecomplex}, arg5::Ptr{Glu_persist_t}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{zLocalLU_t{Int64}}, arg8::Ptr{SuperLUStat_t{Int64}}, info::Ptr{Cint}, arg10::Ptr{SCT_t})::Cvoid
end
function zTrs2_GatherU(iukp, rukp, klst, nsupc, ldu, usub, uval, tempv)
@ccall libsuperlu_dist_Int64.zTrs2_GatherU(iukp::int_t, rukp::int_t, klst::int_t, nsupc::int_t, ldu::int_t, usub::Ptr{int_t}, uval::Ptr{doublecomplex}, tempv::Ptr{doublecomplex})::int_t
end
function zTrs2_ScatterU(iukp, rukp, klst, nsupc, ldu, usub, uval, tempv)
@ccall libsuperlu_dist_Int64.zTrs2_ScatterU(iukp::int_t, rukp::int_t, klst::int_t, nsupc::int_t, ldu::int_t, usub::Ptr{int_t}, uval::Ptr{doublecomplex}, tempv::Ptr{doublecomplex})::int_t
end
function zTrs2_GatherTrsmScatter(klst, iukp, rukp, usub, uval, tempv, knsupc, nsupr, lusup, Glu_persist)
@ccall libsuperlu_dist_Int64.zTrs2_GatherTrsmScatter(klst::int_t, iukp::int_t, rukp::int_t, usub::Ptr{int_t}, uval::Ptr{doublecomplex}, tempv::Ptr{doublecomplex}, knsupc::int_t, nsupr::Cint, lusup::Ptr{doublecomplex}, Glu_persist::Ptr{Glu_persist_t})::int_t
end
function pzgstrs2(m, k0, k, Glu_persist, grid, Llu, stat)
@ccall libsuperlu_dist_Int64.pzgstrs2(m::int_t, k0::int_t, k::int_t, Glu_persist::Ptr{Glu_persist_t}, grid::Ptr{gridinfo_t{Int64}}, Llu::Ptr{zLocalLU_t{Int64}}, stat::Ptr{SuperLUStat_t{Int64}})::Cvoid
end
function pzgstrf2(arg1, nsupers, k0, k, thresh, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
@ccall libsuperlu_dist_Int64.pzgstrf2(arg1::Ptr{superlu_dist_options_t}, nsupers::int_t, k0::int_t, k::int_t, thresh::Cdouble, arg6::Ptr{Glu_persist_t}, arg7::Ptr{gridinfo_t{Int64}}, arg8::Ptr{zLocalLU_t{Int64}}, arg9::Ptr{MPI_Request}, arg10::Cint, arg11::Ptr{SuperLUStat_t{Int64}}, arg12::Ptr{Cint})::Cvoid
end
function zAllocLlu_3d(nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.zAllocLlu_3d(nsupers::int_t, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function zp3dScatter(n, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.zp3dScatter(n::int_t, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function zscatter3dLPanels(nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.zscatter3dLPanels(nsupers::int_t, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function zscatter3dUPanels(nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.zscatter3dUPanels(nsupers::int_t, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function zcollect3dLpanels(layer, nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.zcollect3dLpanels(layer::int_t, nsupers::int_t, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function zcollect3dUpanels(layer, nsupers, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.zcollect3dUpanels(layer::int_t, nsupers::int_t, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function zp3dCollect(layer, n, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.zp3dCollect(layer::int_t, n::int_t, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function zzeroSetLU(nnodes, nodeList, arg3, arg4)
@ccall libsuperlu_dist_Int64.zzeroSetLU(nnodes::int_t, nodeList::Ptr{int_t}, arg3::Ptr{zLUstruct_t{Int64}}, arg4::Ptr{gridinfo3d_t{Int64}})::int_t
end
function zAllocGlu_3d(n, nsupers, arg3)
@ccall libsuperlu_dist_Int64.zAllocGlu_3d(n::int_t, nsupers::int_t, arg3::Ptr{zLUstruct_t{Int64}})::Cint
end
function zDeAllocLlu_3d(n, arg2, arg3)
@ccall libsuperlu_dist_Int64.zDeAllocLlu_3d(n::int_t, arg2::Ptr{zLUstruct_t{Int64}}, arg3::Ptr{gridinfo3d_t{Int64}})::Cint
end
function zDeAllocGlu_3d(arg1)
@ccall libsuperlu_dist_Int64.zDeAllocGlu_3d(arg1::Ptr{zLUstruct_t{Int64}})::Cint
end
function zreduceAncestors3d(sender, receiver, nnodes, nodeList, Lval_buf, Uval_buf, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.zreduceAncestors3d(sender::int_t, receiver::int_t, nnodes::int_t, nodeList::Ptr{int_t}, Lval_buf::Ptr{doublecomplex}, Uval_buf::Ptr{doublecomplex}, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function zreduceAllAncestors3d(ilvl, myNodeCount, treePerm, LUvsb, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.zreduceAllAncestors3d(ilvl::int_t, myNodeCount::Ptr{int_t}, treePerm::Ptr{Ptr{int_t}}, LUvsb::Ptr{zLUValSubBuf_t{Int64}}, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::Cint
end
function zgatherFactoredLU(sender, receiver, nnodes, nodeList, LUvsb, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.zgatherFactoredLU(sender::int_t, receiver::int_t, nnodes::int_t, nodeList::Ptr{int_t}, LUvsb::Ptr{zLUValSubBuf_t{Int64}}, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function zgatherAllFactoredLU(trf3Dpartition, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.zgatherAllFactoredLU(trf3Dpartition::Ptr{ztrf3Dpartition_t{Int64}}, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function zinit3DLUstruct(myTreeIdxs, myZeroTrIdxs, nodeCount, nodeList, LUstruct, grid3d)
@ccall libsuperlu_dist_Int64.zinit3DLUstruct(myTreeIdxs::Ptr{int_t}, myZeroTrIdxs::Ptr{int_t}, nodeCount::Ptr{int_t}, nodeList::Ptr{Ptr{int_t}}, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}})::int_t
end
function zzSendLPanel(k, receiver, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.zzSendLPanel(k::int_t, receiver::int_t, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function zzRecvLPanel(k, sender, alpha, beta, Lval_buf, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.zzRecvLPanel(k::int_t, sender::int_t, alpha::doublecomplex, beta::doublecomplex, Lval_buf::Ptr{doublecomplex}, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function zzSendUPanel(k, receiver, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.zzSendUPanel(k::int_t, receiver::int_t, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function zzRecvUPanel(k, sender, alpha, beta, Uval_buf, LUstruct, grid3d, SCT)
@ccall libsuperlu_dist_Int64.zzRecvUPanel(k::int_t, sender::int_t, alpha::doublecomplex, beta::doublecomplex, Uval_buf::Ptr{doublecomplex}, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, SCT::Ptr{SCT_t})::int_t
end
function zIBcast_LPanel(k, k0, lsub, lusup, arg5, msgcnt, arg7, ToSendR, xsup, arg10)
@ccall libsuperlu_dist_Int64.zIBcast_LPanel(k::int_t, k0::int_t, lsub::Ptr{int_t}, lusup::Ptr{doublecomplex}, arg5::Ptr{gridinfo_t{Int64}}, msgcnt::Ptr{Cint}, arg7::Ptr{MPI_Request}, ToSendR::Ptr{Ptr{Cint}}, xsup::Ptr{int_t}, arg10::Cint)::int_t
end
function zBcast_LPanel(k, k0, lsub, lusup, arg5, msgcnt, ToSendR, xsup, arg9, arg10)
@ccall libsuperlu_dist_Int64.zBcast_LPanel(k::int_t, k0::int_t, lsub::Ptr{int_t}, lusup::Ptr{doublecomplex}, arg5::Ptr{gridinfo_t{Int64}}, msgcnt::Ptr{Cint}, ToSendR::Ptr{Ptr{Cint}}, xsup::Ptr{int_t}, arg9::Ptr{SCT_t}, arg10::Cint)::int_t
end
function zIBcast_UPanel(k, k0, usub, uval, arg5, msgcnt, arg7, ToSendD, arg9)
@ccall libsuperlu_dist_Int64.zIBcast_UPanel(k::int_t, k0::int_t, usub::Ptr{int_t}, uval::Ptr{doublecomplex}, arg5::Ptr{gridinfo_t{Int64}}, msgcnt::Ptr{Cint}, arg7::Ptr{MPI_Request}, ToSendD::Ptr{Cint}, arg9::Cint)::int_t
end
function zBcast_UPanel(k, k0, usub, uval, arg5, msgcnt, ToSendD, arg8, arg9)
@ccall libsuperlu_dist_Int64.zBcast_UPanel(k::int_t, k0::int_t, usub::Ptr{int_t}, uval::Ptr{doublecomplex}, arg5::Ptr{gridinfo_t{Int64}}, msgcnt::Ptr{Cint}, ToSendD::Ptr{Cint}, arg8::Ptr{SCT_t}, arg9::Cint)::int_t
end
function zIrecv_LPanel(k, k0, Lsub_buf, Lval_buf, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.zIrecv_LPanel(k::int_t, k0::int_t, Lsub_buf::Ptr{int_t}, Lval_buf::Ptr{doublecomplex}, arg5::Ptr{gridinfo_t{Int64}}, arg6::Ptr{MPI_Request}, arg7::Ptr{zLocalLU_t{Int64}}, arg8::Cint)::int_t
end
function zIrecv_UPanel(k, k0, Usub_buf, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.zIrecv_UPanel(k::int_t, k0::int_t, Usub_buf::Ptr{int_t}, arg4::Ptr{doublecomplex}, arg5::Ptr{zLocalLU_t{Int64}}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{MPI_Request}, arg8::Cint)::int_t
end
function zWait_URecv(arg1, msgcnt, arg3)
@ccall libsuperlu_dist_Int64.zWait_URecv(arg1::Ptr{MPI_Request}, msgcnt::Ptr{Cint}, arg3::Ptr{SCT_t})::int_t
end
function zWait_LRecv(arg1, msgcnt, msgcntsU, arg4, arg5)
@ccall libsuperlu_dist_Int64.zWait_LRecv(arg1::Ptr{MPI_Request}, msgcnt::Ptr{Cint}, msgcntsU::Ptr{Cint}, arg4::Ptr{gridinfo_t{Int64}}, arg5::Ptr{SCT_t})::int_t
end
function zISend_UDiagBlock(k0, ublk_ptr, size, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.zISend_UDiagBlock(k0::int_t, ublk_ptr::Ptr{doublecomplex}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int64}}, arg6::Cint)::int_t
end
function zRecv_UDiagBlock(k0, ublk_ptr, size, src, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.zRecv_UDiagBlock(k0::int_t, ublk_ptr::Ptr{doublecomplex}, size::int_t, src::int_t, arg5::Ptr{gridinfo_t{Int64}}, arg6::Ptr{SCT_t}, arg7::Cint)::int_t
end
function zPackLBlock(k, Dest, arg3, arg4, arg5)
@ccall libsuperlu_dist_Int64.zPackLBlock(k::int_t, Dest::Ptr{doublecomplex}, arg3::Ptr{Glu_persist_t}, arg4::Ptr{gridinfo_t{Int64}}, arg5::Ptr{zLocalLU_t{Int64}})::int_t
end
function zISend_LDiagBlock(k0, lblk_ptr, size, arg4, arg5, arg6)
@ccall libsuperlu_dist_Int64.zISend_LDiagBlock(k0::int_t, lblk_ptr::Ptr{doublecomplex}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int64}}, arg6::Cint)::int_t
end
function zIRecv_UDiagBlock(k0, ublk_ptr, size, src, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.zIRecv_UDiagBlock(k0::int_t, ublk_ptr::Ptr{doublecomplex}, size::int_t, src::int_t, arg5::Ptr{MPI_Request}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{SCT_t}, arg8::Cint)::int_t
end
function zIRecv_LDiagBlock(k0, L_blk_ptr, size, src, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.zIRecv_LDiagBlock(k0::int_t, L_blk_ptr::Ptr{doublecomplex}, size::int_t, src::int_t, arg5::Ptr{MPI_Request}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{SCT_t}, arg8::Cint)::int_t
end
function zUDiagBlockRecvWait(k, IrecvPlcd_D, factored_L, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.zUDiagBlockRecvWait(k::int_t, IrecvPlcd_D::Ptr{int_t}, factored_L::Ptr{int_t}, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int64}}, arg6::Ptr{zLUstruct_t{Int64}}, arg7::Ptr{SCT_t})::int_t
end
function zIBcast_UDiagBlock(k, ublk_ptr, size, arg4, arg5)
@ccall libsuperlu_dist_Int64.zIBcast_UDiagBlock(k::int_t, ublk_ptr::Ptr{doublecomplex}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int64}})::int_t
end
function zIBcast_LDiagBlock(k, lblk_ptr, size, arg4, arg5)
@ccall libsuperlu_dist_Int64.zIBcast_LDiagBlock(k::int_t, lblk_ptr::Ptr{doublecomplex}, size::int_t, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int64}})::int_t
end
function zDiagFactIBCast(k, k0, BlockUFactor, BlockLFactor, IrecvPlcd_D, arg6, arg7, arg8, arg9, arg10, arg11, thresh, LUstruct, arg14, info, arg16, tag_ub)
@ccall libsuperlu_dist_Int64.zDiagFactIBCast(k::int_t, k0::int_t, BlockUFactor::Ptr{doublecomplex}, BlockLFactor::Ptr{doublecomplex}, IrecvPlcd_D::Ptr{int_t}, arg6::Ptr{MPI_Request}, arg7::Ptr{MPI_Request}, arg8::Ptr{MPI_Request}, arg9::Ptr{MPI_Request}, arg10::Ptr{gridinfo_t{Int64}}, arg11::Ptr{superlu_dist_options_t}, thresh::Cdouble, LUstruct::Ptr{zLUstruct_t{Int64}}, arg14::Ptr{SuperLUStat_t{Int64}}, info::Ptr{Cint}, arg16::Ptr{SCT_t}, tag_ub::Cint)::int_t
end
function zUPanelTrSolve(k, BlockLFactor, bigV, ldt, arg5, arg6, arg7, arg8, arg9)
@ccall libsuperlu_dist_Int64.zUPanelTrSolve(k::int_t, BlockLFactor::Ptr{doublecomplex}, bigV::Ptr{doublecomplex}, ldt::int_t, arg5::Ptr{Ublock_info_t}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{zLUstruct_t{Int64}}, arg8::Ptr{SuperLUStat_t{Int64}}, arg9::Ptr{SCT_t})::int_t
end
function zLPanelUpdate(k, IrecvPlcd_D, factored_L, arg4, BlockUFactor, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.zLPanelUpdate(k::int_t, IrecvPlcd_D::Ptr{int_t}, factored_L::Ptr{int_t}, arg4::Ptr{MPI_Request}, BlockUFactor::Ptr{doublecomplex}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{zLUstruct_t{Int64}}, arg8::Ptr{SCT_t})::int_t
end
function zUPanelUpdate(k, factored_U, arg3, BlockLFactor, bigV, ldt, arg7, arg8, arg9, arg10, arg11)
@ccall libsuperlu_dist_Int64.zUPanelUpdate(k::int_t, factored_U::Ptr{int_t}, arg3::Ptr{MPI_Request}, BlockLFactor::Ptr{doublecomplex}, bigV::Ptr{doublecomplex}, ldt::int_t, arg7::Ptr{Ublock_info_t}, arg8::Ptr{gridinfo_t{Int64}}, arg9::Ptr{zLUstruct_t{Int64}}, arg10::Ptr{SuperLUStat_t{Int64}}, arg11::Ptr{SCT_t})::int_t
end
function zIBcastRecvLPanel(k, k0, msgcnt, arg4, arg5, Lsub_buf, Lval_buf, factored, arg9, arg10, arg11, tag_ub)
@ccall libsuperlu_dist_Int64.zIBcastRecvLPanel(k::int_t, k0::int_t, msgcnt::Ptr{Cint}, arg4::Ptr{MPI_Request}, arg5::Ptr{MPI_Request}, Lsub_buf::Ptr{int_t}, Lval_buf::Ptr{doublecomplex}, factored::Ptr{int_t}, arg9::Ptr{gridinfo_t{Int64}}, arg10::Ptr{zLUstruct_t{Int64}}, arg11::Ptr{SCT_t}, tag_ub::Cint)::int_t
end
function zIBcastRecvUPanel(k, k0, msgcnt, arg4, arg5, Usub_buf, Uval_buf, arg8, arg9, arg10, tag_ub)
@ccall libsuperlu_dist_Int64.zIBcastRecvUPanel(k::int_t, k0::int_t, msgcnt::Ptr{Cint}, arg4::Ptr{MPI_Request}, arg5::Ptr{MPI_Request}, Usub_buf::Ptr{int_t}, Uval_buf::Ptr{doublecomplex}, arg8::Ptr{gridinfo_t{Int64}}, arg9::Ptr{zLUstruct_t{Int64}}, arg10::Ptr{SCT_t}, tag_ub::Cint)::int_t
end
function zWaitL(k, msgcnt, msgcntU, arg4, arg5, arg6, arg7, arg8)
@ccall libsuperlu_dist_Int64.zWaitL(k::int_t, msgcnt::Ptr{Cint}, msgcntU::Ptr{Cint}, arg4::Ptr{MPI_Request}, arg5::Ptr{MPI_Request}, arg6::Ptr{gridinfo_t{Int64}}, arg7::Ptr{zLUstruct_t{Int64}}, arg8::Ptr{SCT_t})::int_t
end
function zWaitU(k, msgcnt, arg3, arg4, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.zWaitU(k::int_t, msgcnt::Ptr{Cint}, arg3::Ptr{MPI_Request}, arg4::Ptr{MPI_Request}, arg5::Ptr{gridinfo_t{Int64}}, arg6::Ptr{zLUstruct_t{Int64}}, arg7::Ptr{SCT_t})::int_t
end
function zLPanelTrSolve(k, factored_L, BlockUFactor, arg4, arg5)
@ccall libsuperlu_dist_Int64.zLPanelTrSolve(k::int_t, factored_L::Ptr{int_t}, BlockUFactor::Ptr{doublecomplex}, arg4::Ptr{gridinfo_t{Int64}}, arg5::Ptr{zLUstruct_t{Int64}})::int_t
end
function zSchurComplementSetup(k, msgcnt, arg3, arg4, arg5, arg6, arg7, arg8, arg9, bigU, Lsub_buf, Lval_buf, Usub_buf, Uval_buf, arg15, arg16)
@ccall libsuperlu_dist_Int64.zSchurComplementSetup(k::int_t, msgcnt::Ptr{Cint}, arg3::Ptr{Ublock_info_t}, arg4::Ptr{Remain_info_t}, arg5::Ptr{uPanelInfo_t{Int64}}, arg6::Ptr{lPanelInfo_t{Int64}}, arg7::Ptr{int_t}, arg8::Ptr{int_t}, arg9::Ptr{int_t}, bigU::Ptr{doublecomplex}, Lsub_buf::Ptr{int_t}, Lval_buf::Ptr{doublecomplex}, Usub_buf::Ptr{int_t}, Uval_buf::Ptr{doublecomplex}, arg15::Ptr{gridinfo_t{Int64}}, arg16::Ptr{zLUstruct_t{Int64}})::int_t
end
function zSchurComplementSetupGPU(k, msgs, arg3, arg4, arg5, arg6, arg7, arg8, arg9, LUvsb, arg11, arg12, arg13)
@ccall libsuperlu_dist_Int64.zSchurComplementSetupGPU(k::int_t, msgs::Ptr{msgs_t}, arg3::Ptr{packLUInfo_t{Int64}}, arg4::Ptr{int_t}, arg5::Ptr{int_t}, arg6::Ptr{int_t}, arg7::Ptr{gEtreeInfo_t{Int64}}, arg8::Ptr{factNodelists_t{Int64}}, arg9::Ptr{zscuBufs_t}, LUvsb::Ptr{zLUValSubBuf_t{Int64}}, arg11::Ptr{gridinfo_t{Int64}}, arg12::Ptr{zLUstruct_t{Int64}}, arg13::Ptr{HyP_t})::int_t
end
function zgetBigV(arg1, arg2)
@ccall libsuperlu_dist_Int64.zgetBigV(arg1::int_t, arg2::int_t)::Ptr{doublecomplex}
end
function zgetBigU(arg1, arg2, arg3, arg4)
@ccall libsuperlu_dist_Int64.zgetBigU(arg1::Ptr{superlu_dist_options_t}, arg2::int_t, arg3::Ptr{gridinfo_t{Int64}}, arg4::Ptr{zLUstruct_t{Int64}})::Ptr{doublecomplex}
end
function zLluBufInit(arg1, arg2)
@ccall libsuperlu_dist_Int64.zLluBufInit(arg1::Ptr{zLUValSubBuf_t{Int64}}, arg2::Ptr{zLUstruct_t{Int64}})::int_t
end
function zinitScuBufs(arg1, ldt, num_threads, nsupers, arg5, arg6, arg7)
@ccall libsuperlu_dist_Int64.zinitScuBufs(arg1::Ptr{superlu_dist_options_t}, ldt::int_t, num_threads::int_t, nsupers::int_t, arg5::Ptr{zscuBufs_t}, arg6::Ptr{zLUstruct_t{Int64}}, arg7::Ptr{gridinfo_t{Int64}})::int_t
end
function zfreeScuBufs(scuBufs)
@ccall libsuperlu_dist_Int64.zfreeScuBufs(scuBufs::Ptr{zscuBufs_t})::Cint
end
function zsparseTreeFactor(nnodes, perm_c_supno, treeTopoInfo, comReqs, scuBufs, packLUInfo, msgs, LUvsb, dFBuf, factStat, fNlists, options, gIperm_c_supno, ldt, LUstruct, grid3d, stat, thresh, SCT, info)
@ccall libsuperlu_dist_Int64.zsparseTreeFactor(nnodes::int_t, perm_c_supno::Ptr{int_t}, treeTopoInfo::Ptr{treeTopoInfo_t{Int64}}, comReqs::Ptr{commRequests_t}, scuBufs::Ptr{zscuBufs_t}, packLUInfo::Ptr{packLUInfo_t{Int64}}, msgs::Ptr{msgs_t}, LUvsb::Ptr{zLUValSubBuf_t{Int64}}, dFBuf::Ptr{zdiagFactBufs_t}, factStat::Ptr{factStat_t{Int64}}, fNlists::Ptr{factNodelists_t{Int64}}, options::Ptr{superlu_dist_options_t}, gIperm_c_supno::Ptr{int_t}, ldt::int_t, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, stat::Ptr{SuperLUStat_t{Int64}}, thresh::Cdouble, SCT::Ptr{SCT_t}, info::Ptr{Cint})::int_t
end
function zdenseTreeFactor(nnnodes, perm_c_supno, comReqs, scuBufs, packLUInfo, msgs, LUvsb, dFBuf, factStat, fNlists, options, gIperm_c_supno, ldt, LUstruct, grid3d, stat, thresh, SCT, tag_ub, info)
@ccall libsuperlu_dist_Int64.zdenseTreeFactor(nnnodes::int_t, perm_c_supno::Ptr{int_t}, comReqs::Ptr{commRequests_t}, scuBufs::Ptr{zscuBufs_t}, packLUInfo::Ptr{packLUInfo_t{Int64}}, msgs::Ptr{msgs_t}, LUvsb::Ptr{zLUValSubBuf_t{Int64}}, dFBuf::Ptr{zdiagFactBufs_t}, factStat::Ptr{factStat_t{Int64}}, fNlists::Ptr{factNodelists_t{Int64}}, options::Ptr{superlu_dist_options_t}, gIperm_c_supno::Ptr{int_t}, ldt::int_t, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, stat::Ptr{SuperLUStat_t{Int64}}, thresh::Cdouble, SCT::Ptr{SCT_t}, tag_ub::Cint, info::Ptr{Cint})::int_t
end
function zsparseTreeFactor_ASYNC(sforest, comReqss, scuBufs, packLUInfo, msgss, LUvsbs, dFBufs, factStat, fNlists, gEtreeInfo, options, gIperm_c_supno, ldt, HyP, LUstruct, grid3d, stat, thresh, SCT, tag_ub, info)
@ccall libsuperlu_dist_Int64.zsparseTreeFactor_ASYNC(sforest::Ptr{sForest_t{Int64}}, comReqss::Ptr{Ptr{commRequests_t}}, scuBufs::Ptr{zscuBufs_t}, packLUInfo::Ptr{packLUInfo_t{Int64}}, msgss::Ptr{Ptr{msgs_t}}, LUvsbs::Ptr{Ptr{zLUValSubBuf_t{Int64}}}, dFBufs::Ptr{Ptr{zdiagFactBufs_t}}, factStat::Ptr{factStat_t{Int64}}, fNlists::Ptr{factNodelists_t{Int64}}, gEtreeInfo::Ptr{gEtreeInfo_t{Int64}}, options::Ptr{superlu_dist_options_t}, gIperm_c_supno::Ptr{int_t}, ldt::int_t, HyP::Ptr{HyP_t}, LUstruct::Ptr{zLUstruct_t{Int64}}, grid3d::Ptr{gridinfo3d_t{Int64}}, stat::Ptr{SuperLUStat_t{Int64}}, thresh::Cdouble, SCT::Ptr{SCT_t}, tag_ub::Cint, info::Ptr{Cint})::int_t
end
function zLluBufInitArr(numLA, LUstruct)
@ccall libsuperlu_dist_Int64.zLluBufInitArr(numLA::int_t, LUstruct::Ptr{zLUstruct_t{Int64}})::Ptr{Ptr{zLUValSubBuf_t{Int64}}}
end
function zLluBufFreeArr(numLA, LUvsbs)
@ccall libsuperlu_dist_Int64.zLluBufFreeArr(numLA::int_t, LUvsbs::Ptr{Ptr{zLUValSubBuf_t{Int64}}})::Cint
end
function zinitDiagFactBufsArr(mxLeafNode, ldt, grid)
@ccall libsuperlu_dist_Int64.zinitDiagFactBufsArr(mxLeafNode::int_t, ldt::int_t, grid::Ptr{gridinfo_t{Int64}})::Ptr{Ptr{zdiagFactBufs_t}}
end
function zfreeDiagFactBufsArr(mxLeafNode, dFBufs)
@ccall libsuperlu_dist_Int64.zfreeDiagFactBufsArr(mxLeafNode::int_t, dFBufs::Ptr{Ptr{zdiagFactBufs_t}})::Cint
end
function zinitDiagFactBufs(ldt, dFBuf)
@ccall libsuperlu_dist_Int64.zinitDiagFactBufs(ldt::int_t, dFBuf::Ptr{zdiagFactBufs_t})::int_t
end
const TRUE = 1
const HAVE_PARMETIS = TRUE
const XSDK_INDEX_SIZE = 64
const _LONGINT = 1
const EMPTY = -1
const FALSE = 0
const MAX_3D_LEVEL = 32
const CBLOCK = 192
const CACHE_LINE_SIZE = 8
const CSTEPPING = 8
const NO_MARKER = 3
const tag_interLvl = 2
const tag_interLvl_LData = 0
const tag_interLvl_UData = 1
const tag_intraLvl_szMsg = 1000
const tag_intraLvl_LData = 1001
const tag_intraLvl_UData = 1002
const tag_intraLvl = 1003
const DIAG_IND = 0
const NELTS_IND = 1
const RCVD_IND = 2
const SUCCES_RET = 0
const ERROR_RET = 1
const FILLED_SEP = 2
const FILLED_SEPS = 3
const USUB_PR = 0
const LSUB_PR = 1
const RL_SYMB = 0
const DOMAIN_SYMB = 1
const LL_SYMB = 2
const DNS_UPSEPS = 3
const DNS_CURSEP = 4
const MAX_LOOKAHEADS = 50
const SUPERLU_DIST_MAJOR_VERSION = 8
const SUPERLU_DIST_MINOR_VERSION = 1
const SUPERLU_DIST_PATCH_VERSION = 2
const SUPERLU_DIST_RELEASE_DATE = "November 12, 2022"
const MAX_SUPER_SIZE = 512
const BC_HEADER = 2
const LB_DESCRIPTOR = 2
const BR_HEADER = 3
const UB_DESCRIPTOR = 2
const BC_HEADER_NEWU = 3
const UB_DESCRIPTOR_NEWU = 2
const NBUFFERS = 5
const UjROW = 10
const UkSUB = 11
const UkVAL = 12
const LkSUB = 13
const LkVAL = 14
const LkkDIAG = 15
const GSUM = 20
const Xk = 21
const Yk = 22
const LSUM = 23
const COMM_ALL = 100
const COMM_COLUMN = 101
const COMM_ROW = 102
const SUPER_LINEAR = 11
const SUPER_BLOCK = 12
const DIM_X = 16
const DIM_Y = 16
const BLK_M = DIM_X * 4
const BLK_N = DIM_Y * 4
const BLK_K = 2048 ÷ BLK_M
const DIM_XA = DIM_X
const DIM_YA = DIM_Y
const DIM_XB = DIM_X
const DIM_YB = DIM_Y
const NWARP = (DIM_X * DIM_Y) ÷ 32
const THR_M = BLK_M ÷ DIM_X
const THR_N = BLK_N ÷ DIM_Y
const DEG_TREE = 2
end
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 2542 | module SuperLUDIST
using SparseBase
using MPI
include("libs.jl")
using CIndices: CIndex
using DocStringExtensions
using MatrixMarket
using SuperLUBase
using SuperLUBase.Common
using OpenBLAS32_jll # FIX after support for user binary.
using LinearAlgebra
function __init__()
if VERSION ≥ v"1.9"
config = LinearAlgebra.BLAS.lbt_get_config()
if !any(lib -> lib.interface == :lp64, config.loaded_libs)
LinearAlgebra.BLAS.lbt_forward(OpenBLAS32_jll.libopenblas_path)
end
end
# LinearAlgebra.BLAS.set_num_threads(1)
#superlu_set_num_threads(Int32, 1)
#superlu_set_num_threads(Int64, 1)
end
include("../lib/common.jl")
include("../lib/libsuperlu_dist32.jl")
include("../lib/libsuperlu_dist64.jl")
using .SuperLUDIST_Common
using .SuperLU_Int32
using .SuperLU_Int64
import Base: (\), size, getproperty, setproperty!, propertynames, show
using SparseBase: AbstractSparseStore, indexeltype, storedeltype
using SparseBase.Communication
const nstored = SparseBase.nstored
export ReplicatedSuperMatrix, DistributedSuperMatrix,
nstored
function prefixsymbol(::Type{T}) where T
T === Float32 && (return :s)
T === Float64 && (return :d)
T === ComplexF32 && (return :c)
T === ComplexF64 && (return :z)
end
function prefixname(::Type{T}, name::Symbol) where T
Symbol(prefixsymbol(T), name)
Symbol(prefixsymbol(T), name)
Symbol(prefixsymbol(T), name)
Symbol(prefixsymbol(T), name)
end
function toslutype(::Type{T}) where T
T === Float32 && (return Common.SLU_S)
T === Float64 && (return Common.SLU_D)
T === ComplexF32 && (return Common.SLU_C)
T === ComplexF64 && (return Common.SLU_Z)
end
abstract type AbstractSuperMatrix{Tv, Ti, S} <: AbstractMatrix{Tv} end
function Base.getproperty(S::AbstractSuperMatrix, s::Symbol)
s === :supermatrix && return Base.getfield(S, s)
s === :store && return Base.getfield(S, s)
s === :format && return Base.getfield(S, s)
s === :globalsize && return Base.getfield(S, s)
s === :first_row && return Base.getfield(S, s)
s === :grid && return Base.getfield(S, s)
return getproperty(S.supermatrix[], s)
end
# TODO: move to SuperLUBase.jl
Base.unsafe_convert(
T::Type{Ptr{SuperMatrix{I}}},
A::AbstractSuperMatrix{<:Any, I}
) where {I <: Union{Int32, Int64}} =
Base.unsafe_convert(T, A.supermatrix)
include("lowlevel.jl")
include("structs.jl")
include("distributedmatrix.jl")
include("replicatedmatrix.jl")
include("drivers.jl")
include("matrixmarket.jl")
include("highlevel.jl")
end
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 6353 | """
$(TYPEDEF)
SuperMatrix distributed by row between all ranks in a communicator.
The Julia representation may be accessed by `A.store::SparseBase.CSRStore{T, CIndex{<:Int}}`.
Each local matrix stores a subset of rows specified by `A.globalrows`
# Extended
$(FIELDS)
"""
mutable struct DistributedSuperMatrix{T, I, S, F, J, G} <: AbstractSuperMatrix{T, I, S}
"""Internal: Reference to `Common.SuperMatrix{I}`"""
supermatrix::Base.RefValue{S} # the supermatrix
"""Internal: Reference to storage format `Common.NRFormat_loc{I}` held by supermatrix"""
format::Base.RefValue{F} # the internal storage
"""Julia-side storage, of type `SparseBase.CSRStore. Keeps memory alive.`"""
store::J #keepalive for format
globalsize::NTuple{2, I}
first_row::I
grid::G
end
Base.size(A::DistributedSuperMatrix) = A.globalsize
Communication.localpart(A::DistributedSuperMatrix) = A.store
# TODO propagate fields to C structs.
"""
DistributedSuperMatrix{Tv, Ti}()
Construct an empty DistributedSuperMatrix to be filled later.
Note: Currently, modifying Julia-level fields will not propagate to the C structs.
For instance in order to update the size you must update the size of
`A::DistributedSuperMatrix.store` as well as the sizes stored in `A.format` and
`A.supermatrix`.
"""
function DistributedSuperMatrix{Tv, Ti}(grid::Grid{Ti}) where {Tv, Ti}
store = SparseBase.CSRStore{Tv, CIndex{Ti}}()
firstrow, globalsize = 1, (0, 0)
DistributedSuperMatrix(store, firstrow, globalsize, grid)
end
"""
$(TYPEDSIGNATURES)
Construct a DistributedSuperMatrix from a finished `SparseBase.CSRStore`.
# Arguments
- `A` : sparse storage in CSR form, valid index types are `{Int32, Int64}`, valid
element types are `{Float32, Float64, ComplexF64}`.
- `firstrow` : the 1-based starting row of A on this rank.
- `globalsize` : the size of `A` across all ranks.
"""
function DistributedSuperMatrix(
A::SparseBase.CSRStore{<:Any, CIndex{Ti}}, firstrow, globalsize, grid::Grid{Ti}
) where {Ti}
fmtref = Ref(Common.NRformat_loc{Ti}(
nstored(A),
A.vdim,
firstrow - 1, # start of row range.
Ptr{Cvoid}(pointer(A.v)),
Base.unsafe_convert(Ptr{Ti}, A.ptr),
Base.unsafe_convert(Ptr{Ti}, A.idx)
))
superref = Ref(Common.SuperMatrix{Ti}(
Common.SLU_NR_loc,
toslutype(storedeltype(A)),
Common.SLU_GE,
Ti.(globalsize)..., # global size.
Base.unsafe_convert(Ptr{Cvoid}, fmtref)
))
return DistributedSuperMatrix{
storedeltype(A), Ti, eltype(superref), eltype(fmtref), typeof(A), typeof(grid)
}(superref, fmtref, A, Ti.(globalsize), firstrow, grid)
end
function DistributedSuperMatrix(store::SparseBase.AbstractSparseStore{Tv, <:Any, CIndex{Ti}}, firstrow, globalsize, grid::Grid{Ti}) where
{Tv, Ti}
return DistributedSuperMatrix(convert(SparseBase.CSRStore, store), firstrow, globalsize, grid)
end
function DistributedSuperMatrix(store::SparseBase.AbstractSparseStore{Tv, <:Any, Ti}, firstrow, globalsize, grid::Grid{Ti}) where
{Tv, Ti}
return DistributedSuperMatrix(convert(SparseBase.CSRStore{Tv, CIndex{Ti}}, store), firstrow, globalsize, grid)
end
"""
$(TYPEDSIGNATURES)
Construct a DistributedSuperMatrix from the vectors of a CSR matrix, and the necessary metadata.
Valid index types are `{Int32, Int64}`, or `CIndex{Int32}, CIndex{Int64}`, if the indices are already 0-based.
Valid element types are `{Float32, Float64, ComplexF64}`.
# Arguments
- `rowptr, colidx, v` : sparse storage vectors, must be valid CSR matrix internals with types noted above.
- `firstrow` : the 1-based starting row of the matrix on this rank.
- `localsize` : the local size of the matrix on this rank.
- `globalsize` : the size of the matrix across all ranks.
- `grid` : the grid on which the matrix is distributed.
"""
function DistributedSuperMatrix(rowptr, colidx, v, firstrow, localsize, globalsize, grid::Grid{Ti}) where {Ti}
return DistributedSuperMatrix(
SparseBase.CSRStore(rowptr, colidx, v, localsize),
firstrow,
globalsize,
grid
)
end
"""
$(TYPEDSIGNATURES)
Construct a DistributedSuperMatrix from COO format and the necessary metadata.
Valid index types are `{Int32, Int64}`, or `CIndex{Int32}, CIndex{Int64}`, if the indices are already 0-based.
Valid element types are `{Float32, Float64, ComplexF64}`.
# Arguments
- `(rows, cols), v` : sparse storage vectors, must be valid COO matrix internals with types noted above.
- `firstrow` : the 1-based starting row of the matrix on this rank.
- `localsize` : the local size of the matrix on this rank.
- `globalsize` : the size of the matrix across all ranks.
- `grid` : the grid on which the matrix is distributed.
"""
function DistributedSuperMatrix((rows, cols)::NTuple{2, <:AbstractVector}, v, firstrow, localsize, globalsize, grid::Grid{Ti}) where {Ti}
return DistributedSuperMatrix(
SparseBase.CSRStore(ptr, idx, v, localsize),
firstrow,
globalsize,
grid
)
end
"""
$(TYPEDSIGNATURES)
"""
function Communication.scatterstore!(
rstore::DistributedSuperMatrix{Tv, Ti},
sstore::Union{Nothing, SparseBase.CSRStore},
chunksizes; # dimchunks is an iterable of the number of rows / cols (CSR / CSC)
# in each rank.
root::Integer = 0,
comm::MPI.Comm = MPI.COMM_WORLD
) where {Tv, Ti}
# TODO: some of this should happen automatically.
# scatterstore! is semantically a resize and overwrite, so changing ptrs
# shouldn't be necessary.
A, globalrows, firstrow =
Communication.scatterstore!(rstore.store, sstore, chunksizes; root, comm)
rstore.store = A
rstore.globalsize = (globalrows, size(A, 2))
rstore.first_row = firstrow
rstore.format = Ref(Common.NRformat_loc{Ti}(
SparseBase.nstored(A),
A.vdim,
firstrow - 1, # start of row range.
Ptr{Cvoid}(pointer(A.v)),
Base.unsafe_convert(Ptr{Ti}, A.ptr),
Base.unsafe_convert(Ptr{Ti}, A.idx)
))
rstore.supermatrix = Ref(Common.SuperMatrix{Ti}(
Common.SLU_NR_loc,
toslutype(storedeltype(A)),
Common.SLU_GE,
globalrows, A.vlen, # global size.
Base.unsafe_convert(Ptr{Cvoid}, rstore.format)
))
return rstore
end
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 4970 | """
$(TYPEDSIGNATURES)
Solve the replicated sparse linear system `Ax = b`, overwriting `b`
with the solution.
Returns `b` and the factor object which may be used
to solve with different `b` or reuse parts of the factorization different
values values for A.
"""
function pgssvx!(
A::ReplicatedSuperMatrix{Tv, Ti},
b::VecOrMat{Tv};
options = Options(),
perm = ScalePerm{Tv, Ti}(size(A)...),
LU = LUFactors{Tv, Ti}(size(A, 2), A.grid),
stat = LUStat{Ti}(),
berr = Vector{Tv}(undef, size(b, 2))
) where {Tv, Ti}
return pgssvx!(SuperLUFactorization(A, options, nothing, perm, LU, stat, berr, b), b)
end
function pgssvx!(
A::ReplicatedSuperMatrix{Tv, Ti};
options = Options(),
perm = ScalePerm{Tv, Ti}(size(A)...),
LU = LUFactors{Tv, Ti}(size(A, 2), A.grid),
stat = LUStat{Ti}()
) where {Tv, Ti}
return pgssvx!(SuperLUFactorization(A, options, nothing, perm, LU, stat, berr, b), b)
end
"""
$(TYPEDSIGNATURES)
Solve the distributed sparse linear system `Ax = b`, overwriting `b`
with the solution.
Returns `b` and the factor object which may be used
to solve with different `b` or reuse parts of the factorization different
values values for A.
"""
function pgssvx!(
A::DistributedSuperMatrix{Tv, Ti},
b::VecOrMat{Tv};
options = Options(),
Solve = SolveData{Tv, Ti}(options),
perm = ScalePerm{Tv, Ti}(size(A)...),
LU = LUFactors{Tv, Ti}(size(A, 2), A.grid),
stat = LUStat{Ti}(),
berr = Vector{Tv}(undef, size(b, 2))
) where {Tv, Ti}
return pgssvx!(SuperLUFactorization(A, options, Solve, perm, LU, stat, berr, b), b)
end
function pgssvx!(
A::DistributedSuperMatrix{Tv, Ti};
options = Options(),
Solve = SolveData{Tv, Ti}(options),
perm = ScalePerm{Tv, Ti}(size(A)...),
LU = LUFactors{Tv, Ti}(size(A, 2), A.grid),
stat = LUStat{Ti}(),
) where {Tv, Ti}
b = Matrix{Tv}(undef, SparseBase.Communication.localsize(A, 1), 0)
pgssvx!(A, b; options, Solve, perm, LU, stat)
end
function pgssvx!(F::SuperLUFactorization{T, I, <:ReplicatedSuperMatrix{T, I}}, b::VecOrMat{T}) where {T, I}
(; mat, options, perm, factors, stat, berr) = F
b, _ = pgssvx_ABglobal!(options, mat, perm, b, factors, berr, stat)
F.options.Fact = Common.FACTORED
F.b = b
return b, F
end
function pgssvx!(F::SuperLUFactorization{T, I, <:DistributedSuperMatrix{T, I}}, b::VecOrMat{T}) where {T, I}
(; mat, options, solve, perm, factors, stat, berr) = F
currentnrhs = size(F.b, 2)
if currentnrhs != size(b, 2)
F = pgstrs_prep!(F)
pgstrs_init!(
F.solve,
reverse(Communication.localsize(F.mat))...,
size(b, 2), F.mat.first_row - 1, F.perm,
F.factors, F.mat.grid
)
end
b, _ = pgssvx_ABdist!(options, mat, perm, b, factors, solve, berr, stat)
F.options.Fact = Common.FACTORED
F.b = b
return b, F
end
for T ∈ (Float32, Float64, ComplexF64)
for I ∈ (Int32, Int64)
L = Symbol(:SuperLU_, Symbol(I))
@eval begin
function pgssvx_ABglobal!(
options,
A::ReplicatedSuperMatrix{$T, $I},
perm::ScalePerm{$T, $I},
b::Array{$T},
LU::LUFactors{$T, $I},
berr, stat::LUStat{$I}
)
info = Ref{Int32}()
$L.$(Symbol(:p, prefixsymbol(T), :gssvx_ABglobal))(
options, A, perm, b, size(b, 1), size(b, 2),
A.grid, LU, berr, stat, info
)
# TODO: error handle
info[] == 0 || throw(ArgumentError("Something wrong :)"))
return b, perm, LU, stat
end
function pgssvx_ABdist!(
options,
A::DistributedSuperMatrix{$T, $I},
perm::ScalePerm{$T, $I},
b::Array{$T},
LU::LUFactors{$T, $I},
Solve::SolveData{$T, $I},
berr, stat::LUStat{$I}
)
info = Ref{Int32}()
$L.$(Symbol(:p, prefixsymbol(T), :gssvx))(
options, A, perm, b, size(b, 1), size(b, 2),
A.grid, LU, Solve, berr, stat, info
)
info[] == 0 ||
error("Error INFO = $(info[]) from pgssvx")
return b, perm, LU, stat
end
function inf_norm_error_dist(x::Array{$T}, xtrue::Array{$T}, grid::Grid{$I})
$L.$(prefixname(T, :inf_norm_error_dist))(
$I(size(x, 1)), $I(size(x, 2)),
x, $I(size(x, 1)),
xtrue, $I(size(xtrue, 1)),
grid
)
end
function pgstrs_init!(
solve::SolveData{$T, $I},
n, m_local, nrhs, first_row,
scaleperm::ScalePerm{$T, $I},
lu::LUFactors{$T, $I},
grid::Grid{$I}
)
$L.$(Symbol(:p, prefixsymbol(T), :gstrs_init))(
n, m_local, nrhs, first_row, scaleperm.perm_r,
scaleperm.perm_c, grid, lu.Glu_persist, solve
)
return solve
end
function pgstrs_prep!(
F::SuperLUFactorization{$T, $I}
)
if size(F.b, 2) != 0
gstrs = unsafe_load(F.solve.gstrs_comm)
$L.superlu_free_dist(gstrs.B_to_X_SendCnt)
$L.superlu_free_dist(gstrs.X_to_B_SendCnt)
$L.superlu_free_dist(gstrs.ptr_to_ibuf)
else # there has been no gstrs_comm malloc'd, so do that.
end
return F
end
end
end
end
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 356 | function LinearAlgebra.lu!(
A::AbstractSuperMatrix{Tv, Ti},
b_local = ones(Tv, Communication.localsize(A, 2), 1);
kwargs...
) where {Tv, Ti}
return pgssvx!(A, b_local; kwargs...)[2] # F, drop b_local.
end
function LinearAlgebra.ldiv!(A::SuperLUFactorization{Tv, Ti}, B::StridedVecOrMat{Tv}) where {Tv, Ti}
return pgssvx!(A, B)[1]
end
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 1775 | using Libdl: dlopen, dlclose, dlpath, dlsym, RTLD_DEEPBIND, RTLD_LAZY
using Preferences
const _PREFERENCE_SLUINT32 = @load_preference("libsuperlu_dist_Int32", nothing)
const _PREFERENCE_SLUINT64 = @load_preference("libsuperlu_dist_Int64", nothing)
flags = RTLD_DEEPBIND | RTLD_LAZY
if _PREFERENCE_SLUINT32 === nothing && _PREFERENCE_SLUINT64 === nothing
using SuperLU_DIST_jll
elseif _PREFERENCE_SLUINT64 === nothing
libsuperlu_dist_Int32 = _PREFERENCE_SLUINT32
dlopen(libsuperlu_dist_Int32, flags; throw_error=true)
libsuperlu_dist_Int64 = nothing
elseif _PREFERENCE_SLUINT32 === nothing
libsuperlu_dist_Int64 = _PREFERENCE_SLUINT64
dlopen(libsuperlu_dist_Int64, flags; throw_error=true)
libsuperlu_dist_Int32 = nothing
else
libsuperlu_dist_Int64 = _PREFERENCE_SLUINT64
dlopen(libsuperlu_dist_Int64, flags; throw_error=true)
libsuperlu_dist_Int32 = _PREFERENCE_SLUINT32
dlopen(libsuperlu_dist_Int32, flags; throw_error=true)
end
function set_libraries!(;libsuperlu_dist_Int32 = nothing, libsuperlu_dist_Int64 = nothing)
if isnothing(libsuperlu_dist_Int32)
@delete_preferences!("libsuperlu_dist_Int32")
else
isfile(libsuperlu_dist_Int32) || throw(ArgumentError("$libsuperlu_dist_Int32 is not a file that exists."))
@set_preferences!("libsuperlu_dist_Int32" => libsuperlu_dist_Int32)
end
if isnothing(libsuperlu_dist_Int64)
@delete_preferences!("libsuperlu_dist_Int64")
else
isfile(libsuperlu_dist_Int64) || throw(ArgumentError("$libsuperlu_dist_Int64 is not a file that exists."))
@set_preferences!("libsuperlu_dist_Int64" => libsuperlu_dist_Int64)
end
@info "Please restart Julia and reload SuperLUDIST.jl for the library changes to take effect."
end
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 3575 | for T ∈ (Float32, Float64, ComplexF64)
for I ∈ (:Int32, :Int64)
L = Symbol(String(:SuperLU_) * String(I))
@eval begin
function _create_csrlocal_matrix(
a::Base.RefValue{$L.SuperMatrix}, m, n, nnz_local, m_local, first_row,
nzval::AbstractVector{$T},
colindices::AbstractVector{CIndex{$I}},
rowptrs::AbstractVector{CIndex{$I}},
mtype = Common.SLU_GE
)
$L.$(prefixname(T, :Create_CompRowLoc_Matrix_dist))(
a, m, n, nnz_local, m_local, first_row,
nzval, colindices, rowptrs, Common.SLU_NR_loc,
toslutype($T), mtype
)
return a
end
function _create_cscglobal_matrix(
a::Base.RefValue{SuperMatrix{$I}}, m, n, nnz,
nzval::AbstractVector{$T},
rowindices::AbstractVector{$I},
colptrs::AbstractVector{$I},
mtype = Common.SLU_GE
)
$L.$(prefixname(T, :Create_CompCol_Matrix_dist))(
a, m, n, nnz, nzval, rowindices, colptrs,
Common.SLU_NC, toslutype($T), mtype
)
return a
end
function readhb_dist(iam, fpp, m, n, nnz, aref::Base.RefValue{Ptr{$T}}, asubref::Base.RefValue{Ptr{$I}}, xaref::Base.RefValue{Ptr{$I}})
$L.$(prefixname(T, :readhb_dist))(
iam, fpp, m, n, nnz, aref, asubref, xaref
)
end
function readtriple_dist(iam, fpp, m, n, nnz, aref::Base.RefValue{Ptr{$T}}, asubref::Base.RefValue{Ptr{$I}}, xaref::Base.RefValue{Ptr{$I}})
$L.$(prefixname(T, :readtriple_dist))(
iam, fpp, m, n, nnz, aref, asubref, xaref
)
end
function allocateA_dist(n, nnz, aref::Base.RefValue{Ptr{$T}}, asubref::Base.RefValue{Ptr{$I}}, xaref::Base.RefValue{Ptr{$I}})
$L.$(prefixname(T, :allocateA_dist))(n, nnz, aref, asubref, xaref)
end
function GenXtrue_dist!(xtrue::Array{$T}, n::$I, nrhs::$I, ldx = n)
$L.$(prefixname(T, :GenXtrue_dist))(n, nrhs, xtrue, ldx)
end
function FillRHS_dist!(b, A::AbstractSuperMatrix{$T, $I}, xtrue::Array{$T}, trans, nrhs, ldx, ldb)
trans = trans ? Ref{Cchar}('T') : Ref{Cchar}('N')
$L.$(prefixname(T, :FillRHS_dist))(trans, nrhs, xtrue, ldx, A, b, ldb)
end
function ScalePermstructFree(r::Base.RefValue{$(prefixname(T, :ScalePermstruct_t)){$I}})
$L.$(prefixname(T, :ScalePermstructFree))(r)
end
function ScalePermstructInit(r::Base.RefValue{$(prefixname(T, :ScalePermstruct_t)){$I}}, m, n)
$L.$(prefixname(T, :ScalePermstructInit))(m, n, r)
return finalizer(r) do x
!MPI.Finalized() && ScalePermstructFree(x)
end
end
function LUstructFree(r::$(prefixname(T, :LUstruct_t)){$I})
$L.$(prefixname(T, :LUstructFree))(r)
end
function Destroy_LU(r::$(prefixname(T, :LUstruct_t)){$I}, n, grid)
$L.$(prefixname(T, :Destroy_LU))(n, grid, r) # why do I have to grid.grid here?!
end
function LUstructInit(r::$(prefixname(T, :LUstruct_t)){$I}, n, grid)
$L.$(prefixname(T, :LUstructInit))(n, r)
return finalizer(r) do x
!MPI.Finalized() && Destroy_LU(x, n, grid)
!MPI.Finalized() && LUstructFree(x)
end
end
end
end
end
function GenXtrue_dist!(xtrue, ::Type{Ti} = Int) where Ti
GenXtrue_dist!(xtrue, Ti(size(xtrue, 1)), Ti(size(xtrue, 2)))
return xtrue
end
function FillRHS_dist!(b::Array, A::AbstractSuperMatrix, xtrue::Array;
trans = false, nrhs = size(xtrue, 2), ldx = size(xtrue, 1), ldb = size(b, 1))
FillRHS_dist!(b, A, xtrue, trans, nrhs, ldx, ldb)
return b
end
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 4072 |
using SparseBase: CoordinateStore
"""
mmread(ReplicatedSuperMatrix{Tv, Ti}, filename::String)
Read an `mtx` file into a compressed sparse column format and
broadcast it to all ranks in `comm`.
To read an `mtx` file locally use `mmread(SparseBase.CSCStore...)`.
# Arguments
- `arg1<:Type{ReplicatedSuperMatrix{Tv, Ti}}`
- `Tv <: Union{Float32, Float64, ComplexF64}`: Non-optional eltype.
- `Ti <: Union{Int32, Int64}`: Non-optional index type.
- `filename::String`: `.mtx` file accessible by the `root` process.
# Keyword Arguments
- `desymmetrize::Bool = true`: If the matrix file is represented
in symmetric form, represent in the full form.
- `root::Int = 0`: The MPI process on which to read the file.
- `comm::MPI.Comm = MPI.COMM_WORLD`: The MPI communicator on which to distribute
the matrix.
# Example
```julia
using MPI, SuperLUDIST, MatrixMarket
A = MatrixMarket.mmread(ReplicatedSuperMatrix{Float64, Int32}, )
```
"""
function MatrixMarket.mmread(
::Type{<:ReplicatedSuperMatrix{Tv, Ti}}, filename, grid::Grid{Ti};
desymmetrize = true, root = 0
) where {Tv <: Union{Float32, Float64, ComplexF64}, Ti <: Union{Int32, Int64}}
comm = grid.comm
rank = MPI.Comm_rank(comm)
if rank == root
x = convert(SparseBase.CSCStore, mmread(CoordinateStore{Tv, CIndex{Ti}}, filename; desymmetrize))
else
x = SparseBase.CSCStore(CIndex{Ti}[], CIndex{Ti}[], Tv[], (0, 0))
end
Communication.bcaststore!(x, root, comm)
ReplicatedSuperMatrix(x, grid)
end
"""
mmread(DistributedSuperMatrix{Tv, Ti}, filename::String, partitioner = distribute_evenly)
Read an `mtx` file into a compressed sparse column format and
broadcast it to all ranks in `comm`.
To read an `mtx` file locally use `mmread(SparseBase.CSCStore...)`.
# Arguments
- `arg1<:Type{ReplicatedSuperMatrix{Tv, Ti}}`
- `Tv <: Union{Float32, Float64, ComplexF64}`: Non-optional eltype.
- `Ti <: Union{Int32, Int64}`: Non-optional index type.
- `filename::String`: `.mtx` file accessible by the `root` process.
# Keyword Arguments
- `desymmetrize::Bool = true`: If the matrix file is represented
in symmetric form, represent in the full form.
- `root::Int = 0`: The MPI process on which to read the file.
- `comm::MPI.Comm = MPI.COMM_WORLD`: The MPI communicator on which to distribute
the matrix.
# Example
```julia
using MPI, SuperLUDIST, MatrixMarket
A = MatrixMarket.mmread(ReplicatedSuperMatrix{Float64, Int32}, )
```
"""
function MatrixMarket.mmread(
::Type{<:DistributedSuperMatrix{Tv, Ti}}, filename, grid::Grid{Ti};
desymmetrize = true, root = 0, partitioner = Communication.distribute_evenly
) where {Tv <: Union{Float32, Float64, ComplexF64}, Ti <: Union{Int32, Int64}}
comm = grid.comm
rank = MPI.Comm_rank(comm)
if rank == root
x = convert(SparseBase.CSRStore, mmread(CoordinateStore{Tv, CIndex{Ti}}, filename; desymmetrize))
else
x = nothing
end
out = SparseBase.CSRStore(CIndex{Ti}[], CIndex{Ti}[], Tv[], (0, 0))
part = Communication.ContinuousPartitioning(partitioner(nrows, MPI.Comm_size(comm)), ncols)
rowsizes = Communication.partition_sizes(part)[1]
out, globalnrows, startingrow = Communication.scatterstore!(out, x, rowsizes; root, comm)
out = DistributedSuperMatrix(out, startingrow, (globalnrows, size(out, 2)), grid)
end
function mmread_and_generatesolution(Tv, Ti, nrhs, path, grid; root = 0)
comm = grid.comm
iam = grid.iam
if iam == root
coo = MatrixMarket.mmread(SparseBase.CoordinateStore{Tv, CIndex{Ti}},
path)
csc = convert(SparseBase.CSCStore, coo)
else
csc = SparseBase.CSCStore{Tv, CIndex{Ti}}()
coo = nothing
end
Communication.bcaststore!(csc, root, comm)
Acsc = SuperLUDIST.ReplicatedSuperMatrix(csc, grid)
m, n, = size(Acsc)
xtrue = Matrix{Tv}(undef, n, nrhs)
b = Matrix{Tv}(undef, m, nrhs)
if iam == root
SuperLUDIST.GenXtrue_dist!(xtrue, Ti)
SuperLUDIST.FillRHS_dist!(b, Acsc, xtrue)
end
MPI.Bcast!(b, root, comm)
MPI.Bcast!(xtrue, root, comm)
return coo, b, xtrue
end
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 2132 | """
$(TYPEDEF)
SuperMatrix that has been globally replicated on all ranks in a communicator.
The local storage contains the full matrix, the Julia representation may be accessed
by `A.store::SparseBase.CSCStore{T, CIndex{<:Int}}`.
# Extended
$(FIELDS)
"""
mutable struct ReplicatedSuperMatrix{T, I, S, F, J, G} <: AbstractSuperMatrix{T, I, S}
"""Internal: Reference to `Common.SuperMatrix{I}`"""
supermatrix::Base.RefValue{S}
"""Internal: Reference to storage format `Common.NCformat{I}` held by supermatrix"""
format::Base.RefValue{F}
"""Julia-side storage, of type `SparseBase.CSCStore. Keeps memory alive.`"""
store::J
grid::G
end
Base.size(A::ReplicatedSuperMatrix) = size(A.store)
Base.size(A::ReplicatedSuperMatrix, dim) = size(A.store, dim)
Communication.localpart(A::ReplicatedSuperMatrix) = A.store
function ReplicatedSuperMatrix{Tv, Ti}(grid::Grid{Ti}) where
{Tv, Ti}
store = SparseBase.CSCStore{Tv, CIndex{Ti}}()
return ReplicatedSuperMatrix(store, grid)
end
function ReplicatedSuperMatrix(store::SparseBase.CSCStore{Tv, CIndex{Ti}}, grid::Grid{Ti}, mtype = Common.SLU_GE) where
{Tv, Ti}
fmt, keepstore = Base.unsafe_convert(Common.NCformat, store)
fmtref = Ref(fmt)
superref = Ref(Common.SuperMatrix{Ti}(
Common.SLU_NC,
toslutype(Tv),
mtype,
Ti(size(store, 1)),
Ti(size(store, 2)),
Base.unsafe_convert(Ptr{Cvoid}, fmtref)
))
return ReplicatedSuperMatrix{Tv, Ti, eltype(superref), typeof(fmt), typeof(keepstore), typeof(grid)}(
superref, fmtref, keepstore, grid
)
end
# TODO: use new eltype / iltype setup.
function ReplicatedSuperMatrix(store::SparseBase.AbstractSparseStore{Tv, <:Any, CIndex{Ti}}, grid::Grid{Ti}, mtype = Common.SLU_GE) where
{Tv, Ti}
return ReplicatedSuperMatrix(convert(SparseBase.CSCStore, store), grid, mtype)
end
function ReplicatedSuperMatrix(store::SparseBase.AbstractSparseStore{Tv, <:Any, Ti}, grid::Grid{Ti}, mtype = Common.SLU_GE) where
{Tv, Ti}
return ReplicatedSuperMatrix(convert(SparseBase.CSCStore{Tv, CIndex{Ti}}, store), grid, mtype)
end
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 11317 | # Grid (gridinfo_t) functions:
##############################
# const Grid{I} = SuperLUDIST_Common.gridinfo_t{I}
# const Grid3D{I} = SuperLUDIST_Common.gridinfo3d_t{I}
struct Grid{I}
comm::MPI.Comm
gridinfo::SuperLUDIST_Common.gridinfo_t{I}
end
struct Grid3D{I}
comm::MPI.Comm
gridinfo::SuperLUDIST_Common.gridinfo3d_t{I}
end
for I ∈ (:Int32, :Int64)
L = Symbol(String(:SuperLU_) * String(I))
libname = Symbol(:libsuperlu_dist_, I)
@eval begin
function gridmap!(g::Grid{$I}, nprow, npcol, usermap::Matrix{Int32})
myrank = MPI.Comm_rank(g.comm)
color = myrank ÷ (nprow * npcol)
subcomm = MPI.Comm_split(g.comm, color, myrank)
$L.superlu_gridmap(subcomm, nprow, npcl, usermap, size(usermap, 1), g)
return g
end
function gridinit!(g::Grid{$I}, nprow, npcol)
$L.superlu_gridinit(g.comm, nprow, npcol, g)
return g
end
function Grid{$I}(nprow::Integer, npcol::Integer, comm = MPI.COMM_WORLD; batch = false, usermap = nothing)
$I == Int32 && libsuperlu_dist_Int32 === nothing &&
(throw(ArgumentError("libsuperlu_dist_Int32 is not loaded.")))
$I == Int64 && libsuperlu_dist_Int64 === nothing &&
(throw(ArgumentError("libsuperlu_dist_Int64 is not loaded.")))
!MPI.Initialized() && MPI.Init()
g = Grid{$I}(
comm,
SuperLUDIST_Common.gridinfo_t{$I}(
Base.unsafe_convert(MPI.MPI_Comm, comm),
superlu_scope_t(comm),
superlu_scope_t(comm),
convert(Cint, MPI.Comm_rank(comm)), nprow, npcol
)
)
if !batch
gridinit!(g, nprow, npcol)
else
usermap === nothing ? gridmap!(g, nprow, npcol) : gridmap!(g, nprow, npcol, usermap)
end
if g.iam == -1 || g.iam >= nprow * npcol
$L.superlu_gridexit(g)
return g
else
finalizer(g.gridinfo) do G
!MPI.Finalized() && $L.superlu_gridexit(G)
end
return g
end
end
# Base.unsafe_convert(T::Type{Ptr{SuperLUDIST_Common.gridinfo_t{$I}}}, g::Grid{$I}) =
# Base.unsafe_convert(T, g.grid)
Base.unsafe_convert(::Type{Ptr{SuperLUDIST_Common.gridinfo_t{$I}}}, O::Grid{$I}) =
Ptr{gridinfo_t{$I}}(pointer_from_objref(O.gridinfo))
Base.unsafe_convert(
::Type{Ptr{SuperLUDIST_Common.gridinfo_t{$I}}},
O::SuperLUDIST_Common.gridinfo_t{$I}
) = Ptr{gridinfo_t{$I}}(pointer_from_objref(O))
end # end eval
end # end for
function gridmap!(r, comm, nprow, npcol)
usermap = LinearIndices((nprow, npcol))' .- 1
return gridmap!(r, comm, nprow, npcol, usermap)
end
function SuperLUDIST_Common.superlu_scope_t(
comm; Np = MPI.Comm_size(comm), Iam = MPI.Comm_rank(comm)
)
return SuperLUDIST_Common.superlu_scope_t(
Base.unsafe_convert(MPI.MPI_Comm, comm), Np, Iam
)
end
function Base.getproperty(g::Grid, s::Symbol)
# Julia level functions expect a Comm, not an MPI_Comm / Int32.
s === :comm && return getfield(g, s)
s === :gridinfo && return getfield(g, s)
return getfield(g.gridinfo, s)
end
# Option functions:
###################
const Options = Common.superlu_dist_options_t
Base.unsafe_convert(::Type{Ptr{superlu_dist_options_t}}, O::superlu_dist_options_t) =
Ptr{superlu_dist_options_t}(pointer_from_objref(O))
# ScalePerm (ScalePermstruct_t) functions:
##########################################
struct ScalePerm{T, I, S}
scaleperm::S
end
ScalePerm{T}(m, n) where T = ScalePerm{T, Int}(m, n)
ScalePerm{T, I}(m, n) where {T, Ti, I<:CIndex{Ti}} =
ScalePerm{T, Ti}(m, n)
function Base.getproperty(g::ScalePerm, s::Symbol)
s === :scaleperm && return Base.getfield(g, s)
return getproperty(g.scaleperm, s)
end
for I ∈ (:Int32, :Int64)
L = Symbol(String(:SuperLU_) * String(I))
libname = Symbol(:libsuperlu_dist_, I)
for T ∈ (Float32, Float64, ComplexF64)
@eval begin
function ScalePerm{$T, $I}(m, n)
r = Common.$(prefixname(T, :ScalePermstruct_t)){$I}(
Common.NOEQUIL,
Ptr{Cvoid}(), Ptr{Cvoid}(),
Ptr{$I}(Libc.malloc(sizeof($I) * m)),
Ptr{$I}(Libc.malloc(sizeof($I) * n))
)
return ScalePerm{$T, $I, typeof(r)}(finalizer(r) do x
if !MPI.Finalized()
Libc.free(x.perm_r)
Libc.free(x.perm_c)
(x.DiagScale == Common.ROW || x.DiagScale == Common.BOTH) && Libc.free(x.R)
(x.DiagScale == Common.COL || x.DiagScale == Common.BOTH) && Libc.free(x.C)
end
end)
end
Base.unsafe_convert(T::Type{Ptr{$(prefixname(T, :ScalePermstruct_t)){$I}}}, S::ScalePerm{$T, $I}) =
Base.unsafe_convert(T, S.scaleperm)
Base.unsafe_convert(T::Type{Ptr{$(prefixname(T, :ScalePermstruct_t)){$I}}}, S::$(prefixname(T, :ScalePermstruct_t)){$I}) =
Ptr{$(prefixname(T, :ScalePermstruct_t)){$I}}(pointer_from_objref(S))
end # end eval
end # end for
end # end for
# LUFactors (LUstruct_t) functions:
###################################
struct LUFactors{T, I, S, G}
LU::S
grid::G
n::I
end
LUFactors{T}(n, grid) where T = LUFactors{T, Int}(n, grid)
LUFactors{T, I}(n, grid) where {T, Ti, I<:CIndex{Ti}} = LUFactors{T, Ti}(n, grid)
function Base.getproperty(g::LUFactors, s::Symbol)
s === :LU && return Base.getfield(g, s)
s === :grid && return Base.getfield(g, s)
s === :n && return Base.getfield(g, s)
return getproperty(g.LU, s)
end
for I ∈ (:Int32, :Int64)
L = Symbol(String(:SuperLU_) * String(I))
libname = Symbol(:libsuperlu_dist_, I)
for T ∈ (Float32, Float64, ComplexF64)
@eval begin
function LUFactors{$T, $I}(n, grid::G) where G
r = Common.$(prefixname(T, :LUstruct_t)){$I}(Ptr{Cvoid}(), Ptr{Cvoid}(), Ptr{Cvoid}(), '\0')
LUstructInit(r, n, grid)
return LUFactors{$T, $I, eltype(r), G}(r, grid, n)
end
Base.unsafe_convert(T::Type{Ptr{$(prefixname(T, :LUstruct_t)){$I}}}, S::LUFactors{$T, $I}) =
Base.unsafe_convert(T, S.LU)
Base.unsafe_convert(
::Type{Ptr{$(prefixname(T, :LUstruct_t)){$I}}},
L::$(prefixname(T, :LUstruct_t)){$I}
) = Ptr{$(prefixname(T, :LUstruct_t)){$I}}(pointer_from_objref(L))
end # end eval
end # end for
end # end for
# LUStat (SuperLUStat_t) functions:
###################################
struct LUStat{I, S}
stat::S
end
LUStat() = LUStat{Int}()
LUStat{I}() where {Ti, I<:CIndex{Ti}} = LUStat{Ti}()
for I ∈ (:Int32, :Int64)
L = Symbol(String(:SuperLU_) * String(I))
libname = Symbol(:libsuperlu_dist_, I)
@eval begin
function PStatInit(r::SuperLUStat_t{$I})
$L.PStatInit(r)
return finalizer(r) do x
!MPI.Finalized() && $L.PStatFree(x)
end
end
function LUStat{$I}()
r = SuperLUStat_t{$I}(
Ptr{Cvoid}(),
Ptr{Cvoid}(),
Ptr{Cvoid}(),
0, 0, 0, 0., 0., 0., 0, 0
)
PStatInit(r)
return LUStat{$I, typeof(r)}(r)
end
Base.unsafe_convert(T::Type{Ptr{Common.SuperLUStat_t{$I}}}, S::LUStat{$I}) =
Base.unsafe_convert(T, S.stat)
Base.unsafe_convert(
::Type{Ptr{Common.SuperLUStat_t{$I}}},
S::Common.SuperLUStat_t{$I}
) = Ptr{Common.SuperLUStat_t{$I}}(pointer_from_objref(S))
function PStatPrint(options, stat::LUStat{$I}, grid)
$L.PStatPrint(options, stat, grid)
end
end # end eval
end # end for
# SolveData (SOLVEstruct_t) functions:
######################################
mutable struct SolveData{T, I, S}
data::S
options::Options
end
SolveData{T}(options) where T = SolveData{T, Int}(options)
SolveData{T, I}(options) where {T, Ti, I<:CIndex{Ti}} =
SolveData{T, Ti}(options)
function Base.getproperty(g::SolveData, s::Symbol)
s === :options && return Base.getfield(g, s)
s === :data && return Base.getfield(g, s)
return getproperty(g.data, s)
end
for I ∈ (:Int32, :Int64)
L = Symbol(String(:SuperLU_) * String(I))
libname = Symbol(:libsuperlu_dist_, I)
for T ∈ (Float32, Float64, ComplexF64)
@eval begin
Base.unsafe_convert(T::Type{Ptr{$L.$(prefixname(T, :SOLVEstruct_t)){$I}}}, S::SolveData{$T, $I}) =
Base.unsafe_convert(T, S.data)
Base.unsafe_convert(
T::Type{Ptr{$L.$(prefixname(T, :SOLVEstruct_t)){$I}}},
S::$L.$(prefixname(T, :SOLVEstruct_t)){$I}
) = Ptr{$L.$(prefixname(T, :SOLVEstruct_t)){$I}}(pointer_from_objref(S))
function SolveData{$T, $I}(options)
r = $L.$(prefixname(T, :SOLVEstruct_t)){$I}(
Ptr{Cvoid}(),
Ptr{Cvoid}(),
0,
Ptr{Cvoid}(),
Ptr{Cvoid}(),
Ptr{Cvoid}(),
Ptr{Cvoid}(),
Ptr{Cvoid}(),
Ptr{Cvoid}(),
Ptr{Cvoid}()
)
S = SolveData{$T, $I, eltype(r)}(r, options)
return finalizer(S) do solve
!MPI.Finalized() && options.SolveInitialized == Common.YES &&
$L.$(prefixname(T, :SolveFinalize))(options, solve)
end
end
end # end eval
end # end for
end # end for
mutable struct SuperLUFactorization{T, I, A, Solve, Perm, Factors, Stat, B} <: LinearAlgebra.Factorization{T}
mat::A
options::Options
solve::Solve
perm::Perm
factors::Factors
stat::Stat
berr::Vector{T}
b::B
function SuperLUFactorization{T, I, A, Solve, Perm, Factors, Stat, B}(
mat::A, options::Options, solve::Solve, perm::Perm,
factors::Factors, stat::Stat, berr::Vector{T}, b::B
) where {
T<:Union{Float32, Float64, ComplexF64},
I <: Union{Int32, Int64},
A <: AbstractSuperMatrix{T, I},
Solve <: Union{SolveData{T, I}, Nothing},
Perm <: ScalePerm{T, I},
Factors <: LUFactors{T, I},
Stat <: LUStat{I},
B <: StridedVecOrMat{T}
}
return new(mat, options, solve, perm, factors, stat, berr, b)
end
end
isfactored(F::SuperLUFactorization) = F.options.Fact == Common.FACTORED
function SuperLUFactorization(
A::AbstractSuperMatrix{Tv, Ti}, options,
solve::Solve, perm::Perm, factors::Factors, stat::Stat, berr::Vector{Tv}, b::B
) where {Tv, Ti, Solve, Perm, Factors, Stat, B}
return SuperLUFactorization{Tv, Ti, typeof(A), Solve, Perm, Factors, Stat, B}(
A, options, solve, perm, factors, stat, berr, b
)
end
function PStatPrint(F::SuperLUFactorization)
PStatPrint(F.options, F.stat, F.mat.grid)
end
for I ∈ (:Int32, :Int64)
L = Symbol(String(:SuperLU_) * String(I))
libname = Symbol(:libsuperlu_dist_, I)
@eval begin
superlu_set_num_threads(::Type{$I}, n) =
ccall(
(:omp_set_num_threads_, $libname), Cvoid, (Ref{Int32},), Int32(n)
)
# SuperMatrix functions:
########################
Base.unsafe_convert(T::Type{Ptr{SuperMatrix{$I}}}, A::AbstractSuperMatrix{<:Any, $I}) =
Base.unsafe_convert(T, A.supermatrix)
end
for T ∈ (Float32, Float64, ComplexF64)
@eval begin
function inf_norm_error_dist(n, nrhs, b, ldb, xtrue::AbstractVector{$T}, ldx, grid::Grid{$I})
return $L.$(prefixname(T, :inf_norm_error_dist))(n, nrhs, b, ldb, xtrue, ldx, grid)
end
end
end
end
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | code | 71 | using SuperLUDIST
using Test
@testset "SuperLUDIST.jl" begin
end
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | docs | 4177 | # SuperLUDIST.jl
SuperLUDIST.jl is Julia wrapper around the [superlu_dist](https://github.com/xiaoyeli/superlu_dist) distributed sparse factorization library. superlu_dist contains a set of subroutines to solve a sparse linear system A*X=B.
SuperLUDIST is a parallel extension to the serial SuperLU library. It is targeted for the distributed memory parallel machines. SuperLUDIST is implemented in ANSI C, with OpenMP for on-node parallelism and MPI for off-node communications. We are actively developing GPU acceleration capabilities.
[](https://aa25desh.github.io/SuperLUDIST.jl/stable/)
[](https://aa25desh.github.io/SuperLUDIST.jl/dev/)
[](https://github.com/aa25desh/SuperLUDIST.jl/actions/workflows/CI.yml?query=branch%3Amain)
[](https://codecov.io/gh/aa25desh/SuperLUDIST.jl)
## Installation
`SuperLUDIST.jl` is available in the General registry through Julia's package manager.
Enter the Pkg REPL mode by typing `]` in the Julia REPL and then run:
```julia
pkg> add SuperLUDIST
```
or equivalently via the `Pkg.jl` API:
```julia
julia> import Pkg; Pkg.add("SuperLUDIST")
```
Proper use of `SuperLUDIST.jl` will typically also require `MPI.jl`, `SparseBase.jl` and possibly `MatrixMarket.jl`. These can be installed from the Pkg REPL mode:
```julia
pkg> add MPI SparseBase MatrixMarket
```
or equivalently:
```julia
julia> Pkg.add("MPI", "SparseBase", "MatrixMarket")
```
The binaries provided with Julia may not work correctly on your machine (this is currently affecting at least NERSC Perlmutter).
If this is the case you may provide your own library with:
```julia
SuperLUDIST.set_libraries!(; libsuperlu_dist_Int32 = <PATH TO 32 BIT LIBRARY>, libsuperlu_dist_Int64 = <PATH TO 64 BIT LIBRARY>)
``````
These libraries should be built with the proper integer size (32 bit or 64 bit),
and should be linked against the MPI used by MPI.jl (on HPC clusters this should be your system MPI).
You may provide one or the other, or both, but if the 32 or 64 bit integer libraries are unavailable 32 bit or 64 bit matrices will be unavailable respectively.
## Usage
Examples for running in replicated and distributed mode are provided in the examples directory. To run these examples
follow the instructions provided [here](https://juliaparallel.org/MPI.jl/latest/configuration/) to set up your MPI correctly. In particular `mpiexecjl` should be in your path (it is typically found in `~/.julia/bin`)
Then you can invoke a driver example:
```
mpiexecjl -n <nprocs> julia --project examples/basic_example.jl
```
This command does a couple things. The first part launches MPI with `<nprocs>` ranks. The second part `julia --project` activates the current folder. If your installation is in the global environment you may omit `--project`, or provide a path to the environment you would like to use: `--project=~/MySuperLUProject`. Finally `examples/pdrive.jl` is the Julia script to be executed under MPI.
Driver routine examples are found in the `examples` folder of this repository. The examples currently cover basic usage of `pgssvx` and `pgssvx_ABglobal` driver routines. These routines load matrix market files and generate right hand sides, which is not a typical use-case. Instead users will often build a submatrix on each rank, and construct a `DistributedSuperMatrix`.
## Known Issues
- CUDA support is currently disabled.
- OpenMP will often oversubscribe single node setups. In this case you should use `SuperLUDIST.superlu_set_num_threads(Int32, <num>)` or `SuperLUDIST.superlu_set_num_threads(Int64, <num>)` to the number of OpenMP threads desired on each rank.
## About the project
This is summer a project at [Lawrence Berkeley National Lab](https://www.lbl.gov) with scalable solvers group Led by [Dr. Xiaoye Sherry Li](https://crd.lbl.gov/divisions/amcr/applied-mathematics-dept/scalable-solvers/members/staff-members/xiaoye-li/).
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"BSD-3-Clause"
] | 0.3.2 | b88c81ea1f6c3b79154072842ddce1e70c572281 | docs | 191 | ```@meta
CurrentModule = SuperLUDIST
```
# SuperLUDIST
Documentation for [SuperLUDIST](https://github.com/aa25desh/SuperLUDIST.jl).
```@index
```
```@autodocs
Modules = [SuperLUDIST]
```
| SuperLUDIST | https://github.com/JuliaSparse/SuperLUDIST.jl.git |
|
[
"MIT"
] | 1.0.0 | 44b407f084023b50aaa73dd656fff5b214402596 | code | 4740 | module NativeNaNMath
using Base: IEEEFloat
#catch all, works with AD without specific rules
include("nanbase.jl")
using .NaNBase: SkipNaN, nan, skipnan
export skipnan
#functions with non-negative domain
for f in (:log,:log2,:log10,
:sqrt)
@eval begin
$f(x) = Base.$f(x)
function $f(x::Real)
in_domain = x >= zero(x)
Base.$f(ifelse(in_domain,x,nan(x)))
end
end
end
#two-argument log. TODO: find a better version
log(x,base) = Base.log(x,base)
function log(x::Real,base::Real)
in_domain = (x >= zero(x)) & (base > zero(base))
Base.log(ifelse(in_domain,x,nan(x)),ifelse(in_domain,base,nan(base)))
end
# domain: >= -1
log1p(x) = Base.log1p(x)
function log1p(x::Real)
in_domain = x >= -one(x)
Base.log1p(ifelse(in_domain,x,nan(x)))
end
#functions with finite domain:
for f in (:sin,:sind,:sinpi,
:cos,:cosd,:cospi,
:tan,:tand,
:sec,:secd,
:cot,:cotd,
:csc,:cscd)
@eval begin
$f(x) = Base.$f(x)
function $f(x::Real)
in_domain = !isinf(x)
Base.$f(ifelse(in_domain,x,nan(x)))
end
end
end
for f in (:sincos,:sincosd,:sincospi)
@eval begin
$f(x) = Base.$f(x)
function $f(x::Real)
in_domain = !isinf(x)
Base.$f(ifelse(in_domain,x,nan(x)))
end
end
end
#domain: -1 <= x <= 1
for f in (:asin,:asind,
:acos,:acosd,
:atanh)
@eval begin
$f(x) = Base.$f(x)
function $f(x::Real)
in_domain = abs(x) <= 1
Base.$f(ifelse(in_domain,x,nan(x)))
end
end
end
#domain: -Inf <= x <= -1 || 1 <= x <= Inf
for f in (:asec,:asecd,
:acsc,:acscd,
:acoth
)
@eval begin
$f(x) = Base.$f(x)
function $f(x::Real)
in_domain = abs(x) >= 1
Base.$f(ifelse(in_domain,x,nan(x)))
end
end
end
#domain: >= 1
acosh(x) = Base.acosh(x)
function acosh(x::Real)
in_domain = x >= one(x)
Base.acosh(ifelse(in_domain,x,nan(x)))
end
#domain: 0 <= x <= 1
asech(x) = Base.asech(x)
function asech(x::Real)
in_domain = zero(x) <= x <= one(x)
Base.asech(ifelse(in_domain,x,nan(x)))
end
# Don't override built-in ^ operator
"""
pow(x,y)
Exponentiation operator.
For arguments `!(x<:Real) | !(y<:Real)` it will use `Base.^`.
For `x<:Real & y<:Real`, it will always return an number capable of holding NaNs. It will return NaNs if `x<0`
## Examples
```jldoctest
julia> NativeNaNMath.pow(2,3)
8.0
julia> NativeNaNMath.pow(2,-3)
0.125
julia> NativeNaNMath.pow(2.0,3.0)
8.0
julia> NativeNaNMath.pow(-2.0,3.0)
NaN
```
"""
function pow(x::Real, y::Real)
x,y,_nan = promote(x,y,nan(x)) #this will make pow type-stable, at the cost of losing Integer exponentiation
z = ifelse(x>=zero(x),x,_nan)
return z^y
end
pow(x,y) = x^y
"""
NativeNaNMath.min(x, y)
Compute the IEEE 754-2008 compliant minimum of `x` and `y`. As of version 1.6 of Julia,
`Base.min(x, y)` will return `NaN` if `x` or `y` is `NaN`. `NativeNaNMath.min` favors values over
`NaN`, and will return whichever `x` or `y` is not `NaN` in that case.
## Examples
```julia
julia> NativeNaNMath.min(NaN, 0.0)
0.0
julia> NativeNaNMath.min(1, 2)
1
```
"""
min(x::T, y::T) where {T<:AbstractFloat} = ifelse((y < x) | (signbit(y) > signbit(x)),
ifelse(isnan(y), x, y),
ifelse(isnan(x), y, x))
"""
NativeNaNMath.max(x, y)
Compute the IEEE 754-2008 compliant maximum of `x` and `y`. As of version 1.6 of Julia,
`Base.max(x, y)` will return `NaN` if `x` or `y` is `NaN`. `NativeNaNMath.max` favors values over
`NaN`, and will return whichever `x` or `y` is not `NaN` in that case.
## Examples
```julia
julia> NativeNaNMath.max(NaN, 0.0)
0.0
julia> NativeNaNMath.max(1, 2)
2
```
"""
max(x::T, y::T) where {T<:AbstractFloat} = ifelse((y > x) | (signbit(y) < signbit(x)),
ifelse(isnan(y), x, y),
ifelse(isnan(x), y, x))
min(x::Real, y::Real) = min(promote(x, y)...)
max(x::Real, y::Real) = max(promote(x, y)...)
function min(x::BigFloat, y::BigFloat)
isnan(x) && return y
isnan(y) && return x
return Base.min(x, y)
end
function max(x::BigFloat, y::BigFloat)
isnan(x) && return y
isnan(y) && return x
return Base.max(x, y)
end
# Integers can't represent NaN
min(x::Integer, y::Integer) = Base.min(x, y)
max(x::Integer, y::Integer) = Base.max(x, y)
min(x::Real) = x
max(x::Real) = x
# Multi-arg versions
for f in (:min, :max)
@eval ($f)(a, b, c, xs...) = Base.afoldl($f, ($f)(($f)(a, b), c), xs...)
end
end #module
| NativeNaNMath | https://github.com/longemen3000/NativeNaNMath.jl.git |
|
[
"MIT"
] | 1.0.0 | 44b407f084023b50aaa73dd656fff5b214402596 | code | 5793 | #This is a port of SkipMissing, but for NaNs
module NaNBase
const BigNaN = big"NaN"
@inline nan(::T) where T = nan(T)
@inline nan(::Type{Float16}) = NaN16
@inline nan(::Type{Float32}) = NaN32
@inline nan(::Type{Float64}) = NaN64
#TODO: define nan for integer types
@inline nan(::Type{BigFloat}) = BigNaN
@inline nan(::Type{BigInt}) = BigNaN
@inline nan(::Type{T}) where T<:Real = zero(T)/zero(T)
#check if this gives out the correct behaviour.
@inline nan(::Type{<:Rational{T}}) where T = nan(T)
struct SkipNaN{T}
x::T
end
function Base.show(io::IO, s::SkipNaN)
print(io, "skipnan(")
show(io, s.x)
print(io, ')')
end
"""
skipnan(itr)
Return an iterator over the elements in `itr` skipping NaN values.
The returned object can be indexed using indices of `itr` if the latter is indexable.
Indices corresponding to NaN values are not valid: they are skipped by [`keys`](@ref)
and [`eachindex`](@ref), and a `ErrorException` is thrown when trying to use them.
Use [`collect`](@ref) to obtain an `Array` containing the non-`NaN` values in
`itr`. Note that even if `itr` is a multidimensional array, the result will always
be a `Vector` since it is not possible to remove NaNs while preserving dimensions
of the input.
# Examples
```jldoctest
julia> x = skipnan([1, NaN, 2])
skipnan([1.0, NaN, 2.0])
julia> sum(x)
3
julia> x[1]
1
julia> x[2]
ERROR: the value at index (2,) is NaN
[...]
julia> argmax(x)
3
julia> collect(keys(x))
2-element Vector{Int64}:
1
3
julia> collect(skipnan([1, NaN, 2]))
2-element Vector{Float64}:
1.0
2.0
julia> collect(skipnan([1 NaN; 2 NaN]))
2-element Vector{Float64}:
1.0
2.0
```
"""
skipnan(itr) = SkipNaN(itr)
Base.IteratorSize(::Type{<:SkipNaN}) = Base.SizeUnknown()
Base.IteratorEltype(::Type{SkipNaN{T}}) where {T} = Base.IteratorEltype(T)
Base.eltype(::Type{SkipNaN{T}}) where {T} = eltype(T)
function Base.iterate(itr::SkipNaN, state...)
y = iterate(itr.x, state...)
y === nothing && return nothing
item, state = y
while isnan(item)
y = iterate(itr.x, state)
y === nothing && return nothing
item, state = y
end
item, state
end
Base.IndexStyle(::Type{<:SkipNaN{T}}) where {T} = Base.IndexStyle(T)
Base.eachindex(itr::SkipNaN) =
Iterators.filter(i -> !isnan(@inbounds(itr.x[i])), eachindex(itr.x))
Base.keys(itr::SkipNaN) =
Iterators.filter(i -> !isnan(@inbounds(itr.x[i])), keys(itr.x))
Base.@propagate_inbounds function Base.getindex(itr::SkipNaN, I...)
v = itr.x[I...]
isnan(v) && throw(Base.ErrorException("the value at index $I is NaN"))
v
end
#fast shortcut
#if typeof(nan(x)) != typeof(x) then x cannot hold nans
Base.mapreduce(f, op, itr::SkipNaN{<:AbstractArray}) =
Base._mapreduce(f, op, IndexStyle(itr.x), typeof(nan(eltype(itr.x))) != eltype(itr.x) ? itr.x : itr)
function Base._mapreduce(f, op, ::Base.IndexLinear, itr::SkipNaN{<:AbstractArray})
A = itr.x
_nan = nan(eltype(A))
ai = _nan
inds = Base.LinearIndices(A)
i = first(inds)
ilast = last(inds)
for outer i in i:ilast
@inbounds ai = A[i]
!isnan(ai) && break
end
isnan(ai) && return Base.mapreduce_empty(f, op, eltype(itr))
a1::eltype(itr) = ai
i == typemax(typeof(i)) && return Base.mapreduce_first(f, op, a1)
i += 1
ai = _nan
for outer i in i:ilast
@inbounds ai = A[i]
!isnan(ai) && break
end
isnan(ai) && return Base.mapreduce_first(f, op, a1)
# We know A contains at least two non-missing entries: the result cannot be nothing
Base.something(Base.mapreduce_impl(f, op, itr, first(inds), last(inds)))
end
Base._mapreduce(f, op, ::Base.IndexCartesian, itr::SkipNaN) = Base.mapfoldl(f, op, itr)
Base.mapreduce_impl(f, op, A::SkipNaN, ifirst::Integer, ilast::Integer) =
Base.mapreduce_impl(f, op, A, ifirst, ilast, Base.pairwise_blocksize(f, op))
# Returns nothing when the input contains only missing values, and Some(x) otherwise
@noinline function Base.mapreduce_impl(f, op, itr::SkipNaN{<:AbstractArray},
ifirst::Integer, ilast::Integer, blksize::Int)
A = itr.x
if ifirst > ilast
return nothing
elseif ifirst == ilast
@inbounds a1 = A[ifirst]
if isnan(a1)
return nothing
else
return Some(Base.mapreduce_first(f, op, a1))
end
elseif ilast - ifirst < blksize
# sequential portion
_nan = nan(eltype(A))
ai = _nan
i = ifirst
for outer i in i:ilast
@inbounds ai = A[i]
!isnan(ai) && break
end
isnan(ai) && return nothing
a1 = ai::eltype(itr)
i == typemax(typeof(i)) && return Some(Base.mapreduce_first(f, op, a1))
i += 1
ai = _nan
for outer i in i:ilast
@inbounds ai = A[i]
!isnan(ai) && break
end
isnan(ai) && return Some(Base.mapreduce_first(f, op, a1))
a2 = ai::eltype(itr)
i == typemax(typeof(i)) && return Some(op(f(a1), f(a2)))
i += 1
v = op(f(a1), f(a2))
@simd for i = i:ilast
@inbounds ai = A[i]
if !isnan(ai)
v = op(v, f(ai))
end
end
return Some(v)
else
# pairwise portion
imid = ifirst + (ilast - ifirst) >> 1
v1 = Base.mapreduce_impl(f, op, itr, ifirst, imid, blksize)
v2 = Base.mapreduce_impl(f, op, itr, imid+1, ilast, blksize)
if v1 === nothing && v2 === nothing
return nothing
elseif v1 === nothing
return v2
elseif v2 === nothing
return v1
else
return Some(op(something(v1), something(v2)))
end
end
end
end
| NativeNaNMath | https://github.com/longemen3000/NativeNaNMath.jl.git |
|
[
"MIT"
] | 1.0.0 | 44b407f084023b50aaa73dd656fff5b214402596 | code | 9071 | @testset "nan" begin
for T in (Int8,Int16,Int32,Int64,Float16,Float32,Float64,BigFloat,BigInt,Rational{Int},Rational{BigInt})
@test isnan(nan(T))
end
end
@testset "log" begin
@test isnan(NativeNaNMath.log(-10))
@test isnan(NativeNaNMath.log1p(-100))
@test isnan(NativeNaNMath.log2(-100))
@test isnan(NativeNaNMath.log10(-100))
@test isnan(NativeNaNMath.log(-10,2))
@test isnan(NativeNaNMath.log(10,-2))
@test isnan(NativeNaNMath.log(-2,-2))
@test NativeNaNMath.log(Complex(2)) == Base.log(Complex(2))
@test NativeNaNMath.log2(Complex(2)) == Base.log2(Complex(2))
@test NativeNaNMath.log10(Complex(2)) == Base.log10(Complex(2))
@test NativeNaNMath.log1p(Complex(2)) == Base.log1p(Complex(2))
@test NativeNaNMath.log(Complex(2),Complex(2)) == Base.log(Complex(2),Complex(2))
end
@testset "pow" begin
@test isnan(NativeNaNMath.pow(-1.5,2.3))
@test isnan(NativeNaNMath.pow(-1.5f0,2.3f0))
@test isnan(NativeNaNMath.pow(-1.5,2.3f0))
@test isnan(NativeNaNMath.pow(-1.5f0,2.3))
@test NativeNaNMath.pow(-1,2) isa Float64
@test NativeNaNMath.pow(-1.5f0,2) isa Float32
@test NativeNaNMath.pow(-1.5f0,2//1) isa Float32
@test NativeNaNMath.pow(-1.5f0,2.3f0) isa Float32
@test NativeNaNMath.pow(-1.5f0,2.3) isa Float64
@test NativeNaNMath.pow(-1.5,2) isa Float64
@test NativeNaNMath.pow(-1.5,2//1) isa Float64
@test NativeNaNMath.pow(-1.5,2.3f0) isa Float64
@test NativeNaNMath.pow(-1.5,2.3) isa Float64
@test NativeNaNMath.pow(randdiag,2) == randdiag^2
end
@testset "sqrt" begin
@test isnan(NativeNaNMath.sqrt(-5))
@test NativeNaNMath.sqrt(5) == Base.sqrt(5)
end
@testset "finite domain" begin
@test isnan(NativeNaNMath.sin(Inf))
@test isnan(NativeNaNMath.sind(Inf))
@test isnan(NativeNaNMath.sinpi(Inf))
@test isnan(NativeNaNMath.cos(Inf))
@test isnan(NativeNaNMath.cosd(Inf))
@test isnan(NativeNaNMath.cospi(Inf))
@test isnan(NativeNaNMath.tan(Inf))
@test isnan(NativeNaNMath.tand(Inf))
@test isnan(NativeNaNMath.sec(Inf))
@test isnan(NativeNaNMath.secd(Inf))
@test isnan(NativeNaNMath.cot(Inf))
@test isnan(NativeNaNMath.cotd(Inf))
@test isnan(NativeNaNMath.csc(Inf))
@test isnan(NativeNaNMath.cscd(Inf))
@test isnan(NativeNaNMath.sin(-Inf))
@test isnan(NativeNaNMath.sind(-Inf))
@test isnan(NativeNaNMath.sinpi(-Inf))
@test isnan(NativeNaNMath.cos(-Inf))
@test isnan(NativeNaNMath.cosd(-Inf))
@test isnan(NativeNaNMath.cospi(-Inf))
@test isnan(NativeNaNMath.tan(-Inf))
@test isnan(NativeNaNMath.tand(-Inf))
@test isnan(NativeNaNMath.sec(-Inf))
@test isnan(NativeNaNMath.secd(-Inf))
@test isnan(NativeNaNMath.cot(-Inf))
@test isnan(NativeNaNMath.cotd(-Inf))
@test isnan(NativeNaNMath.csc(-Inf))
@test isnan(NativeNaNMath.cscd(-Inf))
@test !isnan(NativeNaNMath.sin(-2.3))
@test !isnan(NativeNaNMath.sind(-2.3))
@test !isnan(NativeNaNMath.sinpi(-2.3))
@test !isnan(NativeNaNMath.cos(-2.3))
@test !isnan(NativeNaNMath.cosd(-2.3))
@test !isnan(NativeNaNMath.cospi(-2.3))
@test !isnan(NativeNaNMath.tan(-2.3))
@test !isnan(NativeNaNMath.tand(-2.3))
@test !isnan(NativeNaNMath.sec(-2.3))
@test !isnan(NativeNaNMath.secd(-2.3))
@test !isnan(NativeNaNMath.cot(-2.3))
@test !isnan(NativeNaNMath.cotd(-2.3))
@test !isnan(NativeNaNMath.csc(-2.3))
@test !isnan(NativeNaNMath.cscd(-2.3))
@test isnan.(NativeNaNMath.sincos(Inf)) |> all
@test isnan.(NativeNaNMath.sincospi(Inf)) |> all
@test isnan.(NativeNaNMath.sincosd(Inf)) |> all
@test isnan.(NativeNaNMath.sincos(-Inf)) |> all
@test isnan.(NativeNaNMath.sincospi(-Inf)) |> all
@test isnan.(NativeNaNMath.sincosd(-Inf)) |> all
@test !all(isnan.(NativeNaNMath.sincos(-2.3)))
@test !all(isnan.(NativeNaNMath.sincospi(-2.3)))
@test !all(isnan.(NativeNaNMath.sincosd(-2.3)))
@test NativeNaNMath.sin(randdiag) == Base.sin(randdiag)
@test first(NativeNaNMath.sincos(randdiag)) == first(Base.sincos(randdiag))
end
@testset "0 <= x <= 1" begin
@test isnan(NativeNaNMath.asin(2.))
@test isnan(NativeNaNMath.asind(2.))
@test isnan(NativeNaNMath.acos(2.))
@test isnan(NativeNaNMath.acosd(2.))
@test isnan(NativeNaNMath.atanh(2.))
@test isnan(NativeNaNMath.asin(-2.))
@test isnan(NativeNaNMath.asind(-2.))
@test isnan(NativeNaNMath.acos(-2.))
@test isnan(NativeNaNMath.acosd(-2.))
@test isnan(NativeNaNMath.atanh(-2.))
@test !isnan(NativeNaNMath.asin(0.))
@test !isnan(NativeNaNMath.asind(0.))
@test !isnan(NativeNaNMath.acos(0.))
@test !isnan(NativeNaNMath.acosd(0.))
@test !isnan(NativeNaNMath.atanh(0.))
@test !isnan(NativeNaNMath.asin(-1.))
@test !isnan(NativeNaNMath.asind(-1.))
@test !isnan(NativeNaNMath.acos(-1.))
@test !isnan(NativeNaNMath.acosd(-1.))
@test !isnan(NativeNaNMath.atanh(-1.))
@test !isnan(NativeNaNMath.asin(1.))
@test !isnan(NativeNaNMath.asind(1.))
@test !isnan(NativeNaNMath.acos(1.))
@test !isnan(NativeNaNMath.acosd(1.))
@test !isnan(NativeNaNMath.atanh(1.))
@test NativeNaNMath.asin(randdiag) == Base.asin(randdiag)
end
@testset "x ∉ (0,1)" begin
@test isnan(NativeNaNMath.asec(0.))
@test isnan(NativeNaNMath.asecd(0.))
@test isnan(NativeNaNMath.acsc(0.))
@test isnan(NativeNaNMath.acscd(0.))
@test isnan(NativeNaNMath.acoth(0.))
@test !isnan(NativeNaNMath.asec(2.))
@test !isnan(NativeNaNMath.asecd(2.))
@test !isnan(NativeNaNMath.acsc(2.))
@test !isnan(NativeNaNMath.acscd(2.))
@test !isnan(NativeNaNMath.acoth(2.))
@test !isnan(NativeNaNMath.asec(-2.))
@test !isnan(NativeNaNMath.asecd(-2.))
@test !isnan(NativeNaNMath.acsc(-2.))
@test !isnan(NativeNaNMath.acscd(-2.))
@test !isnan(NativeNaNMath.acoth(-2.))
@test NativeNaNMath.asec(randdiag) == Base.asec(randdiag)
end
@testset "other domains" begin
#acosh: x >= 1
@test !isnan(NativeNaNMath.acosh(2))
@test isnan(NativeNaNMath.acosh(0))
@test NativeNaNMath.acosh(randdiag) == Base.acosh(randdiag)
#asech: 0 <= x <= 1
@test !isnan(NativeNaNMath.asech(0.5))
@test isnan(NativeNaNMath.asech(2))
@test isnan(NativeNaNMath.asech(-2))
@test NativeNaNMath.asech(randdiag) == Base.asech(randdiag)
end
@testset "reductions" begin
@test sum([1., 2., NaN] |> skipnan) == 3.0
@test sum([1. 2.; NaN 1.] |> skipnan) == 4.0
@test_broken isnan(sum([NaN, NaN] |> skipnan))
#collect(skipnan([NaN, NaN])) == Float64[]
@test sum(Float64[] |> skipnan) == 0.0
@test sum([1f0, 2f0, NaN32] |> skipnan) === 3.0f0
@test maximum([1., 2., NaN] |> skipnan) == 2.0
@test maximum([1. 2.; NaN 1.] |> skipnan) == 2.0
@test minimum([1., 2., NaN] |> skipnan) == 1.0
@test minimum([1. 2.; NaN 1.] |> skipnan) == 1.0
@test extrema([1., 2., NaN] |> skipnan) == (1.0, 2.0)
@test extrema([2., 1., NaN] |> skipnan) == (1.0, 2.0)
@test extrema([1. 2.; NaN 1.] |> skipnan) == (1.0, 2.0)
@test extrema([2. 1.; 1. NaN] |> skipnan) == (1.0, 2.0)
@test extrema([NaN, -1., NaN] |> skipnan) == (-1.0, -1.0)
end
@testset "statistics" begin
@test mean([1., 2., NaN] |> skipnan) == 1.5
@test mean([1. 2.; NaN 3.] |> skipnan) == 2.0
@test var([1., 2., NaN] |> skipnan) == 0.5
@test std([1., 2., NaN] |> skipnan) == 0.7071067811865476
@test median([1.] |> skipnan) == 1.
@test median([1., NaN] |> skipnan) == 1.
@test median([NaN, 1., 3.] |> skipnan) == 2.
@test median([1., 3., 2., NaN] |> skipnan) == 2.
@test median([NaN, 1, 3] |> skipnan) == 2.
@test median([1, 2, NaN] |> skipnan) == 1.5
@test median([1 2; NaN NaN] |> skipnan) == 1.5
@test median([NaN 2; 1 NaN] |> skipnan) == 1.5
@test_broken isnan(median(Float64[] |> skipnan)) #empty collection error
@test_broken isnan(median(Float32[] |> skipnan)) #empty collection error
@test_broken isnan(median([NaN] |> skipnan)) #empty collection error
end
@testset "min/max" begin
@test NativeNaNMath.min(1, 2) == 1
@test NativeNaNMath.min(1.0, 2.0) == 1.0
@test NativeNaNMath.min(1, 2.0) == 1.0
@test NativeNaNMath.min(BigFloat(1.0), 2.0) == BigFloat(1.0)
@test NativeNaNMath.min(BigFloat(1.0), BigFloat(2.0)) == BigFloat(1.0)
@test NativeNaNMath.min(NaN, 1) == 1.0
@test NativeNaNMath.min(NaN32, 1) == 1.0f0
@test isnan(NativeNaNMath.min(NaN, NaN))
@test isnan(NativeNaNMath.min(NaN))
@test NativeNaNMath.min(NaN, NaN, 0.0, 1.0) == 0.0
@test NativeNaNMath.max(1, 2) == 2
@test NativeNaNMath.max(1.0, 2.0) == 2.0
@test NativeNaNMath.max(1, 2.0) == 2.0
@test NativeNaNMath.max(BigFloat(1.0), 2.0) == BigFloat(2.0)
@test NativeNaNMath.max(BigFloat(1.0), BigFloat(2.0)) == BigFloat(2.0)
@test NativeNaNMath.max(NaN, 1) == 1.0
@test NativeNaNMath.max(NaN32, 1) == 1.0f0
@test isnan(NativeNaNMath.max(NaN, NaN))
@test isnan(NativeNaNMath.max(NaN))
@test NativeNaNMath.max(NaN, NaN, 0.0, 1.0) == 1.0
end | NativeNaNMath | https://github.com/longemen3000/NativeNaNMath.jl.git |
|
[
"MIT"
] | 1.0.0 | 44b407f084023b50aaa73dd656fff5b214402596 | code | 184 | using NativeNaNMath
using NativeNaNMath: skipnan,nan
using Test, Statistics
const randmatrix = rand(2,2)
const randdiag = [rand() 0.;0. rand()]
include("math.jl")
include("skipnan.jl") | NativeNaNMath | https://github.com/longemen3000/NativeNaNMath.jl.git |
|
[
"MIT"
] | 1.0.0 | 44b407f084023b50aaa73dd656fff5b214402596 | code | 6207 | @testset "skipnan" begin
x = skipnan([1, 2, NaN, 4])
@test repr(x) == "skipnan([1.0, 2.0, NaN, 4.0])"
@test eltype(x) === Float64
@test collect(x) == [1., 2., 4.]
@test collect(x) isa Vector{Float64}
x = skipnan([1. 2.; NaN 4.])
@test eltype(x) === Float64
@test collect(x) == [1, 2, 4]
@test collect(x) isa Vector{Float64}
x = collect(skipnan([NaN]))
@test eltype(x) === Float64
@test isempty(collect(x))
@test collect(x) isa Vector{Float64}
x = skipnan([NaN, NaN, 1., 2., NaN, 4., NaN, NaN])
@test eltype(x) === Float64
@test collect(x) == [1., 2., 4.]
@test collect(x) isa Vector{Float64}
x = skipnan(v for v in [NaN, 1, NaN, 2, 4])
@test eltype(x) === Any
@test collect(x) == [1., 2., 4.]
@test collect(x) isa Vector{Float64}
@testset "indexing" begin
x = skipnan([1, NaN, 2, NaN, NaN])
@test collect(eachindex(x)) == collect(keys(x)) == [1, 3]
@test x[1] === 1.
@test x[3] === 2.
@test_throws ErrorException x[2]
@test_throws BoundsError x[6]
@test findfirst(==(2), x) == 3
@test findall(==(2), x) == [3]
@test argmin(x) == 1
@test findmin(x) == (1, 1)
@test argmax(x) == 3
@test findmax(x) == (2, 3)
x = skipnan([NaN 2; 1 NaN])
@test collect(eachindex(x)) == [2, 3]
@test collect(keys(x)) == [CartesianIndex(2, 1), CartesianIndex(1, 2)]
@test x[2] === x[2, 1] === 1.
@test x[3] === x[1, 2] === 2.
@test_throws ErrorException x[1]
@test_throws ErrorException x[1, 1]
@test_throws BoundsError x[5]
@test_throws BoundsError x[3, 1]
@test findfirst(==(2), x) == CartesianIndex(1, 2)
@test findall(==(2), x) == [CartesianIndex(1, 2)]
@test argmin(x) == CartesianIndex(2, 1)
@test findmin(x) == (1, CartesianIndex(2, 1))
@test argmax(x) == CartesianIndex(1, 2)
@test findmax(x) == (2, CartesianIndex(1, 2))
for x in (skipnan([]), skipnan([NaN, NaN]))
@test isempty(collect(eachindex(x)))
@test isempty(collect(keys(x)))
@test_throws BoundsError x[3]
@test_throws BoundsError x[3, 1]
@test findfirst(==(2), x) === nothing
@test isempty(findall(==(2), x))
if Base.VERSION < v"1.8"
@test_throws ArgumentError argmin(x)
@test_throws ArgumentError findmin(x)
@test_throws ArgumentError argmax(x)
@test_throws ArgumentError findmax(x)
else
@test_throws MethodError argmin(x)
@test_throws MethodError findmin(x)
@test_throws MethodError argmax(x)
@test_throws MethodError findmax(x)
end
end
end
@testset "mapreduce" begin
# Vary size to test splitting blocks with several configurations of missing values
for T in (Int, Float64),
A in (rand(T, 10), rand(T, 1000), rand(T, 10000))
if T === Int
@test sum(A) === @inferred(sum(skipnan(A))) ===
@inferred(reduce(+, skipnan(A))) ===
@inferred(mapreduce(identity, +, skipnan(A)))
else
@test sum(A) ≈ @inferred(sum(skipnan(A))) ===
@inferred(reduce(+, skipnan(A))) ===
@inferred(mapreduce(identity, +, skipnan(A)))
end
@test mapreduce(cos, *, A) ≈
@inferred(mapreduce(cos, *, skipnan(A)))
B = Vector{Float64}(A)
replace!(x -> rand(Bool) ? x : NaN, B)
@test sum(collect(skipnan(B))) ≈ @inferred(sum(skipnan(B))) ===
@inferred(reduce(+, skipnan(B))) ===
@inferred(mapreduce(identity, +, skipnan(B)))
@test mapreduce(cos, *, collect(skipnan(A))) ≈
@inferred(mapreduce(cos, *, skipnan(A)))
# Test block full of missing values
B[1:length(B)÷2] .= NaN
@test sum(collect(skipnan(B))) ≈ sum(skipnan(B)) ==
reduce(+, skipnan(B)) == mapreduce(identity, +, skipnan(B))
@test mapreduce(cos, *, collect(skipnan(A))) ≈ mapreduce(cos, *, skipnan(A))
end
# Patterns that exercize code paths for inputs with 1 or 2 non-missing values
@test sum(skipnan([1., NaN, NaN, NaN])) === 1.
@test sum(skipnan([NaN, NaN, NaN, 1.])) === 1.
@test sum(skipnan([1, NaN, NaN, NaN, 2.])) === 3.
@test sum(skipnan([NaN, NaN, NaN, 1., 2.])) === 3.
for n in 0:3
itr = skipnan(Vector{Float64}(fill(NaN, n)))
@test sum(itr) == reduce(+, itr) == mapreduce(identity, +, itr) === 0.
if Base.VERSION < v"1.8"
@test_throws ArgumentError reduce(x -> x/2, itr)
@test_throws ArgumentError mapreduce(x -> x/2, +, itr)
else
@test_throws MethodError reduce(x -> x/2, itr)
@test_throws MethodError mapreduce(x -> x/2, +, itr)
end
end
end
end
#=
# issue #35504
nt = NamedTuple{(:x, :y),Tuple{Union{Missing, Int},Union{Missing, Float64}}}(
(missing, missing))
@test sum(skipnan(nt)) === 0
# issues #38627 and #124
@testset for len in [1, 2, 15, 16, 1024, 1025]
v = repeat(Union{Int,Missing}[1], len)
oa = OffsetArray(v, typemax(Int)-length(v))
sm = skipnan(oa)
@test sum(sm) == len
v = repeat(Union{Int,Missing}[missing], len)
oa = OffsetArray(v, typemax(Int)-length(v))
sm = skipnan(oa)
@test sum(sm) == 0
@testset "filter" begin
allmiss = Vector{Union{Int,Missing}}(missing, 10)
@test isempty(filter(isodd, skipnan(allmiss))::Vector{Int})
twod1 = [1.0f0 missing; 3.0f0 missing]
@test filter(x->x > 0, skipnan(twod1))::Vector{Float32} == [1, 3]
twod2 = [1.0f0 2.0f0; 3.0f0 4.0f0]
@test filter(x->x > 0, skipnan(twod2)) == reshape(twod2, (4,))
end
end=# | NativeNaNMath | https://github.com/longemen3000/NativeNaNMath.jl.git |
|
[
"MIT"
] | 1.0.0 | 44b407f084023b50aaa73dd656fff5b214402596 | docs | 2507 | # NativeNaNMath
[](https://github.com/longemen3000/NativeNaNMath.jl/actions)
[](https://codecov.io/gh/longemen3000/NativeNaNMath.jl)
Alternative approach to [NaNMath.jl](https://github.com/mlubin/NaNMath.jl), by using the functions available in Julia Base instead of the Libm ones.
It should be (almost) drop-in replacement for NaNMath.jl.
## Mathematic functions:
The following functions are not exported but defined:
- Logarithmic:
- `log(x)`,`log1p(x)`,`log2(x)`,`log10(x)`,`log1p(x)`
- `log(x,base)`
- Trigonometric:
- `sin(x)`,`cos(x)`,`tan(x)`,`cot(x)`,`sec(x)`,`csc(x)`
- `sind(x)`,`cosd(x)`,`tand(x)`,`cotd(x)`,`secd(x)`,`cscd(x)`
- `sinpi(x)`,`cospi(x)`
- `sincos(x)`,`sincosd(x)`,`sincospi(x)`
- `asin(x)`,`acos(x)`,`asec(x)`,`acsc(x)`
- `asind(x)`,`acosd(x)`,`asecd(x)`,`acscd(x)`
- Hyperbolic:
- `acosh(x)`,`asech(x)`,`atanh(x)`,`acoth(x)`
- `sqrt(x)`
- `pow(x,y)`
- `min(x)`,`max(x)`
## `skipnan`
The package only exports a single function: `skipnan(itr)` that works in the same way that `skipmissing(itr)`:
```julia
x = collect(1.0:10.0)
x[end] = NaN
xn = skipnan(x)
sum(xn) #45
```
## `nan`
The package uses the `nan(::Type{<:Real})` function to obtain an always valid NaN. on types that aren't capable of holding NaNs, (like all integers), it will return a promoted type that can hold NaNs (`Float64` for `Int8`,`Int16`,`Int32`,`Int64`, `BigFloat` for `BigInt`). on Rationals, `nan(Rational{T}) = nan(T)`. This function should satisfy `isnan(nan(T))`
It defaults to `zero(x)/zero(x)`.
## Differences with NaNMath.jl
- instead of providing NaN-compatible `sum`, `maximum`, `minimum`, etc. It provides a nan-skipping iterator. it can reproduce almost all functionality, except some corner cases:
- `sum(skipnan[NaN])` is `0.0` instead of `NaN`, because `collect(skipnan([NaN])) = Float64[]` and `sum(Float64[]) == 0.0`
- `median(skipnan([NaN])` is not defined. same reason that with `sum`
Other than that, `skipnan` expands the NaN functionality to any reducing operator.
- `pow(x::Integer,y::Integer)` will always promote to a float type.
- `NativeNaNMath.f(x)` where x is not a `Real` number will always default to `Base.f(x)`. This is useful because automatic differenciation and custom number types can use this package without overloading anything.
| NativeNaNMath | https://github.com/longemen3000/NativeNaNMath.jl.git |
|
[
"MIT"
] | 0.1.6 | aea60d3eda027c10f838db7c57b30ed0f7041682 | code | 813 | using Documenter, Sqlite3Stats
makedocs(
format = Documenter.HTML(
prettyurls = get(ENV, "CI", nothing) == "true",
collapselevel = 2,
# assets = ["assets/favicon.ico", "assets/extra_styles.css"],
# analytics = "UA-xxxxxxxxx-x",
),
sitename="Sqlite3Stats.jl",
authors = "Mehmet Hakan Satman",
pages = [
"Index" => "index.md",
"Examples" => "examples.md",
"API References" => "api.md",
"Contributing" => "contributing.md",
]
)
deploydocs(
repo = "github.com/jbytecode/Sqlite3Stats.jl",
)
| Sqlite3Stats | https://github.com/jbytecode/Sqlite3Stats.jl.git |
|
[
"MIT"
] | 0.1.6 | aea60d3eda027c10f838db7c57b30ed0f7041682 | code | 12673 | module Sqlite3Stats
import Distributions
import StatsBase
import HypothesisTests
import SQLite
import Logging
export StatsBase
export SQLite
export Distributions
export register_functions
function linear_regression(x::Array{Float64,1}, y::Array{Float64,1})::Array{Float64,1}
meanx = StatsBase.mean(x)
meany = StatsBase.mean(y)
beta1 = sum((x .- meanx) .* (y .- meany)) / sum((x .- meanx) .* (x .- meanx))
beta0 = meany - beta1 * meanx
return [beta0, beta1]
end
macro F64Vector()
Array{Float64,1}(undef, 0)
end
macro F64Matrix2()
Array{Float64,2}(undef, (0, 2))
end
function register_hypothesis_tests(db::SQLite.DB, verbose::Bool)::Nothing
# Jarque-Bera test for normality
SQLite.register(
db,
@F64Vector,
(x, y) -> vcat(x, y),
x -> HypothesisTests.pvalue(HypothesisTests.JarqueBeraTest(x)),
name = "JB",
)
return nothing
end
function register_descriptive_functions(db::SQLite.DB, verbose::Bool)::Nothing
@info "Registering Quantiles"
# First Quartile
# or 0.25th Quartile
SQLite.register(
db,
@F64Vector,
(x, y) -> vcat(x, y),
x -> StatsBase.quantile(x, 0.25),
name = "Q1",
)
# Second Quartiles or sample median
SQLite.register(
db,
@F64Vector,
(x, y) -> vcat(x, y),
x -> StatsBase.quantile(x, 0.50),
name = "Q2",
)
# Sample median
SQLite.register(
db,
@F64Vector,
(x, y) -> vcat(x, y),
x -> StatsBase.quantile(x, 0.50),
name = "MEDIAN",
)
# Third Quartile or 0.75th Quartile
SQLite.register(
db,
@F64Vector,
(x, y) -> vcat(x, y),
x -> StatsBase.quantile(x, 0.75),
name = "Q3",
)
# QUANTILE(x, p)
# where 0 <= p <= 1
SQLite.register(
db,
@F64Matrix2,
(x, a, b) -> vcat(x, [a, b]'),
x -> StatsBase.quantile(x[:, 1], x[1, 2]),
name = "QUANTILE",
nargs = 2,
)
@info "Registering covariance and correlation"
# COVARIANCE(x, y)
SQLite.register(
db,
@F64Matrix2,
(x, a, b) -> vcat(x, [a, b]'),
x -> StatsBase.cov(x[:, 1], x[:, 2]),
name = "COV",
nargs = 2,
)
SQLite.register(
db,
@F64Matrix2,
(x, a, b) -> vcat(x, [a, b]'),
x -> StatsBase.cor(x[:, 1], x[:, 2]),
name = "COR",
nargs = 2,
)
SQLite.register(
db,
@F64Matrix2,
(x, a, b) -> vcat(x, [a, b]'),
x -> StatsBase.corspearman(x[:, 1], x[:, 2]),
name = "CORSPEARMAN",
nargs = 2,
)
SQLite.register(
db,
@F64Matrix2,
(x, a, b) -> vcat(x, [a, b]'),
x -> StatsBase.corkendall(x[:, 1], x[:, 2]),
name = "CORKENDALL",
nargs = 2,
)
@info "Registering location and scale functions"
SQLite.register(
db,
@F64Vector,
(x, y) -> vcat(x, y),
x -> StatsBase.geomean(x),
name = "GEOMEAN",
)
SQLite.register(
db,
@F64Vector,
(x, y) -> vcat(x, y),
x -> StatsBase.harmmean(x),
name = "HARMMEAN",
)
SQLite.register(
db,
@F64Vector,
(x, y) -> vcat(x, y),
x -> StatsBase.mode(x),
name = "MODE",
)
# Maximum absolute deviations
SQLite.register(
db,
@F64Matrix2,
(x, a, b) -> vcat(x, [a, b]'),
x -> StatsBase.maxad(x[:, 1], x[:, 2]),
name = "MAXAD",
nargs = 2,
)
# Mean absolute deviations
SQLite.register(
db,
@F64Matrix2,
(x, a, b) -> vcat(x, [a, b]'),
x -> StatsBase.meanad(x[:, 1], x[:, 2]),
name = "MEANAD",
nargs = 2,
)
# Mean squared deviations
SQLite.register(
db,
@F64Matrix2,
(x, a, b) -> vcat(x, [a, b]'),
x -> StatsBase.msd(x[:, 1], x[:, 2]),
name = "MSD",
nargs = 2,
)
SQLite.register(
db,
@F64Vector,
(x, y) -> vcat(x, y),
x -> StatsBase.mad(x, normalize = true),
name = "MAD",
)
SQLite.register(
db,
@F64Vector,
(x, y) -> vcat(x, y),
x -> StatsBase.iqr(x),
name = "IQR",
)
@info "Registering moments"
SQLite.register(
db,
@F64Vector,
(x, y) -> vcat(x, y),
x -> StatsBase.skewness(x),
name = "SKEWNESS",
)
SQLite.register(
db,
@F64Vector,
(x, y) -> vcat(x, y),
x -> StatsBase.kurtosis(x),
name = "KURTOSIS",
)
@info "Registering weighted functions"
SQLite.register(
db,
@F64Matrix2,
(x, a, b) -> vcat(x, [a, b]'),
x -> StatsBase.mean(x[:, 1], StatsBase.weights(x[:, 2])),
name = "WMEAN",
nargs = 2,
)
SQLite.register(
db,
@F64Matrix2,
(x, a, b) -> vcat(x, [a, b]'),
x -> StatsBase.median(x[:, 1], StatsBase.weights(x[:, 2])),
name = "WMEDIAN",
nargs = 2,
)
SQLite.register(
db,
@F64Vector,
(x, y) -> vcat(x, y),
x -> StatsBase.entropy(x),
name = "ENTROPY",
)
@info "Ordinary least squares"
SQLite.register(
db,
@F64Matrix2,
(x, a, b) -> vcat(x, [a, b]'),
x -> linear_regression(x[:, 1], x[:, 2])[2],
name = "LINSLOPE",
nargs = 2,
)
SQLite.register(
db,
@F64Matrix2,
(x, a, b) -> vcat(x, [a, b]'),
x -> linear_regression(x[:, 1], x[:, 2])[1],
name = "LININTERCEPT",
nargs = 2,
)
return nothing
end
function register_dist_functions(db::SQLite.DB, verbose::Bool)::Nothing
@info "Registering R like dx(), px(), qx(), rx() distribution functions"
# qnorm, pnorm, rnorm
SQLite.register(
db,
(x, mu, sd) -> Distributions.quantile(Distributions.Normal(mu, sd), x),
name = "QNORM",
)
SQLite.register(
db,
(x, mu, sd) -> Distributions.pdf(Distributions.Normal(mu, sd), x),
name = "PNORM",
)
SQLite.register(db, (mu, sd) -> rand(Distributions.Normal(mu, sd)), name = "RNORM")
# qt, pt, rt
SQLite.register(
db,
(x, dof) -> Distributions.quantile(Distributions.TDist(dof), x),
name = "QT",
)
SQLite.register(
db,
(x, dof) -> Distributions.cdf(Distributions.TDist(dof), x),
name = "PT",
)
SQLite.register(db, (dof) -> rand(Distributions.TDist(dof)), name = "RT")
# qchisq, pchisq, rchisq
SQLite.register(
db,
(x, dof) -> Distributions.quantile(Distributions.Chisq(dof), x),
name = "QCHISQ",
)
SQLite.register(
db,
(x, dof) -> Distributions.cdf(Distributions.Chisq(dof), x),
name = "PCHISQ",
)
SQLite.register(db, (dof) -> rand(Distributions.Chisq(dof)), name = "RCHISQ")
# qf, pf, rf
SQLite.register(
db,
(x, dof1, dof2) -> Distributions.quantile(Distributions.FDist(dof1, dof2), x),
name = "QF",
)
SQLite.register(
db,
(x, dof1, dof2) -> Distributions.cdf(Distributions.FDist(dof1, dof2), x),
name = "PF",
)
SQLite.register(db, (dof1, dof2) -> rand(Distributions.FDist(dof1, dof2)), name = "RF")
# qpois, ppois, rpois
SQLite.register(
db,
(x, lambda) -> Distributions.quantile(Distributions.Poisson(lambda), x),
name = "QPOIS",
)
SQLite.register(
db,
(x, lambda) -> Distributions.cdf(Distributions.Poisson(lambda), x),
name = "PPOIS",
)
SQLite.register(db, (lambda) -> rand(Distributions.Poisson(lambda)), name = "RPOIS")
# qbinom, pbinom, rbinom
SQLite.register(
db,
(x, n, p) -> Distributions.quantile(Distributions.Binomial(n, p), x),
name = "QBINOM",
)
SQLite.register(
db,
(x, n, p) -> Distributions.cdf(Distributions.Binomial(n, p), x),
name = "PBINOM",
)
SQLite.register(db, (n, p) -> rand(Distributions.Binomial(n, p)), name = "RBINOM")
# qrunif, prunif, runif
SQLite.register(
db,
(x, a, b) -> Distributions.quantile(Distributions.Uniform(a, b), x),
name = "QUNIF",
)
SQLite.register(
db,
(x, a, b) -> Distributions.cdf(Distributions.Uniform(a, b), x),
name = "PUNIF",
)
SQLite.register(db, (a, b) -> rand(Distributions.Uniform(a, b)), name = "RUNIF")
# qexp, pexp, rexp
SQLite.register(
db,
(x, theta) -> Distributions.quantile(Distributions.Exponential(theta), x),
name = "QEXP",
)
SQLite.register(
db,
(x, theta) -> Distributions.cdf(Distributions.Exponential(theta), x),
name = "PEXP",
)
SQLite.register(db, (theta) -> rand(Distributions.Exponential(theta)), name = "REXP")
# qbeta, pbeta, rbeta
SQLite.register(
db,
(x, alpha, beta) -> Distributions.quantile(Distributions.Beta(alpha, beta), x),
name = "QBETA",
)
SQLite.register(
db,
(x, alpha, beta) -> Distributions.cdf(Distributions.Beta(alpha, beta), x),
name = "PBETA",
)
SQLite.register(
db,
(alpha, beta) -> rand(Distributions.Beta(alpha, beta)),
name = "RBETA",
)
# qcauchy, pcauchy, rcauchy
SQLite.register(
db,
(x, mu, sigma) -> Distributions.quantile(Distributions.Cauchy(mu, sigma), x),
name = "QCAUCHY",
)
SQLite.register(
db,
(x, mu, sigma) -> Distributions.cdf(Distributions.Cauchy(mu, sigma), x),
name = "PCAUCHY",
)
SQLite.register(
db,
(mu, sigma) -> rand(Distributions.Cauchy(mu, sigma)),
name = "RCAUCHY",
)
# qgamma, pgamma, rgamma
SQLite.register(
db,
(x, alpha, theta) -> Distributions.quantile(Distributions.Gamma(alpha, theta), x),
name = "QGAMMA",
)
SQLite.register(
db,
(x, alpha, theta) -> Distributions.cdf(Distributions.Gamma(alpha, theta), x),
name = "PGAMMA",
)
SQLite.register(
db,
(alpha, theta) -> rand(Distributions.Gamma(alpha, theta)),
name = "RGAMMA",
)
# qfrechet, pfrechet, rfrechet
SQLite.register(
db,
(x, alpha) -> Distributions.quantile(Distributions.Frechet(alpha), x),
name = "QFRECHET",
)
SQLite.register(
db,
(x, alpha) -> Distributions.cdf(Distributions.Frechet(alpha), x),
name = "PFRECHET",
)
SQLite.register(db, (alpha) -> rand(Distributions.Frechet(alpha)), name = "RFRECHET")
# qpareto, ppareto, rpareto
SQLite.register(
db,
(x, alpha, theta) -> Distributions.quantile(Distributions.Pareto(alpha, theta), x),
name = "QPARETO",
)
SQLite.register(
db,
(x, alpha, theta) -> Distributions.cdf(Distributions.Pareto(alpha, theta), x),
name = "PPARETO",
)
SQLite.register(
db,
(alpha, theta) -> rand(Distributions.Pareto(alpha, theta)),
name = "RPARETO",
)
# qweibull, pweibull, rweibull
SQLite.register(
db,
(x, alpha, theta) -> Distributions.quantile(Distributions.Weibull(alpha, theta), x),
name = "QWEIBULL",
)
SQLite.register(
db,
(x, alpha, theta) -> Distributions.cdf(Distributions.Weibull(alpha, theta), x),
name = "PWEIBULL",
)
SQLite.register(
db,
(alpha, theta) -> rand(Distributions.Weibull(alpha, theta)),
name = "RWEIBULL",
)
return nothing
end
function register_functions(db::SQLite.DB; verbose::Bool = false)::Nothing
# Saving the original logger and creating a local one
# if verbose == true then the minimum level is Debug
# so no output will be visible at runtime
old_logger = Logging.global_logger()
if verbose
logger = Logging.ConsoleLogger(stdout, Logging.Info)
else
logger = Logging.NullLogger()
end
Logging.global_logger(logger)
# Registering descriptive functions
register_descriptive_functions(db, verbose)
# Registering distribution functions
register_dist_functions(db, verbose)
# Registering Hypothesis Test functions
register_hypothesis_tests(db, verbose)
@info "Setting old logger as global"
Logging.global_logger(old_logger)
return nothing
end
end # module
| Sqlite3Stats | https://github.com/jbytecode/Sqlite3Stats.jl.git |
|
[
"MIT"
] | 0.1.6 | aea60d3eda027c10f838db7c57b30ed0f7041682 | code | 26474 | using Test
using Sqlite3Stats
using DataFrames
using Sqlite3Stats.SQLite
db = SQLite.DB()
Sqlite3Stats.register_functions(db)
@testset "Functions" verbose = true begin
SQLite.execute(db, "drop table if exists Numbers")
SQLite.execute(db, "create table Numbers (val float, otherval float)")
x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]
for v in x
y = 11.0 - v
SQLite.execute(db, "insert into Numbers (val, otherval) values ($(v), $(y))")
end
result = DBInterface.execute(db, "select val, otherval from Numbers") |> DataFrame
@test size(result) == (10, 2)
@testset "Q1" begin
result =
DBInterface.execute(db, "select count(val), Q1(val) as MYQ1 from Numbers") |>
DataFrame
@test result[!, "MYQ1"] == [3.25]
end
@testset "Q2" begin
result =
DBInterface.execute(db, "select count(val), Q2(val) as MYQ2 from Numbers") |>
DataFrame
@test result[!, "MYQ2"] == [5.5]
end
@testset "MEDIAN" begin
result =
DBInterface.execute(
db,
"select count(val), MEDIAN(val) as MYMEDIAN from Numbers",
) |> DataFrame
@test result[!, "MYMEDIAN"] == [5.5]
end
@testset "Q3" begin
result =
DBInterface.execute(db, "select count(val), Q3(val) as MYQ3 from Numbers") |>
DataFrame
@test result[!, "MYQ3"] == [7.75]
end
@testset "QUANTILE" begin
result =
DBInterface.execute(
db,
"select QUANTILE(val, 0.25) as MYRESULT from Numbers",
) |> DataFrame
@test result[!, "MYRESULT"] == [3.25]
result =
DBInterface.execute(
db,
"select QUANTILE(val, 0.50) as MYRESULT from Numbers",
) |> DataFrame
@test result[!, "MYRESULT"] == [5.5]
result =
DBInterface.execute(
db,
"select QUANTILE(val, 0.75) as MYRESULT from Numbers",
) |> DataFrame
@test result[!, "MYRESULT"] == [7.75]
end
@testset "COV" begin
result =
DBInterface.execute(db, "select COV(val, val) as MYCOV from Numbers") |>
DataFrame
@test result[!, "MYCOV"] == [9.166666666666666]
end
@testset "COR" begin
result =
DBInterface.execute(db, "select COR(val, val) as MYCOR from Numbers") |>
DataFrame
@test result[!, "MYCOR"] == [1.0]
result =
DBInterface.execute(db, "select COR(val, otherval) as MYCOR from Numbers") |>
DataFrame
@test result[!, "MYCOR"] == [-1.0]
end
@testset "CORSPEARMAN" begin
result =
DBInterface.execute(db, "select CORSPEARMAN(val, val) as MYCOR from Numbers") |>
DataFrame
@test result[!, "MYCOR"] == [1.0]
result =
DBInterface.execute(
db,
"select CORSPEARMAN(val, otherval) as MYCOR from Numbers",
) |> DataFrame
@test result[!, "MYCOR"] == [-1.0]
end
@testset "CORKENDALL" begin
result =
DBInterface.execute(db, "select CORKENDALL(val, val) as MYCOR from Numbers") |>
DataFrame
@test result[!, "MYCOR"] == [1.0]
result =
DBInterface.execute(
db,
"select CORKENDALL(val, otherval) as MYCOR from Numbers",
) |> DataFrame
@test result[!, "MYCOR"] == [-1.0]
end
@testset "MAD" begin
result =
DBInterface.execute(db, "select MAD(val) as MYMAD from Numbers") |> DataFrame
@test result[!, "MYMAD"] == [3.7065055462640046]
end
@testset "IQR" begin
result =
DBInterface.execute(db, "select IQR(val) as MYIQR from Numbers") |> DataFrame
@test result[!, "MYIQR"] == [4.5]
end
@testset "SKEWNESS" begin
result =
DBInterface.execute(db, "select SKEWNESS(val) as MYSKEW from Numbers") |>
DataFrame
@test result[!, "MYSKEW"] == [0.0]
end
@testset "KURTOSIS" begin
result =
DBInterface.execute(db, "select KURTOSIS(val) as MYKURT from Numbers") |>
DataFrame
@test result[!, "MYKURT"] == [-1.2242424242424244]
end
@testset "GEOMEAN" begin
result =
DBInterface.execute(db, "select GEOMEAN(val) as MYGEOMEAN from Numbers") |>
DataFrame
@test result[!, "MYGEOMEAN"] == [4.528728688116766]
end
@testset "HARMMEAN" begin
result =
DBInterface.execute(db, "select HARMMEAN(val) as MYHARMMEAN from Numbers") |>
DataFrame
@test result[!, "MYHARMMEAN"] == [3.414171521474055]
end
@testset "MODE" begin
result = DBInterface.execute(db, "select MODE(val) as m from Numbers") |> DataFrame
@test result[!, "m"] == [1.0]
result =
DBInterface.execute(db, "select MODE(otherval) as m from Numbers") |> DataFrame
@test result[!, "m"] == [10.0]
end
@testset "MAXAD" begin
result =
DBInterface.execute(db, "select MAXAD(val, val) as m from Numbers") |> DataFrame
@test result[!, "m"] == [0.0]
result =
DBInterface.execute(db, "select MAXAD(val, otherval) as m from Numbers") |>
DataFrame
@test result[!, "m"] == [9.0]
end
@testset "MEANAD" begin
result =
DBInterface.execute(db, "select MEANAD(val, val) as m from Numbers") |>
DataFrame
@test result[!, "m"] == [0.0]
result =
DBInterface.execute(db, "select MEANAD(val, otherval) as m from Numbers") |>
DataFrame
@test result[!, "m"] == [5.0]
end
@testset "MSD" begin
result =
DBInterface.execute(db, "select MSD(val, val) as m from Numbers") |> DataFrame
@test result[!, "m"] == [0.0]
result =
DBInterface.execute(db, "select MSD(val, otherval) as m from Numbers") |>
DataFrame
@test result[!, "m"] == [33.0]
end
end
@testset "Weighted Functions" verbose = true begin
SQLite.execute(db, "drop table if exists Numbers")
SQLite.execute(db, "create table Numbers (val float, w float)")
x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]
w = [
0.01818181818181818,
0.03636363636363636,
0.05454545454545454,
0.07272727272727272,
0.09090909090909091,
0.10909090909090909,
0.12727272727272726,
0.14545454545454545,
0.16363636363636364,
0.18181818181818182,
]
for i = 1:10
v = x[i]
y = w[i]
SQLite.execute(db, "insert into Numbers (val, w) values ($(v), $(y))")
end
result = DBInterface.execute(db, "select val, w from Numbers") |> DataFrame
@test size(result) == (10, 2)
@testset "WMEAN" begin
result =
DBInterface.execute(db, "select WMEAN(val, w) as MYRESULT from Numbers") |>
DataFrame
@test result[!, "MYRESULT"] == [7.0]
end
@testset "WMEDIAN" begin
result =
DBInterface.execute(db, "select WMEDIAN(val, w) as MYRESULT from Numbers") |>
DataFrame
@test result[!, "MYRESULT"] == [7.0]
end
@testset "ENTROPY" begin
result =
DBInterface.execute(db, "select ENTROPY(w) as MYRESULT from Numbers") |>
DataFrame
@test result[!, "MYRESULT"] == [2.151281720651836]
end
end
@testset "Linear Regression" verbose = true begin
SQLite.execute(db, "drop table if exists Numbers")
SQLite.execute(db, "create table Numbers (x float, y float)")
x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]
y = 2.0 .* x
for i = 1:10
u = x[i]
v = y[i]
SQLite.execute(db, "insert into Numbers (x, y) values ($(u), $(v))")
end
@testset "Raw function" begin
x = [1.0, 2.0, 3.0, 4.0, 5.0]
y = [2.0, 4.0, 6.0, 8.0, 10.0]
reg = Sqlite3Stats.linear_regression(x, y)
@test reg[1] == 0.0
@test reg[2] == 2.0
end
@testset "LINSLOPE" begin
result =
DBInterface.execute(db, "select LINSLOPE(x, y) as MYRESULT from Numbers") |>
DataFrame
@test result[!, "MYRESULT"] == [2.0]
end
@testset "LININTERCEPT" begin
result =
DBInterface.execute(db, "select LININTERCEPT(x, y) as MYRESULT from Numbers") |>
DataFrame
@test result[!, "MYRESULT"] == [0.0]
end
end
@testset "Normal Distribution" verbose = true begin
tol = 0.001
SQLite.execute(db, "drop table if exists numbers")
SQLite.execute(db, "create table numbers (NUM1 float, NUM2 float)")
for i = 1:10
a = rand()
b = rand() * 10
SQLite.execute(db, "insert into numbers(num1, num2) values ($a, $b)")
end
@testset "QNORM" begin
result =
DBInterface.execute(
db,
"select QNORM(0.025, 0, 1) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"], [-1.95996], atol=tol)
end
@testset "PNORM" begin
result =
DBInterface.execute(
db,
"select PNORM(1.9599639845400576, 0, 1) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"], [0.0584451], atol=tol)
end
@testset "RNORM" begin
result =
DBInterface.execute(
db,
"select RNORM(0, 1) as MYRESULT from numbers limit 1",
) |> DataFrame
@test result[!, "MYRESULT"][1] < 10.0
@test result[!, "MYRESULT"][1] > -10.0
end
@testset "RNORM" begin
result =
DBInterface.execute(
db,
"select RNORM(10, 1) as MYRESULT from numbers limit 1",
) |> DataFrame
@test result[!, "MYRESULT"][1] < 30.0
@test result[!, "MYRESULT"][1] > -10.0
end
end
@testset "T Distribution" verbose = true begin
tol = 0.001
SQLite.execute(db, "drop table if exists numbers")
SQLite.execute(db, "create table numbers (NUM1 float, NUM2 float)")
for i = 1:10
a = rand()
b = rand() * 10
SQLite.execute(db, "insert into numbers(num1, num2) values ($a, $b)")
end
@testset "PT" begin
result =
DBInterface.execute(
db,
"select PT(1.9599639845400576,30) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 0.970326, atol=tol)
end
@testset "QT" begin
result =
DBInterface.execute(
db,
"select QT(0.025, 30) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], -2.04227, atol=tol)
end
@testset "RT" begin
result =
DBInterface.execute(db, "select RT(30) as MYRESULT from numbers limit 1") |>
DataFrame
@test result[!, "MYRESULT"][1] < 30.0
@test result[!, "MYRESULT"][1] > -10.0
end
end
@testset "ChiSquare Distribution" verbose = true begin
tol = 0.001
SQLite.execute(db, "drop table if exists numbers")
SQLite.execute(db, "create table numbers (NUM1 float, NUM2 float)")
for i = 1:10
a = rand()
b = rand() * 10
SQLite.execute(db, "insert into numbers(num1, num2) values ($a, $b)")
end
@testset "PCHISQ" begin
result =
DBInterface.execute(
db,
"select PCHISQ(30, 30) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 0.534346, atol=tol)
end
@testset "QCHISQ" begin
result =
DBInterface.execute(
db,
"select QCHISQ(0.05, 30) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 18.4927, atol=tol)
end
@testset "RCHISQ" begin
result =
DBInterface.execute(db, "select RCHISQ(30) as MYRESULT from numbers limit 1") |>
DataFrame
@test result[!, "MYRESULT"][1] < 100.0
@test result[!, "MYRESULT"][1] >= 0.0
end
end
@testset "F Distribution" verbose = true begin
tol = 0.001
SQLite.execute(db, "drop table if exists numbers")
SQLite.execute(db, "create table numbers (NUM1 float, NUM2 float)")
for i = 1:10
a = rand()
b = rand() * 10
SQLite.execute(db, "insert into numbers(num1, num2) values ($a, $b)")
end
@testset "PF" begin
result =
DBInterface.execute(
db,
"select PF(0.1109452, 3, 5) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 0.0499999, atol=tol)
end
@testset "QF" begin
result =
DBInterface.execute(
db,
"select QF(0.05, 3, 5) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 0.1109452, atol=tol)
end
@testset "RF" begin
result =
DBInterface.execute(db, "select RF(3, 5) as MYRESULT from numbers limit 1") |>
DataFrame
@test result[!, "MYRESULT"][1] < 100.0
@test result[!, "MYRESULT"][1] >= 0.0
end
end
@testset "Poisson Distribution" verbose = true begin
tol = 0.001
SQLite.execute(db, "drop table if exists numbers")
SQLite.execute(db, "create table numbers (NUM1 float, NUM2 float)")
for i = 1:10
a = rand()
b = rand() * 10
SQLite.execute(db, "insert into numbers(num1, num2) values ($a, $b)")
end
@testset "PPOIS" begin
result =
DBInterface.execute(
db,
"select PPOIS(1000000, 1000000) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 0.5, atol=tol)
end
@testset "QPOIS" begin
result =
DBInterface.execute(
db,
"select QPOIS(0.50, 5) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 5.0, atol=tol)
end
@testset "RPOIS" begin
result =
DBInterface.execute(db, "select RPOIS(5) as MYRESULT from numbers limit 1") |>
DataFrame
@test result[!, "MYRESULT"][1] < 100.0
@test result[!, "MYRESULT"][1] >= 0.0
end
end
@testset "Binomial Distribution" verbose = true begin
tol = 0.001
SQLite.execute(db, "drop table if exists Numbers")
SQLite.execute(db, "create table numbers (NUM1 float, NUM2 float)")
for i = 1:10
a = rand()
b = rand() * 10
SQLite.execute(db, "insert into numbers(num1, num2) values ($a, $b)")
end
@testset "PBINOM" begin
result =
DBInterface.execute(
db,
"select PBINOM(5, 10, 0.5) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 0.62304687, atol=tol)
end
@testset "QBINOM" begin
result =
DBInterface.execute(
db,
"select QBINOM(0.50, 10, 0.5) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 5.0, atol=tol)
end
@testset "RBINOM" begin
result =
DBInterface.execute(
db,
"select RBINOM(10, 0.5) as MYRESULT from numbers limit 1",
) |> DataFrame
@test result[!, "MYRESULT"][1] <= 10.0
@test result[!, "MYRESULT"][1] >= 0.0
end
end
@testset "Uniform Distribution" verbose = true begin
tol = 0.001
SQLite.execute(db, "drop table if exists Numbers")
SQLite.execute(db, "create table numbers (NUM1 float, NUM2 float)")
for i = 1:10
a = rand()
b = rand() * 10
SQLite.execute(db, "insert into numbers(num1, num2) values ($a, $b)")
end
@testset "PUNIF" begin
result =
DBInterface.execute(
db,
"select PUNIF(5, 0, 10) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 0.5, atol=tol)
end
@testset "QUNIF" begin
result =
DBInterface.execute(
db,
"select QUNIF(0.5, 5, 10) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 7.5, atol=tol)
end
@testset "RUNIF" begin
result =
DBInterface.execute(
db,
"select RUNIF(0, 10) as MYRESULT from numbers limit 1",
) |> DataFrame
@test result[!, "MYRESULT"][1] <= 10.0
@test result[!, "MYRESULT"][1] >= 0.0
end
end
@testset "Exponential Distribution" verbose = true begin
tol = 0.001
SQLite.execute(db, "drop table if exists Numbers")
SQLite.execute(db, "create table numbers (NUM1 float, NUM2 float)")
for i = 1:10
a = rand()
b = rand() * 10
SQLite.execute(db, "insert into numbers(num1, num2) values ($a, $b)")
end
@testset "PEXP" begin
result =
DBInterface.execute(
db,
"select PEXP(5, 10) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 0.39346934, atol=tol)
end
@testset "QEXP" begin
result =
DBInterface.execute(
db,
"select QEXP(0.5, 10) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 6.93147180, atol=tol)
end
@testset "REXP" begin
result =
DBInterface.execute(db, "select REXP(10.0) as MYRESULT from numbers limit 1") |>
DataFrame
@test result[!, "MYRESULT"][1] <= 100.0
@test result[!, "MYRESULT"][1] >= 0.0
end
end
@testset "Beta Distribution" verbose = true begin
tol = 0.001
SQLite.execute(db, "drop table if exists Numbers")
SQLite.execute(db, "create table numbers (NUM1 float, NUM2 float)")
for i = 1:10
a = rand()
b = rand() * 10
SQLite.execute(db, "insert into numbers(num1, num2) values ($a, $b)")
end
@testset "PBETA" begin
result =
DBInterface.execute(
db,
"select PBETA(0.5, 0.12, 1) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 0.92018, atol=tol)
end
@testset "QBETA" begin
result =
DBInterface.execute(
db,
"select QBETA(0.5, 0.12, 1) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 0.00310, atol=tol)
end
@testset "RBETA" begin
result =
DBInterface.execute(
db,
"select RBETA(0.12, 1.0) as MYRESULT from numbers limit 1",
) |> DataFrame
@test result[!, "MYRESULT"][1] <= 1.0
@test result[!, "MYRESULT"][1] >= 0.0
end
end
@testset "Cauchy Distribution" verbose = true begin
tol = 0.001
SQLite.execute(db, "drop table if exists Numbers")
SQLite.execute(db, "create table numbers (NUM1 float, NUM2 float)")
for i = 1:10
a = rand()
b = rand() * 10
SQLite.execute(db, "insert into numbers(num1, num2) values ($a, $b)")
end
@testset "PCAUCHY" begin
result =
DBInterface.execute(
db,
"select PCAUCHY(0, 0, 1) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 0.5, atol=tol)
end
@testset "QCAUCHY" begin
result =
DBInterface.execute(
db,
"select QCAUCHY(0.05, 0, 1) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], -6.313751, atol=tol)
end
@testset "RCAUCHY" begin
result =
DBInterface.execute(
db,
"select RCAUCHY(0, 1) as MYRESULT from numbers limit 1",
) |> DataFrame
@test result[!, "MYRESULT"][1] isa Number
end
end
@testset "Gamma Distribution" verbose = true begin
tol = 0.001
SQLite.execute(db, "drop table if exists Numbers")
SQLite.execute(db, "create table numbers (NUM1 float, NUM2 float)")
for i = 1:10
a = rand()
b = rand() * 10
SQLite.execute(db, "insert into numbers(num1, num2) values ($a, $b)")
end
@testset "PGAMMA" begin
result =
DBInterface.execute(
db,
"select PGAMMA(0.75, 0.5, 1.0) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 0.7793286380801532, atol=tol)
end
@testset "QGAMMA" begin
result =
DBInterface.execute(
db,
"select QGAMMA(0.05, 0.5, 1) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 0.0019660700000097625, atol=tol)
end
@testset "RGAMMA" begin
result =
DBInterface.execute(
db,
"select RGAMMA(0.5, 1) as MYRESULT from numbers limit 1",
) |> DataFrame
@test result[!, "MYRESULT"][1] isa Number
@test result[!, "MYRESULT"][1] <= 15.0
end
end
@testset "Frechet Distribution" verbose = true begin
tol = 0.001
SQLite.execute(db, "drop table if exists Numbers")
SQLite.execute(db, "create table numbers (NUM1 float, NUM2 float)")
for i = 1:10
a = rand()
b = rand() * 10
SQLite.execute(db, "insert into numbers(num1, num2) values ($a, $b)")
end
# alpha = 3
# x = 0.5
@testset "PFRECHET" begin
result =
DBInterface.execute(
db,
"select PFRECHET(1.1299472763373901, 3) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 0.5, atol=tol)
end
@testset "QFRECHET" begin
result =
DBInterface.execute(
db,
"select QFRECHET(0.5, 3) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 1.1299472763373901, atol=tol)
end
@testset "RFRECHET" begin
result =
DBInterface.execute(
db,
"select RFRECHET(3) as MYRESULT from numbers limit 1",
) |> DataFrame
@test result[!, "MYRESULT"][1] isa Number
@test result[!, "MYRESULT"][1] >= 0.0
end
end
@testset "Pareto Distribution" verbose = true begin
tol = 0.001
SQLite.execute(db, "drop table if exists Numbers")
SQLite.execute(db, "create table numbers (NUM1 float, NUM2 float)")
for i = 1:10
a = rand()
b = rand() * 10
SQLite.execute(db, "insert into numbers(num1, num2) values ($a, $b)")
end
# alpha = 3
# x = 0.5
@testset "PPARETO" begin
result =
DBInterface.execute(
db,
"select PPARETO(2, 1, 1) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 0.5, atol=tol)
end
@testset "QPARETO" begin
result =
DBInterface.execute(
db,
"select QPARETO(0.5, 1, 1) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 2, atol=tol)
end
@testset "RPARETO" begin
result =
DBInterface.execute(
db,
"select RPARETO(1, 1) as MYRESULT from numbers limit 1",
) |> DataFrame
@test result[!, "MYRESULT"][1] isa Number
@test result[!, "MYRESULT"][1] >= 1.0
end
end
@testset "Weibull Distribution" verbose = true begin
tol = 0.001
SQLite.execute(db, "drop table if exists Numbers")
SQLite.execute(db, "create table numbers (NUM1 float, NUM2 float)")
for i = 1:10
a = rand()
b = rand() * 10
SQLite.execute(db, "insert into numbers(num1, num2) values ($a, $b)")
end
# alpha = 3
# x = 0.5
@testset "PWEIBULL" begin
result =
DBInterface.execute(
db,
"select PWEIBULL(1, 1, 1) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 0.6321205588285577, atol=tol)
end
@testset "QWEIBULL" begin
result =
DBInterface.execute(
db,
"select QWEIBULL(0.6321205588285577, 1, 1) as MYRESULT from numbers limit 1",
) |> DataFrame
@test isapprox(result[!, "MYRESULT"][1], 1.0, atol=tol)
end
@testset "RWEIBULL" begin
result =
DBInterface.execute(
db,
"select RWEIBULL(1, 1) as MYRESULT from numbers limit 1",
) |> DataFrame
@test result[!, "MYRESULT"][1] isa Number
@test result[!, "MYRESULT"][1] >= 0.0
end
end
@testset "Hypothesis Tests" verbose = true begin
@testset "Jarque-Bera test for normality" begin
SQLite.execute(db, "drop table if exists Numbers")
SQLite.execute(db, "create table Numbers (val float)")
x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]
for i = 1:10
v = x[i]
SQLite.execute(db, "insert into Numbers (val) values ($(v))")
end
result = DBInterface.execute(db, "select JB(val) as myjb from Numbers") |> DataFrame
@test result[!, "myjb"] == [0.7318032036735493]
end
end
| Sqlite3Stats | https://github.com/jbytecode/Sqlite3Stats.jl.git |
|
[
"MIT"
] | 0.1.6 | aea60d3eda027c10f838db7c57b30ed0f7041682 | docs | 2079 | # 0.1.7 (Upcoming Release)
# 0.1.6
- Update tests
# 0.1.5
- Update compatibility entries for StatsBase
# v0.1.4
- Add HypothesisTests as dependency
- Implement Jarque-Bera test for normality
- Update documentation
# v0.1.3
- QWEIBULL, PWEIBULL, and RWEIBULL implemented for Weibull Distribution
- Registering functions are refactored
# v0.1.2
- QGAMMA, PGAMMA, and RGAMMA implemented for Gamma Distribution
- QFRECHET, PQFRECHET, RQFRECHET implemented for Frechet Distribution
- QPARETO, PPARETO, RPARETO implemented for Pareto Distribution
# v0.1.1
- Macro definitions for array and matrix initialization
- Logging system
# v0.1.0
- QCAUCHY (quantile in Cauchy Distribution)
- PCAUCHY (probability in Cauchy Distribution)
- RCAUCHY (quantiles in Cauchy Distribution)
- QBETA (quantile in Beta Distribution)
- PBETA (probability in Beta Distribution)
- RBETA (quantiles in Beta Distribution)
- QEXP (quantile in Exponential Distribution)
- PEXP (probability in Exponential Distribution)
- REXP (quantiles in Exponential Distribution)
- QUNIF (quantile in Uniform Distribution)
- PUNIF (probability in Uniform Distribution)
- RUNIF (quantiles in Uniform Distribution)
- QBINOM (quantile in Binomial Distribution)
- PBINOM (probability in Binomial Distribution)
- RBINOM (quantiles in Binomial Distribution)
- QPOIS (quantile in Poisson Distribution)
- PPOIS (probability in Poisson Distribution)
- RPOIS (quantiles in Poisson Distribution)
- QF (quantile in F Distribution)
- PF (probability in F Distribution)
- RF (quantiles in F Distribution)
- QCHISQ (quantile in Chisquare Distribution)
- PCHISQ (probability in Chisquare Distribution)
- RCHISQ (quantiles in Chisquare Distribution)
- QT (quantile in Student's T Distribution)
- PT (probability in Student's T Distribution)
- RT (quantiles in Student's T Distribution)
- Added Distributions as a dependency
- QNORM
- PNORM
- RNORM
- LINSLOPE and LININTERCEPT for linear regression y = intercept + slope x
- Initial package
- Quartiles, mean, median, etc.
- Weighted versions of mean and median
- QUARTILE
- ENTROPY
| Sqlite3Stats | https://github.com/jbytecode/Sqlite3Stats.jl.git |
|
[
"MIT"
] | 0.1.6 | aea60d3eda027c10f838db7c57b30ed0f7041682 | docs | 6957 | [](https://jbytecode.github.io/Sqlite3Stats.jl/dev/)
[](https://codecov.io/gh/jbytecode/Sqlite3Stats.jl)
# Sqlite3Stats
Injecting StatsBase functions into any SQLite database in Julia.
# In Short
Makes it possible to call
```sql
select MEDIAN(fieldname) from tablename
```
in Julia where median is defined in Julia and related packages and the function is *injected* to use within SQLite. **Database file is not modified**.
# Installation
```julia
julia> using Pkg
julia> Pkg.add("Sqlite3Stats")
```
# Simple use
```julia
using SQLite
using Sqlite3Stats
using DataFrames
# Any SQLite database
# In our case, it is dbfile.db
db = SQLite.DB("dbfile.db")
# Injecting functions
Sqlite3Stats.register_functions(db)
```
# Registered Functions and Examples
```Julia
using SQLite
using Sqlite3Stats
using DataFrames
db = SQLite.DB("dbfile.db")
# Injecting functions
Sqlite3Stats.register_functions(db)
# 1st Quartile
result = DBInterface.execute(db, "select Q1(num) from table") |> DataFrame
# 2st Quartile
result = DBInterface.execute(db, "select Q2(num) from table") |> DataFrame
# Median (Equals to Q2)
result = DBInterface.execute(db, "select MEDIAN(num) from table") |> DataFrame
# 3rd Quartile
result = DBInterface.execute(db, "select Q3(num) from table") |> DataFrame
# QUANTILE
result = DBInterface.execute(db, "select QUANTILE(num, 0.25) from table") |> DataFrame
result = DBInterface.execute(db, "select QUANTILE(num, 0.50) from table") |> DataFrame
result = DBInterface.execute(db, "select QUANTILE(num, 0.75) from table") |> DataFrame
# Covariance
result = DBInterface.execute(db, "select COV(num, other) from table") |> DataFrame
# Pearson Correlation
result = DBInterface.execute(db, "select COR(num, other) from table") |> DataFrame
# Spearman Correlation
result = DBInterface.execute(db, "select SPEARMANCOR(num, other) from table") |> DataFrame
# Kendall Correlation
result = DBInterface.execute(db, "select KENDALLCOR(num, other) from table") |> DataFrame
# Median Absolute Deviations
result = DBInterface.execute(db, "select MAD(num) from table") |> DataFrame
# Inter-Quartile Range
result = DBInterface.execute(db, "select IQR(num) from table") |> DataFrame
# Skewness
result = DBInterface.execute(db, "select SKEWNESS(num) from table") |> DataFrame
# Kurtosis
result = DBInterface.execute(db, "select KURTOSIS(num) from table") |> DataFrame
# Geometric Mean
result = DBInterface.execute(db, "select GEOMEAN(num) from table") |> DataFrame
# Harmonic Mean
result = DBInterface.execute(db, "select HARMMEAN(num) from table") |> DataFrame
# Maximum absolute deviations
result = DBInterface.execute(db, "select MAXAD(num) from table") |> DataFrame
# Mean absolute deviations
result = DBInterface.execute(db, "select MEANAD(num) from table") |> DataFrame
# Mean squared deviations
result = DBInterface.execute(db, "select MSD(num) from table") |> DataFrame
# Mode
result = DBInterface.execute(db, "select MODE(num) from table") |> DataFrame
# WMEAN for weighted mean
result = DBInterface.execute(db, "select WMEAN(num, weights) from table") |> DataFrame
# WMEDIAN for weighted mean
result = DBInterface.execute(db, "select WMEDIAN(num, weights) from table") |> DataFrame
# Entropy
result = DBInterface.execute(db, "select ENTROPY(probs) from table") |> DataFrame
# Slope (a) of linear regression y = b + ax
result = DBInterface.execute(db, "select LINSLOPE(x, y) from table") |> DataFrame
# Intercept (b) of linear regression y = b + ax
result = DBInterface.execute(db, "select LININTERCEPT(x, y) from table") |> DataFrame
```
# Well-known Probability Related Functions
This family of functions implement QXXX(), PXXX(), and RXXX() for a probability density or mass function XXX. Q for quantile, p for propability or cdf value, R for random number.
`QNORM(p, mean, stddev)` returns the quantile value $q$
whereas
`PNORM(q, mean, stddev)` returns $p$ using the equation
$$
\int_{-\infty}^{q} f(x; \mu, \sigma)dx = p
$$
and `RNORM(mean, stddev)` draws a random number from a Normal distribution with mean `mean` ( $\mu$ ) and standard deviation `stddev` ( $\sigma$ ) which is defined as
$$
f(x; \mu, \sigma) = \frac{1}{\sigma\sqrt{2\pi}} e^{-\frac{1}{2} (\frac{x-\mu}{\sigma})^2}
$$
and $-\infty < x < \infty$.
```julia
# Quantile of Normal Distribution with mean 0 and standard deviation 1
result = DBInterface.execute(db, "select QNORM(0.025, 0.0, 1.0) from table") |> DataFrame
# Probability of Normal Distribution with mean 0 and standard deviation 1
result = DBInterface.execute(db, "select PNORM(-1.96, 0.0, 1.0) from table") |> DataFrame
# Random number drawn from a Normal Distribution with mean * and standard deviation 1
result = DBInterface.execute(db, "select RNORM(0.0, 1.0) from table") |> DataFrame
```
# Other functions for distributions
Note that Q, P, and R prefix correspond to Quantile, CDF (Probability), and Random (number), respectively.
- `QT(x, dof)`, `PT(x, dof)`, `RT(dof)` for Student-T Distribution
- `QCHISQ(x, dof)`, `PCHISQ(x, dof)`, `RCHISQ(dof)` for ChiSquare Distribution
- `QF(x, dof1, dof2)`, `PF(x, dof1, dof2)`, `RF(dof1, dof2)` for F Distribution
- `QPOIS(x, lambda)`,`RPOIS(x, lambda)`, `RPOIS(lambda)` for Poisson Distribution
- `QBINOM(x, n, p)`, `PBINOM(x, n, p)`, `RBINOM(n, p)` for Binomial Distribution
- `QUNIF(x, a, b)`, `PUNIF(x, a, b)`, `RUNIF(a, b)` for Uniform Distribution
- `QEXP(x, theta)`, `PEXP(x, theta)`, `REXP(theta)` for Exponential Distribution
- `QBETA(x, alpha, beta)`, `PGAMMA(x, alpha, beta)`, `RGAMMA(alpha, beta)` for Beta Distribution
- `QCAUCHY(x, location, scale)`, `PCAUCHY(x, location, scale)`, `RCAUCHY(location, scale)` for Cauchy Distribution
- `QGAMMA(x, alpha, theta)`, `PGAMMA(x, alpha, theta)`, `RGAMMA(alpha, theta)` for Gamma Distribution
- `QFRECHET(x, alpha)`, `PFRECHET(x, alpha)`, `RFRECHET(alpha)` for Frechet Distribution
- `QPARETO(x, alpha, theta)`, `PPARETO(x, alpha, theta)`, `RPARETO(alpha, theta)` for Pareto Distribution
- `QWEIBULL(x, alpha, theta)`, `PWEIBULL(x, alpha, theta)`, `RWEIBULL(alpha, theta)` for Weibull Distribution
# Hypothesis Tests
- `JB(x)` for Jarque-Bera Normality Test (returns the p-value)
# The Logic
The package mainly uses the ```register``` function. For example, a single variable
function ```MEDIAN``` is registered as
```julia
SQLite.register(db, [],
(x,y) -> vcat(x, y),
x -> StatsBase.quantile(x, 0.50),
name = "MEDIAN")
```
whereas, the two-variable function ```COR``` is registered as
```julia
SQLite.register(db, Array{Float64, 2}(undef, (0, 2)),
(x, a, b) -> vcat(x, [a, b]'),
x -> StatsBase.cor(x[:,1], x[:,2]),
name = "COR", nargs = 2)
```
for Pearson's correlation coefficient.
| Sqlite3Stats | https://github.com/jbytecode/Sqlite3Stats.jl.git |
|
[
"MIT"
] | 0.1.6 | aea60d3eda027c10f838db7c57b30ed0f7041682 | docs | 588 | # API references
## The Logic
The package mainly uses the ```register``` function. For example, a single variable
function ```MEDIAN``` is registered as
```julia
SQLite.register(db, [],
(x,y) -> vcat(x, y),
x -> StatsBase.quantile(x, 0.50),
name = "MEDIAN")
```
whereas, the two-variable function ```COR``` is registered as
```julia
SQLite.register(db, Array{Float64, 2}(undef, (0, 2)),
(x, a, b) -> vcat(x, [a, b]'),
x -> StatsBase.cor(x[:,1], x[:,2]),
name = "COR", nargs = 2)
```
for Pearson's correlation coefficient.
| Sqlite3Stats | https://github.com/jbytecode/Sqlite3Stats.jl.git |
|
[
"MIT"
] | 0.1.6 | aea60d3eda027c10f838db7c57b30ed0f7041682 | docs | 5863 | # Examples
## Registered Functions
Firstly, import libraries to read and manipulate the interest database.
```Julia
using Sqlite3Stats
using SQLite
using DataFrames
```
Now, open a database file.
```julia
db = SQLite.DB("dbfile.db")
```
More information about the injecting functions can be obtained as follows.
```julia
Sqlite3Stats.register_functions(db)
```
## Obtaining Quartiles
```julia
# 1st Quartile
result = DBInterface.execute(db, "select Q1(num) from table") |> DataFrame
# 2st Quartile
result = DBInterface.execute(db, "select Q2(num) from table") |> DataFrame
# Median (Equals to Q2)
result = DBInterface.execute(db, "select MEDIAN(num) from table") |> DataFrame
# 3rd Quartile
result = DBInterface.execute(db, "select Q3(num) from table") |> DataFrame
# QUANTILE
result = DBInterface.execute(db, "select QUANTILE(num, 0.25) from table") |> DataFrame
result = DBInterface.execute(db, "select QUANTILE(num, 0.50) from table") |> DataFrame
result = DBInterface.execute(db, "select QUANTILE(num, 0.75) from table") |> DataFrame
```
## Covariance and Correlation
```julia
# Covariance
result = DBInterface.execute(db, "select COV(num, other) from table") |> DataFrame
# Pearson Correlation
result = DBInterface.execute(db, "select COR(num, other) from table") |> DataFrame
# Spearman Correlation
result = DBInterface.execute(db, "select SPEARMANCOR(num, other) from table") |> DataFrame
# Kendall Correlation
result = DBInterface.execute(db, "select KENDALLCOR(num, other) from table") |> DataFrame
# Median Absolute Deviations
result = DBInterface.execute(db, "select MAD(num) from table") |> DataFrame
# Inter-Quartile Range
result = DBInterface.execute(db, "select IQR(num) from table") |> DataFrame
# Skewness
result = DBInterface.execute(db, "select SKEWNESS(num) from table") |> DataFrame
```
## Kurtosis, Mean and Standard Deviation
```julia
# Kurtosis
result = DBInterface.execute(db, "select KURTOSIS(num) from table") |> DataFrame
# Geometric Mean
result = DBInterface.execute(db, "select GEOMEAN(num) from table") |> DataFrame
# Harmonic Mean
result = DBInterface.execute(db, "select HARMMEAN(num) from table") |> DataFrame
# Maximum absolute deviations
result = DBInterface.execute(db, "select MAXAD(num) from table") |> DataFrame
# Mean absolute deviations
result = DBInterface.execute(db, "select MEANAD(num) from table") |> DataFrame
# Mean squared deviations
result = DBInterface.execute(db, "select MSD(num) from table") |> DataFrame
# Mode
result = DBInterface.execute(db, "select MODE(num) from table") |> DataFrame
# WMEAN for weighted mean
result = DBInterface.execute(db, "select WMEAN(num, weights) from table") |> DataFrame
# WMEDIAN for weighted mean
result = DBInterface.execute(db, "select WMEDIAN(num, weights) from table") |> DataFrame
```
## Entropy
```julia
result = DBInterface.execute(db, "select ENTROPY(probs) from table") |> DataFrame
```
## Slope (a) of linear regression y = b + ax
```julia
result = DBInterface.execute(db, "select LINSLOPE(x, y) from table") |> DataFrame
```
## Intercept (b) of linear regression y = b + ax
```julia
result = DBInterface.execute(db, "select LININTERCEPT(x, y) from table") |> DataFrame
```
## Well-known Probability Related Functions
This family of functions implement QXXX(), PXXX(), and RXXX() for a probability density or mass function XXX. Q for quantile, p for propability or cdf value, R for random number.
`QNORM(p, mean, stddev)` returns the quantile value $q$
whereas
`PNORM(q, mean, stddev)` returns $p$ using the equation
$$
\int_{-\infty}^{q} f(x; \mu, \sigma)dx = p
$$
and `RNORM(mean, stddev)` draws a random number from a Normal distribution with mean `mean` ( $\mu$ ) and standard deviation `stddev` ( $\sigma$ ) which is defined as
$$
f(x; \mu, \sigma) = \frac{1}{\sigma\sqrt{2\pi}} e^{-\frac{1}{2} (\frac{x-\mu}{\sigma})^2}
$$
and $-\infty < x < \infty$.
```julia
# Quantile of Normal Distribution with mean 0 and standard deviation 1
result = DBInterface.execute(db, "select QNORM(0.025, 0.0, 1.0) from table") |> DataFrame
# Probability of Normal Distribution with mean 0 and standard deviation 1
result = DBInterface.execute(db, "select PNORM(-1.96, 0.0, 1.0) from table") |> DataFrame
# Random number drawn from a Normal Distribution with mean * and standard deviation 1
result = DBInterface.execute(db, "select RNORM(0.0, 1.0) from table") |> DataFrame
```
## Other functions for distributions
Note that Q, P, and R prefix correspond to Quantile, CDF (Probability), and Random (number), respectively.
- `QT(x, dof)`, `PT(x, dof)`, `RT(dof)` for Student-T Distribution
- `QCHISQ(x, dof)`, `PCHISQ(x, dof)`, `RCHISQ(dof)` for ChiSquare Distribution
- `QF(x, dof1, dof2)`, `PF(x, dof1, dof2)`, `RF(dof1, dof2)` for F Distribution
- `QPOIS(x, lambda)`,`RPOIS(x, lambda)`, `RPOIS(lambda)` for Poisson Distribution
- `QBINOM(x, n, p)`, `PBINOM(x, n, p)`, `RBINOM(n, p)` for Binomial Distribution
- `QUNIF(x, a, b)`, `PUNIF(x, a, b)`, `RUNIF(a, b)` for Uniform Distribution
- `QEXP(x, theta)`, `PEXP(x, theta)`, `REXP(theta)` for Exponential Distribution
- `QBETA(x, alpha, beta)`, `PGAMMA(x, alpha, beta)`, `RGAMMA(alpha, beta)` for Beta Distribution
- `QCAUCHY(x, location, scale)`, `PCAUCHY(x, location, scale)`, `RCAUCHY(location, scale)` for Cauchy Distribution
- `QGAMMA(x, alpha, theta)`, `PGAMMA(x, alpha, theta)`, `RGAMMA(alpha, theta)` for Gamma Distribution
- `QFRECHET(x, alpha)`, `PFRECHET(x, alpha)`, `RFRECHET(alpha)` for Frechet Distribution
- `QPARETO(x, alpha, theta)`, `PPARETO(x, alpha, theta)`, `RPARETO(alpha, theta)` for Pareto Distribution
- `QWEIBULL(x, alpha, theta)`, `PWEIBULL(x, alpha, theta)`, `RWEIBULL(alpha, theta)` for Weibull Distribution
## Hypothesis Tests
- `JB(x)` for Jarque-Bera Normality Test (returns the p-value)
| Sqlite3Stats | https://github.com/jbytecode/Sqlite3Stats.jl.git |
|
[
"MIT"
] | 0.1.6 | aea60d3eda027c10f838db7c57b30ed0f7041682 | docs | 630 | # Sqlite3Stats.jl
Injecting StatsBase functions into any SQLite database in Julia.
## In Short
Makes it possible to call
```sql
select MEDIAN(fieldname) from tablename
```
in Julia where median is defined in Julia and related packages and the function is *injected* to use within SQLite. **Database file is not modified**.
## Installation
```julia
julia> using Pkg
julia> Pkg.add("Sqlite3Stats")
```
## Simple use
```julia
using SQLite
using Sqlite3Stats
using DataFrames
# Any SQLite database
# In our case, it is dbfile.db
db = SQLite.DB("dbfile.db")
# Injecting functions
Sqlite3Stats.register_functions(db)
```
| Sqlite3Stats | https://github.com/jbytecode/Sqlite3Stats.jl.git |
|
[
"MIT"
] | 0.4.2 | 55f90977e998403f56c1f6abab13fb67c32b35b9 | code | 422 |
using FluxExtra, Documenter
makedocs(modules=[FluxExtra,FluxExtra.Normalizations],
sitename = "FluxExtra.jl",
pages = ["Home" => "index.md",
"Layers" => "layers.md",
"Functions" => "functions.md"],
authors = "Open Machine Learning Association",
format = Documenter.HTML(prettyurls = false)
)
deploydocs(
repo = "github.com/OML-NPA/FluxExtra.jl.git",
devbranch = "main"
)
| FluxExtra | https://github.com/OML-NPA/FluxExtra.jl.git |
|
[
"MIT"
] | 0.4.2 | 55f90977e998403f56c1f6abab13fb67c32b35b9 | code | 180 | module FluxExtra
using Flux, Statistics
include("layers.jl")
include("Normalizations.jl")
export Join, Split, Addition, Activation, Flatten, Identity
export Normalizations
end
| FluxExtra | https://github.com/OML-NPA/FluxExtra.jl.git |
|
[
"MIT"
] | 0.4.2 | 55f90977e998403f56c1f6abab13fb67c32b35b9 | code | 4124 |
module Normalizations
using Statistics
function norm_range!(data::T,min_vals::T, max_vals::T,new_min::F,new_max::F) where {F<:AbstractFloat,N,T<:Array{F,N}}
data .= ((data .- min_vals)./(max_vals .- min_vals)).*(new_max .- new_min) .+ new_min
return nothing
end
function norm_range!(data::Vector{T},new_min::F,new_max::F) where {F<:AbstractFloat,N,T<:Array{F,N}}
num = size(data[1],N)
min_vals = T(undef,ntuple(x->1,Val(N-1))...,num)
max_vals = T(undef,ntuple(x->1,Val(N-1))...,num)
for i = 1:num
min_vals[i] = minimum(cat(selectdim.(data, N, i)...,dims=Val(N)))
max_vals[i] = maximum(cat(selectdim.(data, N, i)...,dims=Val(N)))
end
map(x -> norm_range!(x,min_vals, max_vals,new_min,new_max), data)
return min_vals, max_vals
end
"""
norm_01!(data::T,min_vals::T, max_vals::T) where {F<:AbstractFloat,N,T<:Array{F,N}}
Rescales each feature (last dimension) to be in the range [0,1].
"""
function norm_01!(data::T,min_vals::T, max_vals::T) where {F<:AbstractFloat,N,T<:Array{F,N}}
norm_range!(data,min_vals, max_vals,zero(F),one(F))
return nothing
end
"""
norm_01!(data::Vector{T}) where {F<:AbstractFloat,N,T<:Array{F,N}}
Rescales each feature (last dimension) to be in the range [0,1]. Returns min and max values for each feature.
"""
function norm_01!(data::Vector{T}) where {F<:AbstractFloat,N,T<:Array{F,N}}
min_vals, max_vals = norm_range!(data,zero(F),one(F))
return min_vals, max_vals
end
"""
norm_negpos1(data::T,min_vals::T,max_vals::T) where {F<:AbstractFloat,N,T<:Array{F,N}}
Rescales each feature (last dimension) to be in the range [-1,1].
"""
function norm_negpos1!(data::T,min_vals::T,max_vals::T) where {F<:AbstractFloat,N,T<:Array{F,N}}
norm_range!(data,min_vals, max_vals,-one(F),one(F))
return nothing
end
"""
norm_negpos1(data::Vector{T}) where {F<:AbstractFloat,N,T<:Array{F,N}}
Rescales each feature (last dimension) to be in the range [-1,1]. Returns min and max values for each feature.
"""
function norm_negpos1!(data::Vector{T}) where {F<:AbstractFloat,N,T<:Array{F,N}}
min_vals, max_vals = norm_range!(data,-one(F),one(F))
return min_vals, max_vals
end
"""
norm_zerocenter!(data::T,mean_vals::T) where {F<:AbstractFloat,N,T<:Array{F,N}}
Subtracts the mean of each feature (last dimension).
"""
function norm_zerocenter!(data::T,mean_vals::T) where {N,T<:Array{<:AbstractFloat,N}}
data .= data .- mean_vals
return nothing
end
"""
norm_zerocenter!(data::Vector{T}) where {F<:AbstractFloat,N,T<:Array{F,N}}
Subtracts the mean of each feature (last dimension). Returns a mean value for each feature.
"""
function norm_zerocenter!(data::Vector{T}) where {N,T<:Array{<:AbstractFloat,N}}
num = size(data[1],N)
mean_vals = T(undef,ntuple(x->1,Val(N-1))...,num)
for i = 1:num
mean_vals[i] = mean(cat(selectdim.(data, N, i)...,dims=Val(N)))
end
map(x -> norm_zerocenter!(x,mean_vals), data)
return mean_vals
end
"""
norm_zscore!(data::T,mean_vals::T,std_vals::T) where {F<:AbstractFloat,N,T<:Array{F,N}}
Subtracts the mean and divides by the standard deviation of each feature (last dimension).
"""
function norm_zscore!(data::T,mean_vals::T,std_vals::T) where {N,T<:Array{<:AbstractFloat,N}}
data .= (data .- mean_vals)./std_vals
return nothing
end
"""
norm_zscore!(data::Vector{T}) where {F<:AbstractFloat,N,T<:Array{F,N}}
Subtracts the mean and divides by the standard deviation of each feature (last dimension).
Returns mean and standard deviation values for each feature.
"""
function norm_zscore!(data::Vector{T}) where {N,T<:Array{<:AbstractFloat,N}}
num = size(data[1],N)
mean_vals = T(undef,ntuple(x->1,Val(N-1))...,num)
std_vals = T(undef,ntuple(x->1,Val(N-1))...,num)
for i = 1:num
mean_vals[i] = mean(cat(selectdim.(data, N, i)...,dims=Val(N)))
std_vals[i] = std(cat(selectdim.(data, N, i)...,dims=Val(N)))
end
map(x -> norm_zscore!(x,mean_vals,std_vals), data)
return mean_vals, std_vals
end
export norm_01!, norm_negpos1!, norm_zerocenter!, norm_zscore!
end | FluxExtra | https://github.com/OML-NPA/FluxExtra.jl.git |
|
[
"MIT"
] | 0.4.2 | 55f90977e998403f56c1f6abab13fb67c32b35b9 | code | 3983 |
# Join layer
"""
Join(dim::Int64)
Join(dim = dim::Int64)
Concatenates a tuple of arrays along a dimension `dim`. A convenient and type stable way of using `x -> cat(x..., dims = dim)`.
"""
struct Join{D}
dim::Int64
function Join(dim)
if dim>3
throw(DimensionMismatch("Dimension should be 1, 2 or 3."))
end
new{dim}(dim)
end
function Join(;dim)
if dim>3
throw(DimensionMismatch("Dimension should be 1, 2 or 3."))
end
new{dim}(dim)
end
end
(m::Join{D})(x::NTuple{N,AbstractArray}) where {D,N} = cat(x...,dims = Val(D))
function Base.show(io::IO, l::Join)
print(io, "Join(", "dim = ",l.dim, ")")
end
# Split layer
"""
Split(outputs::Int64, dim::Int64)
Split(outputs::Int64, dim = dim::Int64)
Breaks an array into a number of arrays which is equal to `outputs` along a dimension `dim`. `dim` should we divisible by `outputs` without a remainder.
"""
struct Split{O,D}
outputs::Int64
dim::Int64
function Split(outputs,dim)
if dim>3
throw(DimensionMismatch("Dimension should be 1, 2 or 3."))
elseif outputs<2
throw(DomainError(outputs, "The number of outputs should be 2 or more."))
end
new{outputs,dim}(outputs,dim)
end
function Split(outputs;dim)
if dim>3
throw(DimensionMismatch("Dimension should be 1, 2 or 3."))
elseif outputs<2
throw(DomainError(outputs, "The number of outputs should be 2 or more."))
end
new{outputs,dim}(outputs,dim)
end
end
function Split_func(x::T,m::Split{O,D}) where {O,D,T<:AbstractArray{<:AbstractFloat,2}}
if D!=1
throw(DimensionMismatch("Dimension should be 1."))
end
step_var = Int64(size(x, D) / O)
f = i::Int64 -> (1+(i-1)*step_var):(i)*step_var
vals = ntuple(i -> i, O)
inds_vec = map(f,vals)
x_out = map(inds -> x[inds,:],inds_vec)
return x_out
end
function get_part(x::T,inds::NTuple{O,UnitRange{Int64}},d::Type{Val{1}}) where {O,T<:AbstractArray{<:AbstractFloat,4}}
x_out = map(inds -> x[inds,:,:,:],inds)
end
function get_part(x::T,inds::NTuple{O,UnitRange{Int64}},d::Type{Val{2}}) where {O,T<:AbstractArray{<:AbstractFloat,4}}
x_out = map(inds -> x[:,inds,:,:],inds)
end
function get_part(x::T,inds::NTuple{O,UnitRange{Int64}},d::Type{Val{3}}) where {O,T<:AbstractArray{<:AbstractFloat,4}}
x_out = map(inds -> x[:,:,inds,:],inds)
end
function Split_func(x::T,m::Split{O,D}) where {O,D,T<:AbstractArray{<:AbstractFloat,4}}
step_var = Int64(size(x, D) / O)
f = i::Int64 -> (1+(i-1)*step_var):(i)*step_var
vals = ntuple(i -> i, O)
inds_tuple = map(f,vals)
x_out = get_part(x,inds_tuple,Val{D})
return x_out
end
(m::Split{O,D})(x::T) where {O,D,T<:AbstractArray} = Split_func(x,m)
function Base.show(io::IO, l::Split)
print(io, "Split(", l.outputs,", dim = ",l.dim, ")")
end
# Makes Parallel layer type stable when used after Split
(m::Parallel)(xs::NTuple{N,AbstractArray}) where N = map((f,x) -> f(x), m.layers,xs)
# Addition layer
"""
Addition()
A convenient way of using `x -> sum(x)`.
"""
struct Addition
end
(m::Addition)(x::NTuple{N,AbstractArray}) where N = sum(x)
# Activation layer
"""
Activation(f::Function)
A convenient way of using `x -> f(x)`.
"""
struct Activation{F}
f::F
Activation(f::Function) = new{typeof(f)}(f)
end
(m::Activation{F})(x::AbstractArray) where F = m.f.(x)
function Base.show(io::IO, l::Activation)
print(io, "Activation(",l.f, ")")
end
# Flatten layer
"""
Flatten()
Flattens an array. A convenient way of using `x -> Flux.flatten(x)`.
"""
struct Flatten
end
(m::Flatten)(x::AbstractArray) = Flux.flatten(x)
# Identity layer
"""
Identity()
Returns its input without changes. Should be used with a `Parallel` layer if one wants to have a branch that does not change its input.
"""
struct Identity
end
(m::Identity)(x::AbstractArray) = x | FluxExtra | https://github.com/OML-NPA/FluxExtra.jl.git |
|
[
"MIT"
] | 0.4.2 | 55f90977e998403f56c1f6abab13fb67c32b35b9 | code | 8121 |
using Flux, CUDA, Test, FluxExtra, FluxExtra.Normalizations
function test_training(model,x,y)
opt = ADAM()
loss = Flux.Losses.mse
losses = Vector{Float32}(undef,2)
for i = 1:2
local loss_val
ps = Flux.Params(Flux.params(model))
gs = gradient(ps) do
predicted = model(x)
loss_val = loss(predicted,y)
end
losses[i] = loss_val
Flux.Optimise.update!(opt,ps,gs)
end
if losses[1]==losses[2]
error("Parameters not updating.")
end
return true
end
function test_model(model,x,y)
test_exp = quote
@test begin
@inferred $model($x)
true
end
@test test_training($model,$x,$y)
@test begin
@inferred gpu($model)(gpu($x))
true
end
@test test_training(gpu($model),gpu($x),gpu($y))
end
return test_exp
end
#---Tests begin-------------------------------------------------------------
@testset verbose=true "Conv as input" begin
test_layer = Conv((3, 3), 1=>2,pad=SamePad())
test_layer2 = Conv((3, 3), 1=>2,pad=SamePad())
@testset "Join" begin
@testset "Join(1)" begin
x = ones(Float32,6,6,1,1)
y = ones(Float32,12,6,2,1)
model = Chain(Parallel(tuple,(test_layer,test_layer2)),Join(1))
eval(test_model(model,x,y))
end
@testset "Join(2)" begin
x = ones(Float32,6,6,1,1)
y = ones(Float32,6,12,2,1)
model = Chain(Parallel(tuple,(test_layer,test_layer2)),Join(2))
eval(test_model(model,x,y))
end
@testset "Join(dum = 3)" begin
x = ones(Float32,6,6,1,1)
y = ones(Float32,6,6,4,1)
model = Chain(Parallel(tuple,(test_layer,test_layer2)),Join(dim = 3))
eval(test_model(model,x,y))
end
@testset "Join errors" begin
@test try
Join(4)
catch e
if !(e isa DimensionMismatch)
@error "Wrong error returned."
return e
else
true
end
end
@test try
Join(dim = 4)
catch e
if !(e isa DimensionMismatch)
@error "Wrong error returned."
return e
else
true
end
end
end
@testset "Printing" begin
@test begin
Base.show(IOBuffer(),Join(1))
true
end
end
end
@testset "Split" begin
@testset "Split(_,1)" begin
x = ones(Float32,6,6,1,1)
y = ones(Float32,6,6,2,1)
model = Chain(Split(2,1),Parallel(tuple,(test_layer,test_layer)),Join(1))
eval(test_model(model,x,y))
end
@testset "Split(_,2)" begin
x = ones(Float32,6,6,1,1)
y = ones(Float32,6,6,2,1)
model = Chain(Split(2,2),Parallel(tuple,(test_layer,test_layer)),Join(2))
eval(test_model(model,x,y))
end
@testset "Split(_,dim = 3)" begin
x = ones(Float32,6,6,2,1)
y = ones(Float32,6,6,4,1)
model = Chain(Split(2,dim = 3),Parallel(tuple,(test_layer,test_layer)),Join(3))
eval(test_model(model,x,y))
end
@testset "Split errors" begin
@test try
Split(2,4)
catch e
if !(e isa DimensionMismatch)
@error "Wrong error returned."
return e
else
true
end
end
@test try
Split(2,dim = 4)
catch e
if !(e isa DimensionMismatch)
@error "Wrong error returned."
return e
else
true
end
end
@test try
Split(1,1)
catch e
if !(e isa DomainError)
@error "Wrong error returned."
return e
else
true
end
end
@test try
Split(1,dim = 1)
catch e
if !(e isa DomainError)
@error "Wrong error returned."
return e
else
true
end
end
end
@testset "Printing" begin
@test begin
Base.show(IOBuffer(),Split(2,3))
true
end
end
end
@testset "Addition" begin
x = ones(Float32,6,6,1,1)
y = ones(Float32,6,6,1,1)
model = Chain(Parallel(tuple,(test_layer,test_layer)),Addition())
eval(test_model(model,x,y))
end
@testset "Activation" begin
x = ones(Float32,4,4,1,1)
y = ones(Float32,4,4,2,1)
model = Chain(test_layer,Activation(tanh))
eval(test_model(model,x,y))
@testset "Printing" begin
@test begin
Base.show(IOBuffer(),Activation(tanh))
true
end
end
end
@testset "Flatten" begin
x = ones(Float32,4,4,1,1)
y = ones(Float32,32,1)
model = Chain(test_layer,Flatten())
eval(test_model(model,x,y))
end
@testset "Identity" begin
x = ones(Float32,4,4,1,1)
y = ones(Float32,4,4,3,1)
model = Chain(Parallel(tuple,(test_layer,Identity())),Join(3))
eval(test_model(model,x,y))
end
end
@testset verbose=true "Dense as input" begin
test_layer = Dense(2,3)
test_layer2 = Dense(2,3)
@testset "Join" begin
@testset "Join(1)" begin
x = ones(Float32,2,1)
y = ones(Float32,6,1)
model = Chain(Parallel(tuple,(test_layer,test_layer2)),Join(1))
eval(test_model(model,x,y))
end
end
@testset "Split" begin
@testset "Split(_,1)" begin
x = ones(Float32,4,1)
y = ones(Float32,6,1)
model = Chain(Split(2,1),Parallel(tuple,(test_layer,test_layer)),Join(1))
eval(test_model(model,x,y))
end
@testset "Split errors" begin
x = ones(Float32,2,1)
layer = Split(2,2)
@test try
layer(x)
catch e
if !(e isa DimensionMismatch)
error("Wrong error returned.")
return e
else
true
end
end
end
end
@testset "Addition" begin
x = ones(Float32,4,1)
y = ones(Float32,3,1)
model = Chain(Split(2,1),Parallel(tuple,(test_layer,test_layer)),Addition())
eval(test_model(model,x,y))
end
@testset "Activation" begin
x = ones(Float32,2,1)
y = ones(Float32,3,1)
model = Chain(test_layer,Activation(tanh))
eval(test_model(model,x,y))
end
@testset "Identity" begin
x = ones(Float32,2,1)
y = ones(Float32,5,1)
model = Chain(Parallel(tuple,(test_layer,Identity())),Join(1))
eval(test_model(model,x,y))
end
end
@testset "Normalizations" begin
data = repeat([rand(Float32,5,5,3)],2)
@test begin
min_vals,max_vals = norm_01!(data)
map(x -> norm_01!(x,min_vals,max_vals), data)
min_vals,max_vals = norm_negpos1!(data)
map(x -> norm_negpos1!(x,min_vals,max_vals), data)
mean_vals = norm_zerocenter!(data)
mean_vals,std_vals = norm_zscore!(data)
true
end
end
| FluxExtra | https://github.com/OML-NPA/FluxExtra.jl.git |
|
[
"MIT"
] | 0.4.2 | 55f90977e998403f56c1f6abab13fb67c32b35b9 | docs | 3002 | [](https://oml-npa.github.io/FluxExtra.jl/stable/)
[](https://github.com/OML-NPA/FluxExtra.jl/actions/workflows/CI-main.yml)
[](https://codecov.io/gh/OML-NPA/FluxExtra.jl)
# FluxExtra
Additional layers and functions for the [Flux.jl](https://github.com/FluxML/Flux.jl) machine learning library.
## Layers
### Join
```
Join(dim::Int64)
Join(dim = dim::Int64)
```
Concatenates a tuple of arrays along a dimension `dim`. A convenient and type stable way of using `x -> cat(x..., dims = dim)`.
### Split
```
Split(outputs::Int64,dim::Int64)
Split(outputs::Int64, dim = dim::Int64)
```
Breaks an array into a number of arrays which is equal to `output` along a dimension `dim`. `dim` should we divisible by `outputs` without a remainder.
### Flatten
```
Flatten()
```
Flattens an array. A convenient way of using `x -> Flux.flatten(x)`.
### Addition
```
Addition()
```
A convenient way of using `x -> sum(x)`.
### Activation
```
Activation(f::Function)
```
A convenient way of using `x -> f(x)`.
### Identity
```
Identity()
```
Returns its input without changes. Should be used with a `Parallel` layer if one wants to have a branch that does not change its input.
## Normalizations
### [0,1]
```
norm_01!(data::Vector{T}) where {F<:AbstractFloat,N,T<:Array{F,N}}
```
Rescales each feature (last dimension) to be in the range [0,1]. Returns min and max values for each feature.
```
norm_01!(data::T,min_vals::T,max_vals::T) where {F<:AbstractFloat,N,T<:Array{F,N}}
```
Rescales each feature (last dimension) to be in the range [0,1].
### [-1,1]
```
norm_negpos1(data::Vector{T}) where {F<:AbstractFloat,N,T<:Array{F,N}}
```
Rescales each feature (last dimension) to be in the range [-1,1]. Returns min and max values for each feature.
```
norm_negpos1(data::T,min_vals::T,max_vals::T) where {F<:AbstractFloat,N,T<:Array{F,N}}
```
Rescales each feature (last dimension) to be in the range [-1,1].
### Zero center
```
norm_zerocenter!(data::Vector{T}) where {F<:AbstractFloat,N,T<:Array{F,N}}
```
Subtracts the mean of each feature (last dimension). Returns a mean value for each feature.
```
norm_zerocenter!(data::T,min_vals::T,max_vals::T) where {F<:AbstractFloat,N,T<:Array{F,N}}
```
Subtracts the mean of each feature (last dimension).
### Z-score
```
norm_zscore!(data::Vector{T}) where {F<:AbstractFloat,N,T<:Array{F,N}}
```
Subtracts the mean and divides by the standard deviation of each feature (last dimension). Returns mean and standard deviation values for each feature.
```
norm_zscore!(data::T,mean_vals::T,std_vals::T) where {F<:AbstractFloat,N,T<:Array{F,N}}
```
Subtracts the mean and divides by the standard deviation of each feature (last dimension).
## Other
Makes `Flux.Parallel` layer type stable when used with tuples.
| FluxExtra | https://github.com/OML-NPA/FluxExtra.jl.git |
|
[
"MIT"
] | 0.4.2 | 55f90977e998403f56c1f6abab13fb67c32b35b9 | docs | 277 |
## Normalizations
```@docs
Normalizations.norm_01!
```
```@docs
Normalizations.norm_negpos1!
```
```@docs
Normalizations.norm_zerocenter!
```
```@docs
Normalizations.norm_zscore!
```
## Other
Makes `Flux.Parallel` layer type stable when used with tuples. | FluxExtra | https://github.com/OML-NPA/FluxExtra.jl.git |
|
[
"MIT"
] | 0.4.2 | 55f90977e998403f56c1f6abab13fb67c32b35b9 | docs | 123 | # FluxExtra
Additional layers and functions for the [Flux.jl](https://github.com/FluxML/Flux.jl) machine learning library. | FluxExtra | https://github.com/OML-NPA/FluxExtra.jl.git |
|
[
"MIT"
] | 0.4.2 | 55f90977e998403f56c1f6abab13fb67c32b35b9 | docs | 174 |
## Normalizations
```@docs
Join
```
```@docs
Split
```
```@docs
Addition
```
```@docs
Activation
```
```@docs
Flatten
```
```@docs
Identity
``` | FluxExtra | https://github.com/OML-NPA/FluxExtra.jl.git |
|
[
"MIT"
] | 0.1.7 | f58443e5ffa3df2e1b28e4ac37ad5a1f25c22454 | code | 6333 | module Telegrambot
import HTTP, JSON, UUIDs
export InlineQueryResultArticle
export startBot, getUpdates, sendText
struct InlineQueryResultArticle
id::String
title::String
message::String
end
function startBot(botApi=""; textHandle=Dict(), textHandleReplyMessage=Dict(), inlineQueryHandle=Dict())
!isempty(textHandle) || error("You need to pass repond function as parameter to startBot")
# in case people put in what botfather spits
botApi = botApi[1:3]=="bot" ? botApi : "bot" * botApi
# to be used to clear msg que
offset = 0
msgDict = Dict()
while true
msgQuery = getUpdates(botApi,offset)
if length(msgQuery)==0
#this repeast every timeout seconds, now 10
continue
end
offset = maximum([ i["update_id"] for i in msgQuery ]) + 1 #update to clear the msg query next loop
# HTTP respond will have this field if a user @'ed bot in a chat
# find match cmd to pass to correspond function to handle
for rawCmd in msgQuery
# if this is a message
if haskey(rawCmd, "message")
msg = rawCmd["message"]
cmdName = " "
cmdPara = " "
try
cmdName = string(match(r"/([^@\s]+)", msg["text"])[1]) #match till first @ or space
catch
#= @warn "Not a command start with /" =#
continue
end
try
cmdPara = string(match(r"\s(.*)$", msg["text"])[1]) #match from first space to end
catch
cmdPara = " "
#= @warn "Command may got passed empty parameter" =#
end
if haskey(textHandle, cmdName)
reply = textHandle[cmdName](cmdPara, msg) #encode for GET purpose
reply_id = string(msg["chat"]["id"]) #encode for GET purpose
# all space msg is not allower either
!isempty(strip(reply)) || (@warn " message must be non-empty, also can't be all spaces";
reply = "Using the command incorrectly or command is bad")
sendText(botApi, reply_id, reply)
elseif haskey(textHandleReplyMessage, cmdName)
reply = textHandleReplyMessage[cmdName](cmdPara, msg) #encode for GET purpose
reply_id = string(msg["chat"]["id"]) #encode for GET purpose
message_id = string(msg["message_id"]) #encode for GET purpose
# all space msg is not allower either
if isnothing(reply) || isempty(strip(reply))
@warn " message must be non-empty, also can't be all spaces"
reply = "Using the command incorrectly or command is bad"
end
sendText(botApi, reply_id, reply, message_id = message_id)
else
reply_id = string(msg["chat"]["id"]) #encode for GET purpose
no_cmd_prompt = "The command $cmdName is not found"
sendText(botApi, reply_id, no_cmd_prompt)
#= @warn backtrace() =#
end
end
# HTTP respond will have this field if a user started an inline request
if haskey(rawCmd, "inline_query")
qry = rawCmd["inline_query"]
if qry["query"]≠"" #multiple inline query fills up as user type so initially there is an empty string
articleList = InlineQueryResultArticle[] #make an array of Articles waiting to be converted
for (key, inlineOpt) in inlineQueryHandle
articleEntry = InlineQueryResultArticle(string(UUIDs.uuid4()), key, inlineOpt(qry["query"]))
push!(articleList, articleEntry)
end
results = articleList |> ArticleListtoJSON #encode according to https://core.telegram.org/bots/api#inlinequeryresult
query_id = qry["id"] #encode for GET escape
answerInlineQuery(botApi, query_id, results)
end
end
end
end
end
# GET request sendig to telegram for text repond
function sendText(botApi, id, text; message_id = "")
# can't pass empty text, results 400
text = text |> HTTP.URIs.escapeuri #encode for GET purpose
id = id |> HTTP.URIs.escapeuri #encode for GET purpose
tQuery = ""
message_id == "" ? tQuery="""chat_id=$id&text=$text""" : tQuery="""chat_id=$id&text=$text&reply_to_message_id=$message_id"""
try
updates = HTTP.request("GET","https://api.telegram.org/$botApi/sendMessage";query="$tQuery")
catch e
errmsg = JSON.parse(String(e.response.body))
@warn "$(errmsg["description"]): $id"
end
sleep(0.01)
end
# GET request sendig to telegram for inline respond
function answerInlineQuery(botApi, query_id, results::String)
results = results |> HTTP.URIs.escapeuri #encode for GET purpose
query_id = query_id |> HTTP.URIs.escapeuri #encode for GET purpose
tQuery="""inline_query_id=$query_id&results=$results"""
updates = HTTP.request("GET","https://api.telegram.org/$botApi/answerInlineQuery";query="$tQuery")
sleep(0.01)
end
#encode a list of InlineQueryResultArticle according to telegram api JSON format
function ArticleListtoJSON(articles::Array{InlineQueryResultArticle})
return JSON.json([ Dict(
"type"=>"article","id"=>article.id,
"title"=>article.title,
"input_message_content"=>
Dict{String,String}("message_text"=>article.message)
)
for article in articles])
end
function getUpdates(botApi="", offset=0)
# this is already a long-poll handled on telegram's side
# telling telegram how long we want to timeout once
tQuery="""timeout=10&offset=$offset"""
updates = JSON.parse(String(HTTP.request("GET","https://api.telegram.org/$botApi/getUpdates";query="$tQuery").body))
result = updates["result"]
return result
end
end # module
| Telegrambot | https://github.com/Moelf/Telegrambot.jl.git |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.