From 0f5ce8501c2df7dce66c2d8c4fd5b5a9b96f84ec Mon Sep 17 00:00:00 2001 From: Alexis Montoison Date: Mon, 9 Dec 2024 13:43:59 -0600 Subject: [PATCH] Add the new wrappers with support of Int64 --- .gitignore | 1 + gen/Project.toml | 1 + gen/analyzer.jl | 50 +++++- gen/wrapper.jl | 4 +- src/C/hsl_ma48.jl | 50 ++++-- src/C/hsl_ma57.jl | 64 +++++--- src/C/hsl_ma77.jl | 111 ++++++++----- src/C/hsl_ma86.jl | 36 +++-- src/C/hsl_ma87.jl | 56 ++++--- src/C/hsl_ma97.jl | 158 +++++++++---------- src/C/hsl_mc68.jl | 12 +- src/C/hsl_mc78.jl | 10 +- src/C/hsl_mc79.jl | 4 +- src/C/hsl_mi20.jl | 34 +++- src/C/hsl_mi28.jl | 18 ++- src/Fortran/fa01.jl | 32 ++++ src/Fortran/fa04.jl | 32 ++++ src/Fortran/fa14.jl | 40 +++++ src/Fortran/fd15.jl | 8 + src/Fortran/kb07.jl | 12 ++ src/Fortran/la04.jl | 143 +++++++++++++++++ src/Fortran/la15.jl | 63 ++++++++ src/Fortran/ma27.jl | 220 ++++++++++++++++++++++++++ src/Fortran/ma28.jl | 80 ++++++++++ src/Fortran/ma30.jl | 64 ++++++++ src/Fortran/ma33.jl | 80 ++++++++++ src/Fortran/ma57.jl | 358 ++++++++++++++++++++++++++++++++++++++++++ src/Fortran/ma61.jl | 121 ++++++++++++++ src/Fortran/mc13.jl | 26 +++ src/Fortran/mc19.jl | 12 ++ src/Fortran/mc20.jl | 22 +++ src/Fortran/mc21.jl | 26 +++ src/Fortran/mc22.jl | 12 ++ src/Fortran/mc23.jl | 14 ++ src/Fortran/mc24.jl | 12 ++ src/Fortran/mc29.jl | 14 ++ src/Fortran/mc30.jl | 12 ++ src/Fortran/mc34.jl | 10 ++ src/Fortran/mc37.jl | 32 ++++ src/Fortran/mc47.jl | 40 +++++ src/Fortran/mc49.jl | 42 +++++ src/Fortran/mc54.jl | 54 +++++++ src/Fortran/mc57.jl | 28 ++++ src/Fortran/mc59.jl | 85 ++++++++++ src/Fortran/mc60.jl | 178 +++++++++++++++++++++ src/Fortran/mc61.jl | 24 +++ src/Fortran/mc64.jl | 140 +++++++++++++++++ src/Fortran/mc71.jl | 12 ++ src/Fortran/mc77.jl | 260 ++++++++++++++++++++++++++++++ src/Fortran/mi21.jl | 25 +++ src/Fortran/mi24.jl | 30 ++++ src/Fortran/mi26.jl | 25 +++ src/Fortran/ym01.jl | 24 +++ src/Fortran/ym11.jl | 32 ++++ src/hsl_ma97.jl | 36 ++++- test/Jenkinsfile | 83 ---------- test/run_tests.sh | 13 -- test/send_gist_url.jl | 76 --------- 58 files changed, 2886 insertions(+), 375 deletions(-) delete mode 100644 test/Jenkinsfile delete mode 100644 test/run_tests.sh delete mode 100644 test/send_gist_url.jl diff --git a/.gitignore b/.gitignore index 3a25230..bebfe93 100644 --- a/.gitignore +++ b/.gitignore @@ -8,3 +8,4 @@ deps/build.log Manifest.toml docs/Manifest.toml gen/symbols.txt +gen/symbols_64.txt diff --git a/gen/Project.toml b/gen/Project.toml index bca9c66..f0d1129 100644 --- a/gen/Project.toml +++ b/gen/Project.toml @@ -5,3 +5,4 @@ JuliaFormatter = "98e50ef6-434e-11e9-1051-2b60c6c9e899" [compat] julia = "1.6" +HSL_jll = "=2024.11.28" diff --git a/gen/analyzer.jl b/gen/analyzer.jl index 57fb668..0df71f7 100644 --- a/gen/analyzer.jl +++ b/gen/analyzer.jl @@ -2,13 +2,17 @@ using HSL_jll using JuliaFormatter -release = "2023.11.7" -libhsl = "/home/alexis/Bureau/git/hsl/libhsl/libHSL-$release/" +release = "2024.11.28" +libhsl = "/home/alexis/Bureau/git/hsl/libhsl/libHSL.v$release/" # Symbols of the shared library libhsl symbols_path = "symbols.txt" run(pipeline(`nm -D $(HSL_jll.libhsl_path)`, stdout=symbols_path)) +# Symbols of the shared library libhsl_subset_64 +symbols_64_path = "symbols_64.txt" +run(pipeline(`nm -D $(HSL_jll.libhsl_subset_64_path)`, stdout=symbols_64_path)) + # Relation between the hsl precision and the name of the symbols hsl_precision = Dict{Char, String}('i' => "integer", 'l' => "long_integer", @@ -392,6 +396,11 @@ function main(name::String="all"; verbose::Bool=false) symbols = split(symbols, "\n", keepempty=false) symbols = [symbol[20:end] for symbol in symbols] + # Create a vector with all symbols exported by the shared library libhsl_subset_64 + symbols_64 = read(symbols_64_path, String) + symbols_64 = split(symbols_64, "\n", keepempty=false) + symbols_64 = [symbol_64[20:end] for symbol_64 in symbols_64] + for (root, dirs, files) in walkdir(libhsl) # We don't want to go inside "examples", metis" and "libhsl" folders @@ -475,6 +484,43 @@ function main(name::String="all"; verbose::Bool=false) end write(file_wrapper, ")::$(output_type)\n") write(file_wrapper, "end\n") + + # Symbols with the suffix `64_` + if "$(fname)64_" in symbols_64 + write(file_wrapper, "\n") + signature64 = replace(signature, fname[1:end-1] => "$(fname)64") + signature64 = replace(signature64, "Cint" => "Int64") + write(file_wrapper, "function $signature64\n") + write(file_wrapper, " @ccall libhsl_subset_64.$(fname)64_(") + for k = 1:narguments + if types[k] == "" + format = false + @warn "Unable to determine the type of $(arguments[k])" + else + type64 = replace(types[k], "Cint" => "Int64") + write(file_wrapper, "$(arguments[k])::$(type64)") + end + (k < narguments) && write(file_wrapper, ", ") + end + + # Hidden arguments + if "Ref{UInt8}" ∈ types || "Ptr{UInt8}" ∈ types || "Ptr{Ptr{UInt8}}" ∈ types + verbose && @info "Hidden argument in $fname." + end + for k = 1:narguments + (types[k] == "Ref{UInt8}") && write(file_wrapper, ", 1::Csize_t") + (types[k] == "Ptr{UInt8}") && write(file_wrapper, ", $(strlen[arguments[k]])::Csize_t") + (types[k] == "Ptr{Ptr{UInt8}}") && write(file_wrapper, ", $(strlen[arguments[k]])::Csize_t") + end + + if output_type == "" + format = false + @warn "Unable to determine the output type" + end + write(file_wrapper, ")::$(output_type)\n") + write(file_wrapper, "end\n") + end + index < num_fnames && write(file_wrapper, "\n") end end diff --git a/gen/wrapper.jl b/gen/wrapper.jl index 6e7f26d..daa7b60 100644 --- a/gen/wrapper.jl +++ b/gen/wrapper.jl @@ -11,7 +11,7 @@ function wrapper(name::String, headers::Vector{String}, optimized::Bool) @info "Wrapping $name" cd(@__DIR__) - include_dir = joinpath(HSL_jll.artifact_dir, "include") + include_dir = joinpath(HSL_jll.artifact_dir, "include", "libhsl") options = load_options(joinpath(@__DIR__, "hsl.toml")) options["general"]["output_file_path"] = joinpath("..", "src", "C", "$(name).jl") @@ -47,7 +47,7 @@ function hsl_headers(include::String, package::String, precisions::Vector{Char}) end function main(name::String="all"; optimized::Bool=false) - include = joinpath(HSL_jll.artifact_dir, "include") + include = joinpath(HSL_jll.artifact_dir, "include", "libhsl") if name == "all" || name == "libhsl" wrapper("libhsl", [joinpath(include, "libhsl.h")], optimized) diff --git a/src/C/hsl_ma48.jl b/src/C/hsl_ma48.jl index 68d1f65..370d7d0 100644 --- a/src/C/hsl_ma48.jl +++ b/src/C/hsl_ma48.jl @@ -24,9 +24,15 @@ mutable struct ma48_control{T} fill_in::Cint switch_mode::Cint - ma48_control{T}() where T = new() + ma48_control{T}() where {T} = new() - ma48_control{T}(f_arrays, multiplier, u, switch_, drop, tolerance, cgce, lp, wp, mp, ldiag, btf, struct_, maxit, factor_blocking, solve_blas, pivoting, diagonal_pivoting, fill_in, switch_mode) where T = new(f_arrays, multiplier, u, switch_, drop, tolerance, cgce, lp, wp, mp, ldiag, btf, struct_, maxit, factor_blocking, solve_blas, pivoting, diagonal_pivoting, fill_in, switch_mode) + function ma48_control{T}(f_arrays, multiplier, u, switch_, drop, tolerance, cgce, lp, wp, mp, + ldiag, btf, struct_, maxit, factor_blocking, solve_blas, pivoting, + diagonal_pivoting, fill_in, switch_mode) where {T} + return new(f_arrays, multiplier, u, switch_, drop, tolerance, cgce, lp, wp, mp, ldiag, btf, + struct_, maxit, factor_blocking, solve_blas, pivoting, diagonal_pivoting, fill_in, + switch_mode) + end end function ma48_default_control_s(control) @@ -52,9 +58,14 @@ mutable struct ma48_ainfo{T} sblock::Cint tblock::Clong - ma48_ainfo{T}() where T = new() + ma48_ainfo{T}() where {T} = new() - ma48_ainfo{T}(ops, flag, more, lena_analyse, lenj_analyse, lena_factorize, leni_factorize, ncmpa, rank, drop, struc_rank, oor, dup, stat, lblock, sblock, tblock) where T = new(ops, flag, more, lena_analyse, lenj_analyse, lena_factorize, leni_factorize, ncmpa, rank, drop, struc_rank, oor, dup, stat, lblock, sblock, tblock) + function ma48_ainfo{T}(ops, flag, more, lena_analyse, lenj_analyse, lena_factorize, + leni_factorize, ncmpa, rank, drop, struc_rank, oor, dup, stat, lblock, + sblock, tblock) where {T} + return new(ops, flag, more, lena_analyse, lenj_analyse, lena_factorize, leni_factorize, ncmpa, + rank, drop, struc_rank, oor, dup, stat, lblock, sblock, tblock) + end end mutable struct ma48_finfo{T} @@ -68,16 +79,20 @@ mutable struct ma48_finfo{T} rank::Cint stat::Cint - ma48_finfo{T}() where T = new() + ma48_finfo{T}() where {T} = new() - ma48_finfo{T}(ops, flag, more, size_factor, lena_factorize, leni_factorize, drop, rank, stat) where T = new(ops, flag, more, size_factor, lena_factorize, leni_factorize, drop, rank, stat) + function ma48_finfo{T}(ops, flag, more, size_factor, lena_factorize, leni_factorize, drop, rank, + stat) where {T} + return new(ops, flag, more, size_factor, lena_factorize, leni_factorize, drop, rank, stat) + end end function ma48_analyse_s(m, n, ne, row, col, val, factors, control, ainfo, finfo, perm, endcol) @ccall libhsl.ma48_analyse_s(m::Cint, n::Cint, ne::Clong, row::Ptr{Cint}, col::Ptr{Cint}, val::Ptr{Float32}, factors::Ptr{Cvoid}, control::Ref{ma48_control{Float32}}, ainfo::Ref{ma48_ainfo{Float32}}, - finfo::Ref{ma48_finfo{Float32}}, perm::Ptr{Cint}, endcol::Ptr{Cint})::Cvoid + finfo::Ref{ma48_finfo{Float32}}, perm::Ptr{Cint}, + endcol::Ptr{Cint})::Cvoid end function ma48_get_perm_s(m, n, factors, perm, control) @@ -88,7 +103,8 @@ end function ma48_factorize_s(m, n, ne, row, col, val, factors, control, finfo, fast, partial) @ccall libhsl.ma48_factorize_s(m::Cint, n::Cint, ne::Clong, row::Ptr{Cint}, col::Ptr{Cint}, val::Ptr{Float32}, factors::Ptr{Cvoid}, - control::Ref{ma48_control{Float32}}, finfo::Ref{ma48_finfo{Float32}}, fast::Cint, + control::Ref{ma48_control{Float32}}, + finfo::Ref{ma48_finfo{Float32}}, fast::Cint, partial::Cint)::Cvoid end @@ -106,7 +122,8 @@ function ma48_solve_s(m, n, ne, row, col, val, factors, rhs, x, control, sinfo, @ccall libhsl.ma48_solve_s(m::Cint, n::Cint, ne::Clong, row::Ptr{Cint}, col::Ptr{Cint}, val::Ptr{Float32}, factors::Ptr{Cvoid}, rhs::Ptr{Float32}, x::Ptr{Float32}, - control::Ref{ma48_control{Float32}}, sinfo::Ref{ma48_sinfo}, trans::Cint, + control::Ref{ma48_control{Float32}}, sinfo::Ref{ma48_sinfo}, + trans::Cint, resid::Ptr{Float32}, error::Ptr{Float32})::Cvoid end @@ -116,7 +133,8 @@ end function ma48_special_rows_and_cols_s(factors, rank, rows, cols, control) @ccall libhsl.ma48_special_rows_and_cols_s(factors::Ptr{Cvoid}, rank::Ptr{Cint}, rows::Ptr{Cint}, - cols::Ptr{Cint}, control::Ref{ma48_control{Float32}})::Cint + cols::Ptr{Cint}, + control::Ref{ma48_control{Float32}})::Cint end function ma48_determinant_s(factors, sgndet, logdet, control) @@ -136,7 +154,8 @@ function ma48_analyse_d(m, n, ne, row, col, val, factors, control, ainfo, finfo, @ccall libhsl.ma48_analyse_d(m::Cint, n::Cint, ne::Clong, row::Ptr{Cint}, col::Ptr{Cint}, val::Ptr{Float64}, factors::Ptr{Cvoid}, control::Ref{ma48_control{Float64}}, ainfo::Ref{ma48_ainfo{Float64}}, - finfo::Ref{ma48_finfo{Float64}}, perm::Ptr{Cint}, endcol::Ptr{Cint})::Cvoid + finfo::Ref{ma48_finfo{Float64}}, perm::Ptr{Cint}, + endcol::Ptr{Cint})::Cvoid end function ma48_get_perm_d(m, n, factors, perm, control) @@ -147,7 +166,8 @@ end function ma48_factorize_d(m, n, ne, row, col, val, factors, control, finfo, fast, partial) @ccall libhsl.ma48_factorize_d(m::Cint, n::Cint, ne::Clong, row::Ptr{Cint}, col::Ptr{Cint}, val::Ptr{Float64}, factors::Ptr{Cvoid}, - control::Ref{ma48_control{Float64}}, finfo::Ref{ma48_finfo{Float64}}, fast::Cint, + control::Ref{ma48_control{Float64}}, + finfo::Ref{ma48_finfo{Float64}}, fast::Cint, partial::Cint)::Cvoid end @@ -155,7 +175,8 @@ function ma48_solve_d(m, n, ne, row, col, val, factors, rhs, x, control, sinfo, @ccall libhsl.ma48_solve_d(m::Cint, n::Cint, ne::Clong, row::Ptr{Cint}, col::Ptr{Cint}, val::Ptr{Float64}, factors::Ptr{Cvoid}, rhs::Ptr{Float64}, x::Ptr{Float64}, - control::Ref{ma48_control{Float64}}, sinfo::Ref{ma48_sinfo}, trans::Cint, + control::Ref{ma48_control{Float64}}, sinfo::Ref{ma48_sinfo}, + trans::Cint, resid::Ptr{Float64}, error::Ptr{Float64})::Cvoid end @@ -165,7 +186,8 @@ end function ma48_special_rows_and_cols_d(factors, rank, rows, cols, control) @ccall libhsl.ma48_special_rows_and_cols_d(factors::Ptr{Cvoid}, rank::Ptr{Cint}, rows::Ptr{Cint}, - cols::Ptr{Cint}, control::Ref{ma48_control{Float64}})::Cint + cols::Ptr{Cint}, + control::Ref{ma48_control{Float64}})::Cint end function ma48_determinant_d(factors, sgndet, logdet, control) diff --git a/src/C/hsl_ma57.jl b/src/C/hsl_ma57.jl index 6634ba3..06f231d 100644 --- a/src/C/hsl_ma57.jl +++ b/src/C/hsl_ma57.jl @@ -25,12 +25,20 @@ mutable struct ma57_control{T} ordering::Cint scaling::Cint rank_deficient::Cint - ispare::NTuple{5,Cint} - rspare::NTuple{10,T} + ispare::NTuple{5, Cint} + rspare::NTuple{10, T} - ma57_control{T}() where T = new() + ma57_control{T}() where {T} = new() - ma57_control{T}(f_arrays, multiplier, reduce, u, static_tolerance, static_level, tolerance, convergence, consist, lp, wp, mp, sp, ldiag, nemin, factorblocking, solveblocking, la, liw, maxla, maxliw, pivoting, thresh, ordering, scaling, rank_deficient, ispare, rspare) where T = new(f_arrays, multiplier, reduce, u, static_tolerance, static_level, tolerance, convergence, consist, lp, wp, mp, sp, ldiag, nemin, factorblocking, solveblocking, la, liw, maxla, maxliw, pivoting, thresh, ordering, scaling, rank_deficient, ispare, rspare) + function ma57_control{T}(f_arrays, multiplier, reduce, u, static_tolerance, static_level, + tolerance, convergence, consist, lp, wp, mp, sp, ldiag, nemin, + factorblocking, solveblocking, la, liw, maxla, maxliw, pivoting, thresh, + ordering, scaling, rank_deficient, ispare, rspare) where {T} + return new(f_arrays, multiplier, reduce, u, static_tolerance, static_level, tolerance, + convergence, consist, lp, wp, mp, sp, ldiag, nemin, factorblocking, solveblocking, + la, liw, maxla, maxliw, pivoting, thresh, ordering, scaling, rank_deficient, ispare, + rspare) + end end function ma57_default_control_s(control) @@ -59,12 +67,16 @@ mutable struct ma57_ainfo{T} dup::Cint maxfrt::Cint stat::Cint - ispare::NTuple{5,Cint} - rspare::NTuple{10,T} + ispare::NTuple{5, Cint} + rspare::NTuple{10, T} - ma57_ainfo{T}() where T = new() + ma57_ainfo{T}() where {T} = new() - ma57_ainfo{T}(opsa, opse, flag, more, nsteps, nrltot, nirtot, nrlnec, nirnec, nrladu, niradu, ncmpa, ordering, oor, dup, maxfrt, stat, ispare, rspare) where T = new(opsa, opse, flag, more, nsteps, nrltot, nirtot, nrlnec, nirnec, nrladu, niradu, ncmpa, ordering, oor, dup, maxfrt, stat, ispare, rspare) + function ma57_ainfo{T}(opsa, opse, flag, more, nsteps, nrltot, nirtot, nrlnec, nirnec, nrladu, + niradu, ncmpa, ordering, oor, dup, maxfrt, stat, ispare, rspare) where {T} + return new(opsa, opse, flag, more, nsteps, nrltot, nirtot, nrlnec, nirnec, nrladu, niradu, + ncmpa, ordering, oor, dup, maxfrt, stat, ispare, rspare) + end end function ma57_analyse_s(n, ne, row, col, factors, control, ainfo, perm) @@ -100,18 +112,25 @@ mutable struct ma57_finfo{T} modstep::Cint rank::Cint stat::Cint - ispare::NTuple{5,Cint} - rspare::NTuple{10,T} + ispare::NTuple{5, Cint} + rspare::NTuple{10, T} - ma57_finfo{T}() where T = new() + ma57_finfo{T}() where {T} = new() - ma57_finfo{T}(opsa, opse, opsb, maxchange, smin, smax, flag, more, maxfrt, nebdu, nrlbdu, nirbdu, nrltot, nirtot, nrlnec, nirnec, ncmpbr, ncmpbi, ntwo, neig, delay, signc, static_, modstep, rank, stat, ispare, rspare) where T = new(opsa, opse, opsb, maxchange, smin, smax, flag, more, maxfrt, nebdu, nrlbdu, nirbdu, nrltot, nirtot, nrlnec, nirnec, ncmpbr, ncmpbi, ntwo, neig, delay, signc, static_, modstep, rank, stat, ispare, rspare) + function ma57_finfo{T}(opsa, opse, opsb, maxchange, smin, smax, flag, more, maxfrt, nebdu, nrlbdu, + nirbdu, nrltot, nirtot, nrlnec, nirnec, ncmpbr, ncmpbi, ntwo, neig, delay, + signc, static_, modstep, rank, stat, ispare, rspare) where {T} + return new(opsa, opse, opsb, maxchange, smin, smax, flag, more, maxfrt, nebdu, nrlbdu, nirbdu, + nrltot, nirtot, nrlnec, nirnec, ncmpbr, ncmpbi, ntwo, neig, delay, signc, static_, + modstep, rank, stat, ispare, rspare) + end end function ma57_factorize_s(n, ne, row, col, val, factors, control, finfo) @ccall libhsl.ma57_factorize_s(n::Cint, ne::Cint, row::Ptr{Cint}, col::Ptr{Cint}, val::Ptr{Float32}, factors::Ptr{Ptr{Cvoid}}, - control::Ref{ma57_control{Float32}}, finfo::Ref{ma57_finfo{Float32}})::Cvoid + control::Ref{ma57_control{Float32}}, + finfo::Ref{ma57_finfo{Float32}})::Cvoid end mutable struct ma57_sinfo{T} @@ -122,12 +141,14 @@ mutable struct ma57_sinfo{T} error::T flag::Cint stat::Cint - ispare::NTuple{5,Cint} - rspare::NTuple{10,T} + ispare::NTuple{5, Cint} + rspare::NTuple{10, T} - ma57_sinfo{T}() where T = new() + ma57_sinfo{T}() where {T} = new() - ma57_sinfo{T}(cond, cond2, berr, berr2, error, flag, stat, ispare, rspare) where T = new(cond, cond2, berr, berr2, error, flag, stat, ispare, rspare) + function ma57_sinfo{T}(cond, cond2, berr, berr2, error, flag, stat, ispare, rspare) where {T} + return new(cond, cond2, berr, berr2, error, flag, stat, ispare, rspare) + end end function ma57_solve_s(n, ne, row, col, val, factors, nrhs, x, control, sinfo, rhs, iter, cond) @@ -186,7 +207,8 @@ function ma57_sparse_lsolve_s(factors, control, nzrhs, irhs, nzsoln, isoln, x, s end function ma57_fredholm_alternative_s(factors, control, x, fredx, sinfo) - @ccall libhsl.ma57_fredholm_alternative_s(factors::Ptr{Ptr{Cvoid}}, control::Ref{ma57_control{Float32}}, + @ccall libhsl.ma57_fredholm_alternative_s(factors::Ptr{Ptr{Cvoid}}, + control::Ref{ma57_control{Float32}}, x::Ptr{Float32}, fredx::Ptr{Float32}, sinfo::Ref{ma57_sinfo{Float32}})::Cvoid end @@ -224,7 +246,8 @@ end function ma57_factorize_d(n, ne, row, col, val, factors, control, finfo) @ccall libhsl.ma57_factorize_d(n::Cint, ne::Cint, row::Ptr{Cint}, col::Ptr{Cint}, val::Ptr{Float64}, factors::Ptr{Ptr{Cvoid}}, - control::Ref{ma57_control{Float64}}, finfo::Ref{ma57_finfo{Float64}})::Cvoid + control::Ref{ma57_control{Float64}}, + finfo::Ref{ma57_finfo{Float64}})::Cvoid end function ma57_solve_d(n, ne, row, col, val, factors, nrhs, x, control, sinfo, rhs, iter, cond) @@ -283,7 +306,8 @@ function ma57_sparse_lsolve_d(factors, control, nzrhs, irhs, nzsoln, isoln, x, s end function ma57_fredholm_alternative_d(factors, control, x, fredx, sinfo) - @ccall libhsl.ma57_fredholm_alternative_d(factors::Ptr{Ptr{Cvoid}}, control::Ref{ma57_control{Float64}}, + @ccall libhsl.ma57_fredholm_alternative_d(factors::Ptr{Ptr{Cvoid}}, + control::Ref{ma57_control{Float64}}, x::Ptr{Float64}, fredx::Ptr{Float64}, sinfo::Ref{ma57_sinfo{Float64}})::Cvoid end diff --git a/src/C/hsl_ma77.jl b/src/C/hsl_ma77.jl index c27bba3..2e0fd98 100644 --- a/src/C/hsl_ma77.jl +++ b/src/C/hsl_ma77.jl @@ -5,11 +5,11 @@ mutable struct ma77_control{T} unit_error::Cint unit_warning::Cint bits::Cint - buffer_lpage::NTuple{2,Cint} - buffer_npage::NTuple{2,Cint} + buffer_lpage::NTuple{2, Cint} + buffer_npage::NTuple{2, Cint} file_size::Clong maxstore::Clong - storage::NTuple{3,Clong} + storage::NTuple{3, Clong} nemin::Cint maxit::Cint infnorm::Cint @@ -25,13 +25,21 @@ mutable struct ma77_control{T} u::T umin::T consist_tol::T - ispare::NTuple{5,Cint} - lspare::NTuple{5,Clong} - rspare::NTuple{5,T} + ispare::NTuple{5, Cint} + lspare::NTuple{5, Clong} + rspare::NTuple{5, T} - ma77_control{T}() where T = new() + ma77_control{T}() where {T} = new() - ma77_control{T}(f_arrays, print_level, unit_diagnostics, unit_error, unit_warning, bits, buffer_lpage, buffer_npage, file_size, maxstore, storage, nemin, maxit, infnorm, thresh, nb54, action, multiplier, nb64, nbi, small, static_, storage_indef, u, umin, consist_tol, ispare, lspare, rspare) where T = new(f_arrays, print_level, unit_diagnostics, unit_error, unit_warning, bits, buffer_lpage, buffer_npage, file_size, maxstore, storage, nemin, maxit, infnorm, thresh, nb54, action, multiplier, nb64, nbi, small, static_, storage_indef, u, umin, consist_tol, ispare, lspare, rspare) + function ma77_control{T}(f_arrays, print_level, unit_diagnostics, unit_error, unit_warning, bits, + buffer_lpage, buffer_npage, file_size, maxstore, storage, nemin, maxit, + infnorm, thresh, nb54, action, multiplier, nb64, nbi, small, static_, + storage_indef, u, umin, consist_tol, ispare, lspare, rspare) where {T} + return new(f_arrays, print_level, unit_diagnostics, unit_error, unit_warning, bits, + buffer_lpage, buffer_npage, file_size, maxstore, storage, nemin, maxit, infnorm, + thresh, nb54, action, multiplier, nb64, nbi, small, static_, storage_indef, u, umin, + consist_tol, ispare, lspare, rspare) + end end function ma77_default_control_s(control) @@ -59,24 +67,33 @@ mutable struct ma77_info{T} num_perturbed::Cint ntwo::Cint stat::Cint - index::NTuple{4,Cint} - nio_read::NTuple{2,Clong} - nio_write::NTuple{2,Clong} - nwd_read::NTuple{2,Clong} - nwd_write::NTuple{2,Clong} - num_file::NTuple{4,Cint} - storage::NTuple{4,Clong} + index::NTuple{4, Cint} + nio_read::NTuple{2, Clong} + nio_write::NTuple{2, Clong} + nwd_read::NTuple{2, Clong} + nwd_write::NTuple{2, Clong} + num_file::NTuple{4, Cint} + storage::NTuple{4, Clong} tree_nodes::Cint unit_restart::Cint unused::Cint usmall::T - ispare::NTuple{5,Cint} - lspare::NTuple{5,Clong} - rspare::NTuple{5,T} + ispare::NTuple{5, Cint} + lspare::NTuple{5, Clong} + rspare::NTuple{5, T} - ma77_info{T}() where T = new() + ma77_info{T}() where {T} = new() - ma77_info{T}(detlog, detsign, flag, iostat, matrix_dup, matrix_rank, matrix_outrange, maxdepth, maxfront, minstore, ndelay, nfactor, nflops, niter, nsup, num_neg, num_nothresh, num_perturbed, ntwo, stat, index, nio_read, nio_write, nwd_read, nwd_write, num_file, storage, tree_nodes, unit_restart, unused, usmall, ispare, lspare, rspare) where T = new(detlog, detsign, flag, iostat, matrix_dup, matrix_rank, matrix_outrange, maxdepth, maxfront, minstore, ndelay, nfactor, nflops, niter, nsup, num_neg, num_nothresh, num_perturbed, ntwo, stat, index, nio_read, nio_write, nwd_read, nwd_write, num_file, storage, tree_nodes, unit_restart, unused, usmall, ispare, lspare, rspare) + function ma77_info{T}(detlog, detsign, flag, iostat, matrix_dup, matrix_rank, matrix_outrange, + maxdepth, maxfront, minstore, ndelay, nfactor, nflops, niter, nsup, num_neg, + num_nothresh, num_perturbed, ntwo, stat, index, nio_read, nio_write, + nwd_read, nwd_write, num_file, storage, tree_nodes, unit_restart, unused, + usmall, ispare, lspare, rspare) where {T} + return new(detlog, detsign, flag, iostat, matrix_dup, matrix_rank, matrix_outrange, maxdepth, + maxfront, minstore, ndelay, nfactor, nflops, niter, nsup, num_neg, num_nothresh, + num_perturbed, ntwo, stat, index, nio_read, nio_write, nwd_read, nwd_write, num_file, + storage, tree_nodes, unit_restart, unused, usmall, ispare, lspare, rspare) + end end function ma77_open_nelt_s(n, fname1, fname2, fname3, fname4, keep, control, info, nelt) @@ -88,13 +105,15 @@ end function ma77_open_s(n, fname1, fname2, fname3, fname4, keep, control, info) @ccall libhsl.ma77_open_s(n::Cint, fname1::Cstring, fname2::Cstring, fname3::Cstring, - fname4::Cstring, keep::Ptr{Ptr{Cvoid}}, control::Ref{ma77_control{Float32}}, + fname4::Cstring, keep::Ptr{Ptr{Cvoid}}, + control::Ref{ma77_control{Float32}}, info::Ref{ma77_info{Float32}})::Cvoid end function ma77_input_vars_s(idx, nvar, list, keep, control, info) @ccall libhsl.ma77_input_vars_s(idx::Cint, nvar::Cint, list::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, - control::Ref{ma77_control{Float32}}, info::Ref{ma77_info{Float32}})::Cvoid + control::Ref{ma77_control{Float32}}, + info::Ref{ma77_info{Float32}})::Cvoid end function ma77_input_reals_s(idx, length, reals, keep, control, info) @@ -105,17 +124,20 @@ end function ma77_analyse_s(order, keep, control, info) @ccall libhsl.ma77_analyse_s(order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, - control::Ref{ma77_control{Float32}}, info::Ref{ma77_info{Float32}})::Cvoid + control::Ref{ma77_control{Float32}}, + info::Ref{ma77_info{Float32}})::Cvoid end function ma77_factor_s(posdef, keep, control, info, scale) - @ccall libhsl.ma77_factor_s(posdef::Cint, keep::Ptr{Ptr{Cvoid}}, control::Ref{ma77_control{Float32}}, + @ccall libhsl.ma77_factor_s(posdef::Cint, keep::Ptr{Ptr{Cvoid}}, + control::Ref{ma77_control{Float32}}, info::Ref{ma77_info{Float32}}, scale::Ptr{Float32})::Cvoid end function ma77_factor_solve_s(posdef, keep, control, info, scale, nrhs, lx, rhs) @ccall libhsl.ma77_factor_solve_s(posdef::Cint, keep::Ptr{Ptr{Cvoid}}, - control::Ref{ma77_control{Float32}}, info::Ref{ma77_info{Float32}}, + control::Ref{ma77_control{Float32}}, + info::Ref{ma77_info{Float32}}, scale::Ptr{Float32}, nrhs::Cint, lx::Cint, rhs::Ptr{Float32})::Cvoid end @@ -141,7 +163,8 @@ end function ma77_enquire_posdef_s(d, keep, control, info) @ccall libhsl.ma77_enquire_posdef_s(d::Ptr{Float32}, keep::Ptr{Ptr{Cvoid}}, - control::Ref{ma77_control{Float32}}, info::Ref{ma77_info{Float32}})::Cvoid + control::Ref{ma77_control{Float32}}, + info::Ref{ma77_info{Float32}})::Cvoid end function ma77_enquire_indef_s(piv_order, d, keep, control, info) @@ -152,13 +175,15 @@ end function ma77_alter_s(d, keep, control, info) @ccall libhsl.ma77_alter_s(d::Ptr{Float32}, keep::Ptr{Ptr{Cvoid}}, - control::Ref{ma77_control{Float32}}, info::Ref{ma77_info{Float32}})::Cvoid + control::Ref{ma77_control{Float32}}, + info::Ref{ma77_info{Float32}})::Cvoid end function ma77_restart_s(restart_file, fname1, fname2, fname3, fname4, keep, control, info) @ccall libhsl.ma77_restart_s(restart_file::Cstring, fname1::Cstring, fname2::Cstring, fname3::Cstring, fname4::Cstring, keep::Ptr{Ptr{Cvoid}}, - control::Ref{ma77_control{Float32}}, info::Ref{ma77_info{Float32}})::Cvoid + control::Ref{ma77_control{Float32}}, + info::Ref{ma77_info{Float32}})::Cvoid end function ma77_finalise_s(keep, control, info) @@ -169,7 +194,8 @@ end function ma77_solve_fredholm_s(nrhs, flag_out, lx, x, keep, control, info, scale) @ccall libhsl.ma77_solve_fredholm_s(nrhs::Cint, flag_out::Ptr{Cint}, lx::Cint, x::Ptr{Float32}, keep::Ptr{Ptr{Cvoid}}, - control::Ref{ma77_control{Float32}}, info::Ref{ma77_info{Float32}}, + control::Ref{ma77_control{Float32}}, + info::Ref{ma77_info{Float32}}, scale::Ptr{Float32})::Cvoid end @@ -193,13 +219,15 @@ end function ma77_open_d(n, fname1, fname2, fname3, fname4, keep, control, info) @ccall libhsl.ma77_open_d(n::Cint, fname1::Cstring, fname2::Cstring, fname3::Cstring, - fname4::Cstring, keep::Ptr{Ptr{Cvoid}}, control::Ref{ma77_control{Float64}}, + fname4::Cstring, keep::Ptr{Ptr{Cvoid}}, + control::Ref{ma77_control{Float64}}, info::Ref{ma77_info{Float64}})::Cvoid end function ma77_input_vars_d(idx, nvar, list, keep, control, info) @ccall libhsl.ma77_input_vars_d(idx::Cint, nvar::Cint, list::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, - control::Ref{ma77_control{Float64}}, info::Ref{ma77_info{Float64}})::Cvoid + control::Ref{ma77_control{Float64}}, + info::Ref{ma77_info{Float64}})::Cvoid end function ma77_input_reals_d(idx, length, reals, keep, control, info) @@ -210,17 +238,20 @@ end function ma77_analyse_d(order, keep, control, info) @ccall libhsl.ma77_analyse_d(order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, - control::Ref{ma77_control{Float64}}, info::Ref{ma77_info{Float64}})::Cvoid + control::Ref{ma77_control{Float64}}, + info::Ref{ma77_info{Float64}})::Cvoid end function ma77_factor_d(posdef, keep, control, info, scale) - @ccall libhsl.ma77_factor_d(posdef::Cint, keep::Ptr{Ptr{Cvoid}}, control::Ref{ma77_control{Float64}}, + @ccall libhsl.ma77_factor_d(posdef::Cint, keep::Ptr{Ptr{Cvoid}}, + control::Ref{ma77_control{Float64}}, info::Ref{ma77_info{Float64}}, scale::Ptr{Float64})::Cvoid end function ma77_factor_solve_d(posdef, keep, control, info, scale, nrhs, lx, rhs) @ccall libhsl.ma77_factor_solve_d(posdef::Cint, keep::Ptr{Ptr{Cvoid}}, - control::Ref{ma77_control{Float64}}, info::Ref{ma77_info{Float64}}, + control::Ref{ma77_control{Float64}}, + info::Ref{ma77_info{Float64}}, scale::Ptr{Float64}, nrhs::Cint, lx::Cint, rhs::Ptr{Float64})::Cvoid end @@ -246,7 +277,8 @@ end function ma77_enquire_posdef_d(d, keep, control, info) @ccall libhsl.ma77_enquire_posdef_d(d::Ptr{Float64}, keep::Ptr{Ptr{Cvoid}}, - control::Ref{ma77_control{Float64}}, info::Ref{ma77_info{Float64}})::Cvoid + control::Ref{ma77_control{Float64}}, + info::Ref{ma77_info{Float64}})::Cvoid end function ma77_enquire_indef_d(piv_order, d, keep, control, info) @@ -257,13 +289,15 @@ end function ma77_alter_d(d, keep, control, info) @ccall libhsl.ma77_alter_d(d::Ptr{Float64}, keep::Ptr{Ptr{Cvoid}}, - control::Ref{ma77_control{Float64}}, info::Ref{ma77_info{Float64}})::Cvoid + control::Ref{ma77_control{Float64}}, + info::Ref{ma77_info{Float64}})::Cvoid end function ma77_restart_d(restart_file, fname1, fname2, fname3, fname4, keep, control, info) @ccall libhsl.ma77_restart_d(restart_file::Cstring, fname1::Cstring, fname2::Cstring, fname3::Cstring, fname4::Cstring, keep::Ptr{Ptr{Cvoid}}, - control::Ref{ma77_control{Float64}}, info::Ref{ma77_info{Float64}})::Cvoid + control::Ref{ma77_control{Float64}}, + info::Ref{ma77_info{Float64}})::Cvoid end function ma77_finalise_d(keep, control, info) @@ -274,7 +308,8 @@ end function ma77_solve_fredholm_d(nrhs, flag_out, lx, x, keep, control, info, scale) @ccall libhsl.ma77_solve_fredholm_d(nrhs::Cint, flag_out::Ptr{Cint}, lx::Cint, x::Ptr{Float64}, keep::Ptr{Ptr{Cvoid}}, - control::Ref{ma77_control{Float64}}, info::Ref{ma77_info{Float64}}, + control::Ref{ma77_control{Float64}}, + info::Ref{ma77_info{Float64}}, scale::Ptr{Float64})::Cvoid end diff --git a/src/C/hsl_ma86.jl b/src/C/hsl_ma86.jl index 6a82793..da09a85 100644 --- a/src/C/hsl_ma86.jl +++ b/src/C/hsl_ma86.jl @@ -15,9 +15,14 @@ mutable struct ma86_control{T} umin::T scaling::Cint - ma86_control{T}() where T = new() + ma86_control{T}() where {T} = new() - ma86_control{T}(f_arrays, diagnostics_level, unit_diagnostics, unit_error, unit_warning, nemin, nb, action, nbi, pool_size, small_, static_, u, umin, scaling) where T = new(f_arrays, diagnostics_level, unit_diagnostics, unit_error, unit_warning, nemin, nb, action, nbi, pool_size, small_, static_, u, umin, scaling) + function ma86_control{T}(f_arrays, diagnostics_level, unit_diagnostics, unit_error, unit_warning, + nemin, nb, action, nbi, pool_size, small_, static_, u, umin, + scaling) where {T} + return new(f_arrays, diagnostics_level, unit_diagnostics, unit_error, unit_warning, nemin, nb, + action, nbi, pool_size, small_, static_, u, umin, scaling) + end end function ma86_default_control_s(control) @@ -42,9 +47,14 @@ mutable struct ma86_info{T} stat::Cint usmall::T - ma86_info{T}() where T = new() + ma86_info{T}() where {T} = new() - ma86_info{T}(detlog, detsign, flag, matrix_rank, maxdepth, num_delay, num_factor, num_flops, num_neg, num_nodes, num_nothresh, num_perturbed, num_two, pool_size, stat, usmall) where T = new(detlog, detsign, flag, matrix_rank, maxdepth, num_delay, num_factor, num_flops, num_neg, num_nodes, num_nothresh, num_perturbed, num_two, pool_size, stat, usmall) + function ma86_info{T}(detlog, detsign, flag, matrix_rank, maxdepth, num_delay, num_factor, + num_flops, num_neg, num_nodes, num_nothresh, num_perturbed, num_two, + pool_size, stat, usmall) where {T} + return new(detlog, detsign, flag, matrix_rank, maxdepth, num_delay, num_factor, num_flops, + num_neg, num_nodes, num_nothresh, num_perturbed, num_two, pool_size, stat, usmall) + end end function ma86_analyse_s(n, ptr, row, order, keep, control, info) @@ -55,7 +65,8 @@ end function ma86_factor_s(n, ptr, row, val, order, keep, control, info, scale) @ccall libhsl.ma86_factor_s(n::Cint, ptr::Ptr{Cint}, row::Ptr{Cint}, val::Ptr{Float32}, - order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, control::Ref{ma86_control{Float32}}, + order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, + control::Ref{ma86_control{Float32}}, info::Ref{ma86_info{Float32}}, scale::Ptr{Float32})::Cvoid end @@ -69,7 +80,8 @@ end function ma86_solve_s(job, nrhs, ldx, x, order, keep, control, info, scale) @ccall libhsl.ma86_solve_s(job::Cint, nrhs::Cint, ldx::Cint, x::Ptr{Float32}, - order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, control::Ref{ma86_control{Float32}}, + order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, + control::Ref{ma86_control{Float32}}, info::Ref{ma86_info{Float32}}, scale::Ptr{Float32})::Cvoid end @@ -89,7 +101,8 @@ end function ma86_factor_d(n, ptr, row, val, order, keep, control, info, scale) @ccall libhsl.ma86_factor_d(n::Cint, ptr::Ptr{Cint}, row::Ptr{Cint}, val::Ptr{Float64}, - order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, control::Ref{ma86_control{Float64}}, + order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, + control::Ref{ma86_control{Float64}}, info::Ref{ma86_info{Float64}}, scale::Ptr{Float64})::Cvoid end @@ -103,7 +116,8 @@ end function ma86_solve_d(job, nrhs, ldx, x, order, keep, control, info, scale) @ccall libhsl.ma86_solve_d(job::Cint, nrhs::Cint, ldx::Cint, x::Ptr{Float64}, - order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, control::Ref{ma86_control{Float64}}, + order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, + control::Ref{ma86_control{Float64}}, info::Ref{ma86_info{Float64}}, scale::Ptr{Float64})::Cvoid end @@ -139,7 +153,8 @@ end function ma86_solve_c(job, nrhs, ldx, x, order, keep, control, info, scale) @ccall libhsl.ma86_solve_c(job::Cint, nrhs::Cint, ldx::Cint, x::Ptr{ComplexF32}, - order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, control::Ref{ma86_control{Float32}}, + order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, + control::Ref{ma86_control{Float32}}, info::Ref{ma86_info{Float32}}, scale::Ptr{Float32})::Cvoid end @@ -175,7 +190,8 @@ end function ma86_solve_z(job, nrhs, ldx, x, order, keep, control, info, scale) @ccall libhsl.ma86_solve_z(job::Cint, nrhs::Cint, ldx::Cint, x::Ptr{ComplexF64}, - order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, control::Ref{ma86_control{Float64}}, + order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, + control::Ref{ma86_control{Float64}}, info::Ref{ma86_info{Float64}}, scale::Ptr{Float64})::Cvoid end diff --git a/src/C/hsl_ma87.jl b/src/C/hsl_ma87.jl index 216f71c..b1a5de2 100644 --- a/src/C/hsl_ma87.jl +++ b/src/C/hsl_ma87.jl @@ -9,11 +9,15 @@ mutable struct ma87_control{T} pool_size::Cint diag_zero_minus::T diag_zero_plus::T - unused::NTuple{40,Cchar} + unused::NTuple{40, Cchar} - ma87_control{T}() where T = new() + ma87_control{T}() where {T} = new() - ma87_control{T}(f_arrays, diagnostics_level, unit_diagnostics, unit_error, unit_warning, nemin, nb, pool_size, diag_zero_minus, diag_zero_plus, unused) where T = new(f_arrays, diagnostics_level, unit_diagnostics, unit_error, unit_warning, nemin, nb, pool_size, diag_zero_minus, diag_zero_plus, unused) + function ma87_control{T}(f_arrays, diagnostics_level, unit_diagnostics, unit_error, unit_warning, + nemin, nb, pool_size, diag_zero_minus, diag_zero_plus, unused) where {T} + return new(f_arrays, diagnostics_level, unit_diagnostics, unit_error, unit_warning, nemin, nb, + pool_size, diag_zero_minus, diag_zero_plus, unused) + end end function ma87_default_control_s(control) @@ -30,11 +34,15 @@ mutable struct ma87_info{T} pool_size::Cint stat::Cint num_zero::Cint - unused::NTuple{40,Cchar} + unused::NTuple{40, Cchar} - ma87_info{T}() where T = new() + ma87_info{T}() where {T} = new() - ma87_info{T}(detlog, flag, maxdepth, num_factor, num_flops, num_nodes, pool_size, stat, num_zero, unused) where T = new(detlog, flag, maxdepth, num_factor, num_flops, num_nodes, pool_size, stat, num_zero, unused) + function ma87_info{T}(detlog, flag, maxdepth, num_factor, num_flops, num_nodes, pool_size, stat, + num_zero, unused) where {T} + return new(detlog, flag, maxdepth, num_factor, num_flops, num_nodes, pool_size, stat, num_zero, + unused) + end end function ma87_analyse_s(n, ptr, row, order, keep, control, info) @@ -45,7 +53,8 @@ end function ma87_factor_s(n, ptr, row, val, order, keep, control, info) @ccall libhsl.ma87_factor_s(n::Cint, ptr::Ptr{Cint}, row::Ptr{Cint}, val::Ptr{Float32}, - order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, control::Ref{ma87_control{Float32}}, + order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, + control::Ref{ma87_control{Float32}}, info::Ref{ma87_info{Float32}})::Cvoid end @@ -59,7 +68,8 @@ end function ma87_solve_s(job, nrhs, ldx, x, order, keep, control, info) @ccall libhsl.ma87_solve_s(job::Cint, nrhs::Cint, ldx::Cint, x::Ptr{Float32}, - order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, control::Ref{ma87_control{Float32}}, + order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, + control::Ref{ma87_control{Float32}}, info::Ref{ma87_info{Float32}})::Cvoid end @@ -68,7 +78,8 @@ function ma87_sparse_fwd_solve_s(nbi, bindex, b, order, invp, nxi, index, x, w, order::Ptr{Cint}, invp::Ptr{Cint}, nxi::Ptr{Cint}, index::Ptr{Cint}, x::Ptr{Float32}, w::Ptr{Float32}, keep::Ptr{Ptr{Cvoid}}, - control::Ref{ma87_control{Float32}}, info::Ref{ma87_info{Float32}})::Cvoid + control::Ref{ma87_control{Float32}}, + info::Ref{ma87_info{Float32}})::Cvoid end function ma87_finalise_s(keep, control) @@ -87,7 +98,8 @@ end function ma87_factor_d(n, ptr, row, val, order, keep, control, info) @ccall libhsl.ma87_factor_d(n::Cint, ptr::Ptr{Cint}, row::Ptr{Cint}, val::Ptr{Float64}, - order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, control::Ref{ma87_control{Float64}}, + order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, + control::Ref{ma87_control{Float64}}, info::Ref{ma87_info{Float64}})::Cvoid end @@ -101,7 +113,8 @@ end function ma87_solve_d(job, nrhs, ldx, x, order, keep, control, info) @ccall libhsl.ma87_solve_d(job::Cint, nrhs::Cint, ldx::Cint, x::Ptr{Float64}, - order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, control::Ref{ma87_control{Float64}}, + order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, + control::Ref{ma87_control{Float64}}, info::Ref{ma87_info{Float64}})::Cvoid end @@ -110,7 +123,8 @@ function ma87_sparse_fwd_solve_d(nbi, bindex, b, order, invp, nxi, index, x, w, order::Ptr{Cint}, invp::Ptr{Cint}, nxi::Ptr{Cint}, index::Ptr{Cint}, x::Ptr{Float64}, w::Ptr{Float64}, keep::Ptr{Ptr{Cvoid}}, - control::Ref{ma87_control{Float64}}, info::Ref{ma87_info{Float64}})::Cvoid + control::Ref{ma87_control{Float64}}, + info::Ref{ma87_info{Float64}})::Cvoid end function ma87_finalise_d(keep, control) @@ -129,7 +143,8 @@ end function ma87_factor_c(n, ptr, row, val, order, keep, control, info) @ccall libhsl.ma87_factor_c(n::Cint, ptr::Ptr{Cint}, row::Ptr{Cint}, val::Ptr{ComplexF32}, - order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, control::Ref{ma87_control{Float32}}, + order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, + control::Ref{ma87_control{Float32}}, info::Ref{ma87_info{Float32}})::Cvoid end @@ -143,7 +158,8 @@ end function ma87_solve_c(job, nrhs, ldx, x, order, keep, control, info) @ccall libhsl.ma87_solve_c(job::Cint, nrhs::Cint, ldx::Cint, x::Ptr{ComplexF32}, - order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, control::Ref{ma87_control{Float32}}, + order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, + control::Ref{ma87_control{Float32}}, info::Ref{ma87_info{Float32}})::Cvoid end @@ -152,7 +168,8 @@ function ma87_sparse_fwd_solve_c(nbi, bindex, b, order, invp, nxi, index, x, w, order::Ptr{Cint}, invp::Ptr{Cint}, nxi::Ptr{Cint}, index::Ptr{Cint}, x::Ptr{ComplexF32}, w::Ptr{ComplexF32}, keep::Ptr{Ptr{Cvoid}}, - control::Ref{ma87_control{Float32}}, info::Ref{ma87_info{Float32}})::Cvoid + control::Ref{ma87_control{Float32}}, + info::Ref{ma87_info{Float32}})::Cvoid end function ma87_finalise_c(keep, control) @@ -171,7 +188,8 @@ end function ma87_factor_z(n, ptr, row, val, order, keep, control, info) @ccall libhsl.ma87_factor_z(n::Cint, ptr::Ptr{Cint}, row::Ptr{Cint}, val::Ptr{ComplexF64}, - order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, control::Ref{ma87_control{Float64}}, + order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, + control::Ref{ma87_control{Float64}}, info::Ref{ma87_info{Float64}})::Cvoid end @@ -185,7 +203,8 @@ end function ma87_solve_z(job, nrhs, ldx, x, order, keep, control, info) @ccall libhsl.ma87_solve_z(job::Cint, nrhs::Cint, ldx::Cint, x::Ptr{ComplexF64}, - order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, control::Ref{ma87_control{Float64}}, + order::Ptr{Cint}, keep::Ptr{Ptr{Cvoid}}, + control::Ref{ma87_control{Float64}}, info::Ref{ma87_info{Float64}})::Cvoid end @@ -194,7 +213,8 @@ function ma87_sparse_fwd_solve_z(nbi, bindex, b, order, invp, nxi, index, x, w, order::Ptr{Cint}, invp::Ptr{Cint}, nxi::Ptr{Cint}, index::Ptr{Cint}, x::Ptr{ComplexF64}, w::Ptr{ComplexF64}, keep::Ptr{Ptr{Cvoid}}, - control::Ref{ma87_control{Float64}}, info::Ref{ma87_info{Float64}})::Cvoid + control::Ref{ma87_control{Float64}}, + info::Ref{ma87_info{Float64}})::Cvoid end function ma87_finalise_z(keep, control) diff --git a/src/C/hsl_ma97.jl b/src/C/hsl_ma97.jl index f196fa0..9115f11 100644 --- a/src/C/hsl_ma97.jl +++ b/src/C/hsl_ma97.jl @@ -16,44 +16,18 @@ mutable struct ma97_control{T} solve_min::Clong solve_mf::Cint consist_tol::T - ispare::NTuple{5,Cint} - rspare::NTuple{10,T} - - """ - # Main control type for MA97. - - ma97_control{T}(; kwargs...) - - ## Keyword arguments: - - * `print_level::Int`: integer controling the verbosit level. Accepted values are: - * <0: no printing - * 0: errors and warnings only (default) - * 1: errors, warnings and basic diagnostics - * 2: errors, warning and full diagnostics - * `unit_diagnostics::Int`: Fortran file unit for diagnostics (default: 6) - * `unit_error::Int`: Fortran file unit for errors (default: 6) - * `unit_warning::Int`: Fortran file unit for warnings (default: 6) - """ - function ma97_control{T}(; - print_level::Int = -1, - unit_diagnostics::Int = 6, - unit_error::Int = 6, - unit_warning::Int = 6) where {T} - control = ma97_control{T}(0, 0, 0, 0.0, 0, 0, 0, 0.0, 0.0, 0, 0, 0, 0, 0, 0, 0, 0.0, ntuple(x -> Cint(0), 5), ntuple(x -> zero(T), 10)) - T == Float32 && ma97_default_control_s(control) - T == Float64 && ma97_default_control_d(control) - T == ComplexF32 && ma97_default_control_c(control) - T == ComplexF64 && ma97_default_control_z(control) - control.f_arrays = 1 # Use 1-based indexing for arrays, avoiding copies. - control.print_level = print_level - control.unit_diagnostics = unit_diagnostics - control.unit_error = unit_error - control.unit_warning = unit_warning - return control - end + ispare::NTuple{5, Cint} + rspare::NTuple{10, T} + + ma97_control{T}() where {T} = new() - ma97_control{T}(f_arrays, action, nemin, multiplier, ordering, print_level, scaling, small, u, unit_diagnostics, unit_error, unit_warning, factor_min, solve_blas3, solve_min, solve_mf, consist_tol, ispare, rspare) where T = new(f_arrays, action, nemin, multiplier, ordering, print_level, scaling, small, u, unit_diagnostics, unit_error, unit_warning, factor_min, solve_blas3, solve_min, solve_mf, consist_tol, ispare, rspare) + function ma97_control{T}(f_arrays, action, nemin, multiplier, ordering, print_level, scaling, + small, u, unit_diagnostics, unit_error, unit_warning, factor_min, + solve_blas3, solve_min, solve_mf, consist_tol, ispare, rspare) where {T} + return new(f_arrays, action, nemin, multiplier, ordering, print_level, scaling, small, u, + unit_diagnostics, unit_error, unit_warning, factor_min, solve_blas3, solve_min, + solve_mf, consist_tol, ispare, rspare) + end end function ma97_default_control_s(control) @@ -79,21 +53,19 @@ mutable struct ma97_info{T} ordering::Cint stat::Cint maxsupernode::Cint - ispare::NTuple{4,Cint} - rspare::NTuple{10,T} - - """ - # Main info type for MA97 - - info = ma97_info{T}() - - An `info` structure used to collect statistics on the analysis, factorization and solve. - """ - function ma97_info{T}() where {T} - return new(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ntuple(x -> Cint(0), 4), ntuple(x -> zero(T), 10)) + ispare::NTuple{4, Cint} + rspare::NTuple{10, T} + + ma97_info{T}() where {T} = new() + + function ma97_info{T}(flag, flag68, flag77, matrix_dup, matrix_rank, matrix_outrange, + matrix_missing_diag, maxdepth, maxfront, num_delay, num_factor, num_flops, + num_neg, num_sup, num_two, ordering, stat, maxsupernode, ispare, + rspare) where {T} + return new(flag, flag68, flag77, matrix_dup, matrix_rank, matrix_outrange, matrix_missing_diag, + maxdepth, maxfront, num_delay, num_factor, num_flops, num_neg, num_sup, num_two, + ordering, stat, maxsupernode, ispare, rspare) end - - ma97_info{T}(flag, flag68, flag77, matrix_dup, matrix_rank, matrix_outrange, matrix_missing_diag, maxdepth, maxfront, num_delay, num_factor, num_flops, num_neg, num_sup, num_two, ordering, stat, maxsupernode, ispare, rspare) where T = new(flag, flag68, flag77, matrix_dup, matrix_rank, matrix_outrange, matrix_missing_diag, maxdepth, maxfront, num_delay, num_factor, num_flops, num_neg, num_sup, num_two, ordering, stat, maxsupernode, ispare, rspare) end function ma97_analyse_s(check, n, ptr, row, val, akeep, control, info, order) @@ -106,7 +78,8 @@ end function ma97_analyse_coord_s(n, ne, row, col, val, akeep, control, info, order) @ccall libhsl.ma97_analyse_coord_s(n::Cint, ne::Cint, row::Ptr{Cint}, col::Ptr{Cint}, val::Ptr{Float32}, akeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float32}}, info::Ref{ma97_info{Float32}}, + control::Ref{ma97_control{Float32}}, + info::Ref{ma97_info{Float32}}, order::Ptr{Cint})::Cvoid end @@ -122,14 +95,16 @@ function ma97_factor_solve_s(matrix_type, ptr, row, val, nrhs, x, ldx, akeep, fk @ccall libhsl.ma97_factor_solve_s(matrix_type::Cint, ptr::Ptr{Cint}, row::Ptr{Cint}, val::Ptr{Float32}, nrhs::Cint, x::Ptr{Float32}, ldx::Cint, akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float32}}, info::Ref{ma97_info{Float32}}, + control::Ref{ma97_control{Float32}}, + info::Ref{ma97_info{Float32}}, scale::Ptr{Float32})::Cvoid end function ma97_solve_s(job, nrhs, x, ldx, akeep, fkeep, control, info) @ccall libhsl.ma97_solve_s(job::Cint, nrhs::Cint, x::Ptr{Float32}, ldx::Cint, akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float32}}, info::Ref{ma97_info{Float32}})::Cvoid + control::Ref{ma97_control{Float32}}, + info::Ref{ma97_info{Float32}})::Cvoid end function ma97_free_akeep_s(akeep) @@ -146,25 +121,29 @@ end function ma97_enquire_posdef_s(akeep, fkeep, control, info, d) @ccall libhsl.ma97_enquire_posdef_s(akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float32}}, info::Ref{ma97_info{Float32}}, + control::Ref{ma97_control{Float32}}, + info::Ref{ma97_info{Float32}}, d::Ptr{Float32})::Cvoid end function ma97_enquire_indef_s(akeep, fkeep, control, info, piv_order, d) @ccall libhsl.ma97_enquire_indef_s(akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float32}}, info::Ref{ma97_info{Float32}}, + control::Ref{ma97_control{Float32}}, + info::Ref{ma97_info{Float32}}, piv_order::Ptr{Cint}, d::Ptr{Float32})::Cvoid end function ma97_alter_s(d, akeep, fkeep, control, info) @ccall libhsl.ma97_alter_s(d::Ptr{Float32}, akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float32}}, info::Ref{ma97_info{Float32}})::Cvoid + control::Ref{ma97_control{Float32}}, + info::Ref{ma97_info{Float32}})::Cvoid end function ma97_solve_fredholm_s(nrhs, flag_out, x, ldx, akeep, fkeep, control, info) @ccall libhsl.ma97_solve_fredholm_s(nrhs::Cint, flag_out::Ptr{Cint}, x::Ptr{Float32}, ldx::Cint, akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float32}}, info::Ref{ma97_info{Float32}})::Cvoid + control::Ref{ma97_control{Float32}}, + info::Ref{ma97_info{Float32}})::Cvoid end function ma97_lmultiply_s(trans, k, x, ldx, y, ldy, akeep, fkeep, control, info) @@ -196,7 +175,8 @@ end function ma97_analyse_coord_d(n, ne, row, col, val, akeep, control, info, order) @ccall libhsl.ma97_analyse_coord_d(n::Cint, ne::Cint, row::Ptr{Cint}, col::Ptr{Cint}, val::Ptr{Float64}, akeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float64}}, info::Ref{ma97_info{Float64}}, + control::Ref{ma97_control{Float64}}, + info::Ref{ma97_info{Float64}}, order::Ptr{Cint})::Cvoid end @@ -212,14 +192,16 @@ function ma97_factor_solve_d(matrix_type, ptr, row, val, nrhs, x, ldx, akeep, fk @ccall libhsl.ma97_factor_solve_d(matrix_type::Cint, ptr::Ptr{Cint}, row::Ptr{Cint}, val::Ptr{Float64}, nrhs::Cint, x::Ptr{Float64}, ldx::Cint, akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float64}}, info::Ref{ma97_info{Float64}}, + control::Ref{ma97_control{Float64}}, + info::Ref{ma97_info{Float64}}, scale::Ptr{Float64})::Cvoid end function ma97_solve_d(job, nrhs, x, ldx, akeep, fkeep, control, info) @ccall libhsl.ma97_solve_d(job::Cint, nrhs::Cint, x::Ptr{Float64}, ldx::Cint, akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float64}}, info::Ref{ma97_info{Float64}})::Cvoid + control::Ref{ma97_control{Float64}}, + info::Ref{ma97_info{Float64}})::Cvoid end function ma97_free_akeep_d(akeep) @@ -236,25 +218,29 @@ end function ma97_enquire_posdef_d(akeep, fkeep, control, info, d) @ccall libhsl.ma97_enquire_posdef_d(akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float64}}, info::Ref{ma97_info{Float64}}, + control::Ref{ma97_control{Float64}}, + info::Ref{ma97_info{Float64}}, d::Ptr{Float64})::Cvoid end function ma97_enquire_indef_d(akeep, fkeep, control, info, piv_order, d) @ccall libhsl.ma97_enquire_indef_d(akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float64}}, info::Ref{ma97_info{Float64}}, + control::Ref{ma97_control{Float64}}, + info::Ref{ma97_info{Float64}}, piv_order::Ptr{Cint}, d::Ptr{Float64})::Cvoid end function ma97_alter_d(d, akeep, fkeep, control, info) @ccall libhsl.ma97_alter_d(d::Ptr{Float64}, akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float64}}, info::Ref{ma97_info{Float64}})::Cvoid + control::Ref{ma97_control{Float64}}, + info::Ref{ma97_info{Float64}})::Cvoid end function ma97_solve_fredholm_d(nrhs, flag_out, x, ldx, akeep, fkeep, control, info) @ccall libhsl.ma97_solve_fredholm_d(nrhs::Cint, flag_out::Ptr{Cint}, x::Ptr{Float64}, ldx::Cint, akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float64}}, info::Ref{ma97_info{Float64}})::Cvoid + control::Ref{ma97_control{Float64}}, + info::Ref{ma97_info{Float64}})::Cvoid end function ma97_lmultiply_d(trans, k, x, ldx, y, ldy, akeep, fkeep, control, info) @@ -286,7 +272,8 @@ end function ma97_analyse_coord_c(n, ne, row, col, val, akeep, control, info, order) @ccall libhsl.ma97_analyse_coord_c(n::Cint, ne::Cint, row::Ptr{Cint}, col::Ptr{Cint}, val::Ptr{ComplexF32}, akeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float32}}, info::Ref{ma97_info{Float32}}, + control::Ref{ma97_control{Float32}}, + info::Ref{ma97_info{Float32}}, order::Ptr{Cint})::Cvoid end @@ -302,14 +289,16 @@ function ma97_factor_solve_c(matrix_type, ptr, row, val, nrhs, x, ldx, akeep, fk @ccall libhsl.ma97_factor_solve_c(matrix_type::Cint, ptr::Ptr{Cint}, row::Ptr{Cint}, val::Ptr{ComplexF32}, nrhs::Cint, x::Ptr{ComplexF32}, ldx::Cint, akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float32}}, info::Ref{ma97_info{Float32}}, + control::Ref{ma97_control{Float32}}, + info::Ref{ma97_info{Float32}}, scale::Ptr{Float32})::Cvoid end function ma97_solve_c(job, nrhs, x, ldx, akeep, fkeep, control, info) @ccall libhsl.ma97_solve_c(job::Cint, nrhs::Cint, x::Ptr{ComplexF32}, ldx::Cint, akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float32}}, info::Ref{ma97_info{Float32}})::Cvoid + control::Ref{ma97_control{Float32}}, + info::Ref{ma97_info{Float32}})::Cvoid end function ma97_free_akeep_c(akeep) @@ -326,25 +315,29 @@ end function ma97_enquire_posdef_c(akeep, fkeep, control, info, d) @ccall libhsl.ma97_enquire_posdef_c(akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float32}}, info::Ref{ma97_info{Float32}}, + control::Ref{ma97_control{Float32}}, + info::Ref{ma97_info{Float32}}, d::Ptr{Float32})::Cvoid end function ma97_enquire_indef_c(akeep, fkeep, control, info, piv_order, d) @ccall libhsl.ma97_enquire_indef_c(akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float32}}, info::Ref{ma97_info{Float32}}, + control::Ref{ma97_control{Float32}}, + info::Ref{ma97_info{Float32}}, piv_order::Ptr{Cint}, d::Ptr{ComplexF32})::Cvoid end function ma97_alter_c(d, akeep, fkeep, control, info) @ccall libhsl.ma97_alter_c(d::Ptr{ComplexF32}, akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float32}}, info::Ref{ma97_info{Float32}})::Cvoid + control::Ref{ma97_control{Float32}}, + info::Ref{ma97_info{Float32}})::Cvoid end function ma97_solve_fredholm_c(nrhs, flag_out, x, ldx, akeep, fkeep, control, info) @ccall libhsl.ma97_solve_fredholm_c(nrhs::Cint, flag_out::Ptr{Cint}, x::Ptr{ComplexF32}, ldx::Cint, akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float32}}, info::Ref{ma97_info{Float32}})::Cvoid + control::Ref{ma97_control{Float32}}, + info::Ref{ma97_info{Float32}})::Cvoid end function ma97_lmultiply_c(trans, k, x, ldx, y, ldy, akeep, fkeep, control, info) @@ -376,7 +369,8 @@ end function ma97_analyse_coord_z(n, ne, row, col, val, akeep, control, info, order) @ccall libhsl.ma97_analyse_coord_z(n::Cint, ne::Cint, row::Ptr{Cint}, col::Ptr{Cint}, val::Ptr{ComplexF64}, akeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float64}}, info::Ref{ma97_info{Float64}}, + control::Ref{ma97_control{Float64}}, + info::Ref{ma97_info{Float64}}, order::Ptr{Cint})::Cvoid end @@ -392,14 +386,16 @@ function ma97_factor_solve_z(matrix_type, ptr, row, val, nrhs, x, ldx, akeep, fk @ccall libhsl.ma97_factor_solve_z(matrix_type::Cint, ptr::Ptr{Cint}, row::Ptr{Cint}, val::Ptr{ComplexF64}, nrhs::Cint, x::Ptr{ComplexF64}, ldx::Cint, akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float64}}, info::Ref{ma97_info{Float64}}, + control::Ref{ma97_control{Float64}}, + info::Ref{ma97_info{Float64}}, scale::Ptr{Float64})::Cvoid end function ma97_solve_z(job, nrhs, x, ldx, akeep, fkeep, control, info) @ccall libhsl.ma97_solve_z(job::Cint, nrhs::Cint, x::Ptr{ComplexF64}, ldx::Cint, akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float64}}, info::Ref{ma97_info{Float64}})::Cvoid + control::Ref{ma97_control{Float64}}, + info::Ref{ma97_info{Float64}})::Cvoid end function ma97_free_akeep_z(akeep) @@ -416,25 +412,29 @@ end function ma97_enquire_posdef_z(akeep, fkeep, control, info, d) @ccall libhsl.ma97_enquire_posdef_z(akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float64}}, info::Ref{ma97_info{Float64}}, + control::Ref{ma97_control{Float64}}, + info::Ref{ma97_info{Float64}}, d::Ptr{Float64})::Cvoid end function ma97_enquire_indef_z(akeep, fkeep, control, info, piv_order, d) @ccall libhsl.ma97_enquire_indef_z(akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float64}}, info::Ref{ma97_info{Float64}}, + control::Ref{ma97_control{Float64}}, + info::Ref{ma97_info{Float64}}, piv_order::Ptr{Cint}, d::Ptr{ComplexF64})::Cvoid end function ma97_alter_z(d, akeep, fkeep, control, info) @ccall libhsl.ma97_alter_z(d::Ptr{ComplexF64}, akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float64}}, info::Ref{ma97_info{Float64}})::Cvoid + control::Ref{ma97_control{Float64}}, + info::Ref{ma97_info{Float64}})::Cvoid end function ma97_solve_fredholm_z(nrhs, flag_out, x, ldx, akeep, fkeep, control, info) @ccall libhsl.ma97_solve_fredholm_z(nrhs::Cint, flag_out::Ptr{Cint}, x::Ptr{ComplexF64}, ldx::Cint, akeep::Ptr{Ptr{Cvoid}}, fkeep::Ptr{Ptr{Cvoid}}, - control::Ref{ma97_control{Float64}}, info::Ref{ma97_info{Float64}})::Cvoid + control::Ref{ma97_control{Float64}}, + info::Ref{ma97_info{Float64}})::Cvoid end function ma97_lmultiply_z(trans, k, x, ldx, y, ldy, akeep, fkeep, control, info) diff --git a/src/C/hsl_mc68.jl b/src/C/hsl_mc68.jl index f50bd0d..a0ed12d 100644 --- a/src/C/hsl_mc68.jl +++ b/src/C/hsl_mc68.jl @@ -12,7 +12,11 @@ mutable struct mc68_control mc68_control() = new() - mc68_control(f_array_in, f_array_out, min_l_workspace, lp, wp, mp, nemin, print_level, row_full_thresh, row_search) = new(f_array_in, f_array_out, min_l_workspace, lp, wp, mp, nemin, print_level, row_full_thresh, row_search) + function mc68_control(f_array_in, f_array_out, min_l_workspace, lp, wp, mp, nemin, print_level, + row_full_thresh, row_search) + return new(f_array_in, f_array_out, min_l_workspace, lp, wp, mp, nemin, print_level, + row_full_thresh, row_search) + end end function mc68_default_control_i(control) @@ -33,7 +37,11 @@ mutable struct mc68_info mc68_info() = new() - mc68_info(flag, iostat, stat, out_range, duplicate, n_compressions, n_zero_eigs, l_workspace, zb01_info, n_dense_rows) = new(flag, iostat, stat, out_range, duplicate, n_compressions, n_zero_eigs, l_workspace, zb01_info, n_dense_rows) + function mc68_info(flag, iostat, stat, out_range, duplicate, n_compressions, n_zero_eigs, + l_workspace, zb01_info, n_dense_rows) + return new(flag, iostat, stat, out_range, duplicate, n_compressions, n_zero_eigs, l_workspace, + zb01_info, n_dense_rows) + end end function mc68_order_i(ord, n, ptr, row, perm, control, info) diff --git a/src/C/hsl_mc78.jl b/src/C/hsl_mc78.jl index 1f423c6..8a43104 100644 --- a/src/C/hsl_mc78.jl +++ b/src/C/hsl_mc78.jl @@ -1,8 +1,8 @@ mutable struct mc78_control f_arrays::Cint heuristic::Cint - nrelax::NTuple{3,Cint} - zrelax::NTuple{3,Cdouble} + nrelax::NTuple{3, Cint} + zrelax::NTuple{3, Cdouble} nemin::Cint unit_error::Cint unit_warning::Cint @@ -13,7 +13,11 @@ mutable struct mc78_control mc78_control() = new() - mc78_control(f_arrays, heuristic, nrelax, zrelax, nemin, unit_error, unit_warning, ssa_abort, svar, sort, lopt) = new(f_arrays, heuristic, nrelax, zrelax, nemin, unit_error, unit_warning, ssa_abort, svar, sort, lopt) + function mc78_control(f_arrays, heuristic, nrelax, zrelax, nemin, unit_error, unit_warning, + ssa_abort, svar, sort, lopt) + return new(f_arrays, heuristic, nrelax, zrelax, nemin, unit_error, unit_warning, ssa_abort, + svar, sort, lopt) + end end function mc78_default_control_i(control) diff --git a/src/C/hsl_mc79.jl b/src/C/hsl_mc79.jl index 7b3a8fd..6eaf547 100644 --- a/src/C/hsl_mc79.jl +++ b/src/C/hsl_mc79.jl @@ -31,7 +31,9 @@ mutable struct mc79_info mc79_info() = new() - mc79_info(flag, hz_comps, vt_comps, sq_comps, m1, m2, m3, mbar, n1, n2, n3, nbar, stat) = new(flag, hz_comps, vt_comps, sq_comps, m1, m2, m3, mbar, n1, n2, n3, nbar, stat) + function mc79_info(flag, hz_comps, vt_comps, sq_comps, m1, m2, m3, mbar, n1, n2, n3, nbar, stat) + return new(flag, hz_comps, vt_comps, sq_comps, m1, m2, m3, mbar, n1, n2, n3, nbar, stat) + end end function mc79_matching_i(m, n, ptr, row, rowmatch, colmatch, control, info) diff --git a/src/C/hsl_mi20.jl b/src/C/hsl_mi20.jl index 30fd1e8..2b4f533 100644 --- a/src/C/hsl_mi20.jl +++ b/src/C/hsl_mi20.jl @@ -23,9 +23,18 @@ mutable struct mi20_control{T} error::Cint one_pass_coarsen::Cint - mi20_control{T}() where T = new() + mi20_control{T}() where {T} = new() - mi20_control{T}(f_arrays, aggressive, c_fail, max_levels, max_points, reduction, st_method, st_parameter, testing, trunc_parameter, coarse_solver, coarse_solver_its, damping, err_tol, levels, pre_smoothing, smoother, post_smoothing, v_iterations, print_level, print, error, one_pass_coarsen) where T = new(f_arrays, aggressive, c_fail, max_levels, max_points, reduction, st_method, st_parameter, testing, trunc_parameter, coarse_solver, coarse_solver_its, damping, err_tol, levels, pre_smoothing, smoother, post_smoothing, v_iterations, print_level, print, error, one_pass_coarsen) + function mi20_control{T}(f_arrays, aggressive, c_fail, max_levels, max_points, reduction, + st_method, st_parameter, testing, trunc_parameter, coarse_solver, + coarse_solver_its, damping, err_tol, levels, pre_smoothing, smoother, + post_smoothing, v_iterations, print_level, print, error, + one_pass_coarsen) where {T} + return new(f_arrays, aggressive, c_fail, max_levels, max_points, reduction, st_method, + st_parameter, testing, trunc_parameter, coarse_solver, coarse_solver_its, damping, + err_tol, levels, pre_smoothing, smoother, post_smoothing, v_iterations, print_level, + print, error, one_pass_coarsen) + end end function mi20_default_control_s(control) @@ -42,9 +51,13 @@ mutable struct mi20_solve_control{T} preconditioner_side::Cint rel_tol::T - mi20_solve_control{T}() where T = new() + mi20_solve_control{T}() where {T} = new() - mi20_solve_control{T}(abs_tol, breakdown_tol, gmres_restart, init_guess, krylov_solver, max_its, preconditioner_side, rel_tol) where T = new(abs_tol, breakdown_tol, gmres_restart, init_guess, krylov_solver, max_its, preconditioner_side, rel_tol) + function mi20_solve_control{T}(abs_tol, breakdown_tol, gmres_restart, init_guess, krylov_solver, + max_its, preconditioner_side, rel_tol) where {T} + return new(abs_tol, breakdown_tol, gmres_restart, init_guess, krylov_solver, max_its, + preconditioner_side, rel_tol) + end end function mi20_default_solve_control_s(solve_control) @@ -61,9 +74,12 @@ mutable struct mi20_info{T} iterations::Cint residual::T - mi20_info{T}() where T = new() + mi20_info{T}() where {T} = new() - mi20_info{T}(flag, clevels, cpoints, cnnz, stat, getrf_info, iterations, residual) where T = new(flag, clevels, cpoints, cnnz, stat, getrf_info, iterations, residual) + function mi20_info{T}(flag, clevels, cpoints, cnnz, stat, getrf_info, iterations, + residual) where {T} + return new(flag, clevels, cpoints, cnnz, stat, getrf_info, iterations, residual) + end end function mi20_setup_s(n, ptr, col, val, keep, control, info) @@ -87,7 +103,8 @@ end function mi20_setup_coord_s(n, ne, row, col, val, keep, control, info) @ccall libhsl.mi20_setup_coord_s(n::Cint, ne::Cint, row::Ptr{Cint}, col::Ptr{Cint}, val::Ptr{Float32}, keep::Ptr{Ptr{Cvoid}}, - control::Ref{mi20_control{Float32}}, info::Ref{mi20_info{Float32}})::Cvoid + control::Ref{mi20_control{Float32}}, + info::Ref{mi20_info{Float32}})::Cvoid end function mi20_finalize_s(keep, control, info) @@ -137,7 +154,8 @@ end function mi20_setup_coord_d(n, ne, row, col, val, keep, control, info) @ccall libhsl.mi20_setup_coord_d(n::Cint, ne::Cint, row::Ptr{Cint}, col::Ptr{Cint}, val::Ptr{Float64}, keep::Ptr{Ptr{Cvoid}}, - control::Ref{mi20_control{Float64}}, info::Ref{mi20_info{Float64}})::Cvoid + control::Ref{mi20_control{Float64}}, + info::Ref{mi20_info{Float64}})::Cvoid end function mi20_finalize_d(keep, control, info) diff --git a/src/C/hsl_mi28.jl b/src/C/hsl_mi28.jl index 79ec04d..5966c83 100644 --- a/src/C/hsl_mi28.jl +++ b/src/C/hsl_mi28.jl @@ -15,9 +15,14 @@ mutable struct mi28_control{T} unit_error::Cint unit_warning::Cint - mi28_control{T}() where T = new() + mi28_control{T}() where {T} = new() - mi28_control{T}(f_arrays, alpha, check, iorder, iscale, lowalpha, maxshift, rrt, shift_factor, shift_factor2, small, tau1, tau2, unit_error, unit_warning) where T = new(f_arrays, alpha, check, iorder, iscale, lowalpha, maxshift, rrt, shift_factor, shift_factor2, small, tau1, tau2, unit_error, unit_warning) + function mi28_control{T}(f_arrays, alpha, check, iorder, iscale, lowalpha, maxshift, rrt, + shift_factor, shift_factor2, small, tau1, tau2, unit_error, + unit_warning) where {T} + return new(f_arrays, alpha, check, iorder, iscale, lowalpha, maxshift, rrt, shift_factor, + shift_factor2, small, tau1, tau2, unit_error, unit_warning) + end end function mi28_default_control_s(control) @@ -42,9 +47,14 @@ mutable struct mi28_info{T} stat::Cint alpha::T - mi28_info{T}() where T = new() + mi28_info{T}() where {T} = new() - mi28_info{T}(band_after, band_before, dup, flag, flag61, flag64, flag68, flag77, nrestart, nshift, oor, profile_before, profile_after, size_r, stat, alpha) where T = new(band_after, band_before, dup, flag, flag61, flag64, flag68, flag77, nrestart, nshift, oor, profile_before, profile_after, size_r, stat, alpha) + function mi28_info{T}(band_after, band_before, dup, flag, flag61, flag64, flag68, flag77, + nrestart, nshift, oor, profile_before, profile_after, size_r, stat, + alpha) where {T} + return new(band_after, band_before, dup, flag, flag61, flag64, flag68, flag77, nrestart, nshift, + oor, profile_before, profile_after, size_r, stat, alpha) + end end function mi28_factorize_s(n, ptr, row, val, lsize, rsize, keep, control, info, scale, perm) diff --git a/src/Fortran/fa01.jl b/src/Fortran/fa01.jl index 959fd83..82701df 100644 --- a/src/Fortran/fa01.jl +++ b/src/Fortran/fa01.jl @@ -2,30 +2,62 @@ function fa01bd(max, nrand) @ccall libhsl.fa01bd_(max::Ref{Cint}, nrand::Ref{Cint})::Cvoid end +function fa01bd_64(max, nrand) + @ccall libhsl_subset_64.fa01bd_64_(max::Ref{Int64}, nrand::Ref{Int64})::Cvoid +end + function fa01cd(il, ir) @ccall libhsl.fa01cd_(il::Ref{Cint}, ir::Ref{Cint})::Cvoid end +function fa01cd_64(il, ir) + @ccall libhsl_subset_64.fa01cd_64_(il::Ref{Int64}, ir::Ref{Int64})::Cvoid +end + function fa01dd(il, ir) @ccall libhsl.fa01dd_(il::Ref{Cint}, ir::Ref{Cint})::Cvoid end +function fa01dd_64(il, ir) + @ccall libhsl_subset_64.fa01dd_64_(il::Ref{Int64}, ir::Ref{Int64})::Cvoid +end + function fa01ad(i) @ccall libhsl.fa01ad_(i::Ref{Cint})::Float64 end +function fa01ad_64(i) + @ccall libhsl_subset_64.fa01ad_64_(i::Ref{Int64})::Float64 +end + function fa01b(max, nrand) @ccall libhsl.fa01b_(max::Ref{Cint}, nrand::Ref{Cint})::Cvoid end +function fa01b_64(max, nrand) + @ccall libhsl_subset_64.fa01b_64_(max::Ref{Int64}, nrand::Ref{Int64})::Cvoid +end + function fa01c(il, ir) @ccall libhsl.fa01c_(il::Ref{Cint}, ir::Ref{Cint})::Cvoid end +function fa01c_64(il, ir) + @ccall libhsl_subset_64.fa01c_64_(il::Ref{Int64}, ir::Ref{Int64})::Cvoid +end + function fa01d(il, ir) @ccall libhsl.fa01d_(il::Ref{Cint}, ir::Ref{Cint})::Cvoid end +function fa01d_64(il, ir) + @ccall libhsl_subset_64.fa01d_64_(il::Ref{Int64}, ir::Ref{Int64})::Cvoid +end + function fa01a(i) @ccall libhsl.fa01a_(i::Ref{Cint})::Float32 end + +function fa01a_64(i) + @ccall libhsl_subset_64.fa01a_64_(i::Ref{Int64})::Float32 +end diff --git a/src/Fortran/fa04.jl b/src/Fortran/fa04.jl index 56fbbac..416232e 100644 --- a/src/Fortran/fa04.jl +++ b/src/Fortran/fa04.jl @@ -2,30 +2,62 @@ function fa04bd(max, nrand) @ccall libhsl.fa04bd_(max::Ref{Cint}, nrand::Ref{Cint})::Cvoid end +function fa04bd_64(max, nrand) + @ccall libhsl_subset_64.fa04bd_64_(max::Ref{Int64}, nrand::Ref{Int64})::Cvoid +end + function fa04cd(igen) @ccall libhsl.fa04cd_(igen::Ref{Cint})::Cvoid end +function fa04cd_64(igen) + @ccall libhsl_subset_64.fa04cd_64_(igen::Ref{Int64})::Cvoid +end + function fa04dd(igen) @ccall libhsl.fa04dd_(igen::Ref{Cint})::Cvoid end +function fa04dd_64(igen) + @ccall libhsl_subset_64.fa04dd_64_(igen::Ref{Int64})::Cvoid +end + function fa04ad(i) @ccall libhsl.fa04ad_(i::Ref{Cint})::Float64 end +function fa04ad_64(i) + @ccall libhsl_subset_64.fa04ad_64_(i::Ref{Int64})::Float64 +end + function fa04b(max, nrand) @ccall libhsl.fa04b_(max::Ref{Cint}, nrand::Ref{Cint})::Cvoid end +function fa04b_64(max, nrand) + @ccall libhsl_subset_64.fa04b_64_(max::Ref{Int64}, nrand::Ref{Int64})::Cvoid +end + function fa04c(igen) @ccall libhsl.fa04c_(igen::Ref{Cint})::Cvoid end +function fa04c_64(igen) + @ccall libhsl_subset_64.fa04c_64_(igen::Ref{Int64})::Cvoid +end + function fa04d(igen) @ccall libhsl.fa04d_(igen::Ref{Cint})::Cvoid end +function fa04d_64(igen) + @ccall libhsl_subset_64.fa04d_64_(igen::Ref{Int64})::Cvoid +end + function fa04a(i) @ccall libhsl.fa04a_(i::Ref{Cint})::Float32 end + +function fa04a_64(i) + @ccall libhsl_subset_64.fa04a_64_(i::Ref{Int64})::Float32 +end diff --git a/src/Fortran/fa14.jl b/src/Fortran/fa14.jl index aa137c6..acbeb98 100644 --- a/src/Fortran/fa14.jl +++ b/src/Fortran/fa14.jl @@ -2,38 +2,78 @@ function fa14bd(ix, max, nrand) @ccall libhsl.fa14bd_(ix::Ref{Cint}, max::Ref{Cint}, nrand::Ref{Cint})::Cvoid end +function fa14bd_64(ix, max, nrand) + @ccall libhsl_subset_64.fa14bd_64_(ix::Ref{Int64}, max::Ref{Int64}, nrand::Ref{Int64})::Cvoid +end + function fa14cd(ix, igen) @ccall libhsl.fa14cd_(ix::Ref{Cint}, igen::Ref{Cint})::Cvoid end +function fa14cd_64(ix, igen) + @ccall libhsl_subset_64.fa14cd_64_(ix::Ref{Int64}, igen::Ref{Int64})::Cvoid +end + function fa14dd(ix, igen) @ccall libhsl.fa14dd_(ix::Ref{Cint}, igen::Ref{Cint})::Cvoid end +function fa14dd_64(ix, igen) + @ccall libhsl_subset_64.fa14dd_64_(ix::Ref{Int64}, igen::Ref{Int64})::Cvoid +end + function fa14id(ix) @ccall libhsl.fa14id_(ix::Ref{Cint})::Cvoid end +function fa14id_64(ix) + @ccall libhsl_subset_64.fa14id_64_(ix::Ref{Int64})::Cvoid +end + function fa14ad(ix, i) @ccall libhsl.fa14ad_(ix::Ref{Cint}, i::Ref{Cint})::Float64 end +function fa14ad_64(ix, i) + @ccall libhsl_subset_64.fa14ad_64_(ix::Ref{Int64}, i::Ref{Int64})::Float64 +end + function fa14b(ix, max, nrand) @ccall libhsl.fa14b_(ix::Ref{Cint}, max::Ref{Cint}, nrand::Ref{Cint})::Cvoid end +function fa14b_64(ix, max, nrand) + @ccall libhsl_subset_64.fa14b_64_(ix::Ref{Int64}, max::Ref{Int64}, nrand::Ref{Int64})::Cvoid +end + function fa14c(ix, igen) @ccall libhsl.fa14c_(ix::Ref{Cint}, igen::Ref{Cint})::Cvoid end +function fa14c_64(ix, igen) + @ccall libhsl_subset_64.fa14c_64_(ix::Ref{Int64}, igen::Ref{Int64})::Cvoid +end + function fa14d(ix, igen) @ccall libhsl.fa14d_(ix::Ref{Cint}, igen::Ref{Cint})::Cvoid end +function fa14d_64(ix, igen) + @ccall libhsl_subset_64.fa14d_64_(ix::Ref{Int64}, igen::Ref{Int64})::Cvoid +end + function fa14i(ix) @ccall libhsl.fa14i_(ix::Ref{Cint})::Cvoid end +function fa14i_64(ix) + @ccall libhsl_subset_64.fa14i_64_(ix::Ref{Int64})::Cvoid +end + function fa14a(ix, i) @ccall libhsl.fa14a_(ix::Ref{Cint}, i::Ref{Cint})::Float32 end + +function fa14a_64(ix, i) + @ccall libhsl_subset_64.fa14a_64_(ix::Ref{Int64}, i::Ref{Int64})::Float32 +end diff --git a/src/Fortran/fd15.jl b/src/Fortran/fd15.jl index 2d3b36b..ea528eb 100644 --- a/src/Fortran/fd15.jl +++ b/src/Fortran/fd15.jl @@ -2,6 +2,14 @@ function fd15ad(t) @ccall libhsl.fd15ad_(t::Ref{UInt8}, 1::Csize_t)::Float64 end +function fd15ad_64(t) + @ccall libhsl_subset_64.fd15ad_64_(t::Ref{UInt8}, 1::Csize_t)::Float64 +end + function fd15a(t) @ccall libhsl.fd15a_(t::Ref{UInt8}, 1::Csize_t)::Float32 end + +function fd15a_64(t) + @ccall libhsl_subset_64.fd15a_64_(t::Ref{UInt8}, 1::Csize_t)::Float32 +end diff --git a/src/Fortran/kb07.jl b/src/Fortran/kb07.jl index 1b3cb50..1b846c8 100644 --- a/src/Fortran/kb07.jl +++ b/src/Fortran/kb07.jl @@ -2,10 +2,22 @@ function kb07ad(count, n, index) @ccall libhsl.kb07ad_(count::Ptr{Float64}, n::Ref{Cint}, index::Ptr{Cint})::Cvoid end +function kb07ad_64(count, n, index) + @ccall libhsl_subset_64.kb07ad_64_(count::Ptr{Float64}, n::Ref{Int64}, index::Ptr{Int64})::Cvoid +end + function kb07ai(count, n, index) @ccall libhsl.kb07ai_(count::Ptr{Cint}, n::Ref{Cint}, index::Ptr{Cint})::Cvoid end +function kb07ai_64(count, n, index) + @ccall libhsl_subset_64.kb07ai_64_(count::Ptr{Int64}, n::Ref{Int64}, index::Ptr{Int64})::Cvoid +end + function kb07a(count, n, index) @ccall libhsl.kb07a_(count::Ptr{Float32}, n::Ref{Cint}, index::Ptr{Cint})::Cvoid end + +function kb07a_64(count, n, index) + @ccall libhsl_subset_64.kb07a_64_(count::Ptr{Float32}, n::Ref{Int64}, index::Ptr{Int64})::Cvoid +end diff --git a/src/Fortran/la04.jl b/src/Fortran/la04.jl index 65d2b7e..efb7ca7 100644 --- a/src/Fortran/la04.jl +++ b/src/Fortran/la04.jl @@ -8,10 +8,26 @@ function la04ad(a, la, irn, ip, m, n, b, c, bnd, kb, lb, job, cntl, ix, jx, x, z iws::Ptr{Cint}, liws::Ref{Cint})::Cvoid end +function la04ad_64(a, la, irn, ip, m, n, b, c, bnd, kb, lb, job, cntl, ix, jx, x, z, g, rinfo, ws, + lws, iws, liws) + @ccall libhsl_subset_64.la04ad_64_(a::Ptr{Float64}, la::Ref{Int64}, irn::Ptr{Int64}, + ip::Ptr{Int64}, m::Ref{Int64}, n::Ref{Int64}, b::Ptr{Float64}, + c::Ptr{Float64}, bnd::Ptr{Float64}, kb::Ref{Int64}, + lb::Ref{Int64}, job::Ref{Int64}, cntl::Ptr{Float64}, + ix::Ptr{Int64}, jx::Ptr{Int64}, x::Ptr{Float64}, + z::Ptr{Float64}, g::Ptr{Float64}, rinfo::Ptr{Float64}, + ws::Ptr{Float64}, lws::Ref{Int64}, iws::Ptr{Int64}, + liws::Ref{Int64})::Cvoid +end + function la04id(cntl) @ccall libhsl.la04id_(cntl::Ptr{Float64})::Cvoid end +function la04id_64(cntl) + @ccall libhsl_subset_64.la04id_64_(cntl::Ptr{Float64})::Cvoid +end + function la04bd(a, la, irn, ip, m, n, bnd, kb, cntl, ix, g, rinfo, iw, irow, pv, y) @ccall libhsl.la04bd_(a::Ptr{Float64}, la::Ref{Cint}, irn::Ptr{Cint}, ip::Ptr{Cint}, m::Ref{Cint}, n::Ref{Cint}, bnd::Ptr{Float64}, kb::Ref{Cint}, cntl::Ptr{Float64}, @@ -19,6 +35,15 @@ function la04bd(a, la, irn, ip, m, n, bnd, kb, cntl, ix, g, rinfo, iw, irow, pv, irow::Ptr{Cint}, pv::Ptr{Float64}, y::Ptr{Float64})::Cvoid end +function la04bd_64(a, la, irn, ip, m, n, bnd, kb, cntl, ix, g, rinfo, iw, irow, pv, y) + @ccall libhsl_subset_64.la04bd_64_(a::Ptr{Float64}, la::Ref{Int64}, irn::Ptr{Int64}, + ip::Ptr{Int64}, m::Ref{Int64}, n::Ref{Int64}, + bnd::Ptr{Float64}, kb::Ref{Int64}, cntl::Ptr{Float64}, + ix::Ptr{Int64}, g::Ptr{Float64}, rinfo::Ptr{Float64}, + iw::Ptr{Int64}, irow::Ptr{Int64}, pv::Ptr{Float64}, + y::Ptr{Float64})::Cvoid +end + function la04cd(a, la, irn, ip, m, n, b, c, bnd, kb, lb, job, cntl, ix, jx, g, rinfo, x, z, ba, ib, indb, ipb, iwb, v, w, y, yy, i15, c15, iseed) @ccall libhsl.la04cd_(a::Ptr{Float64}, la::Ref{Cint}, irn::Ptr{Cint}, ip::Ptr{Cint}, m::Ref{Cint}, @@ -31,6 +56,20 @@ function la04cd(a, la, irn, ip, m, n, b, c, bnd, kb, lb, job, cntl, ix, jx, g, r c15::Ptr{Float64}, iseed::Ref{Cint})::Cvoid end +function la04cd_64(a, la, irn, ip, m, n, b, c, bnd, kb, lb, job, cntl, ix, jx, g, rinfo, x, z, ba, + ib, indb, ipb, iwb, v, w, y, yy, i15, c15, iseed) + @ccall libhsl_subset_64.la04cd_64_(a::Ptr{Float64}, la::Ref{Int64}, irn::Ptr{Int64}, + ip::Ptr{Int64}, m::Ref{Int64}, n::Ref{Int64}, b::Ptr{Float64}, + c::Ptr{Float64}, bnd::Ptr{Float64}, kb::Ref{Int64}, + lb::Ref{Int64}, job::Ref{Int64}, cntl::Ptr{Float64}, + ix::Ptr{Int64}, jx::Ptr{Int64}, g::Ptr{Float64}, + rinfo::Ptr{Float64}, x::Ptr{Float64}, z::Ptr{Float64}, + ba::Ptr{Float64}, ib::Ref{Int64}, indb::Ptr{Int64}, + ipb::Ptr{Int64}, iwb::Ptr{Int64}, v::Ptr{Float64}, + w::Ptr{Float64}, y::Ptr{Float64}, yy::Ptr{Float64}, + i15::Ptr{Int64}, c15::Ptr{Float64}, iseed::Ref{Int64})::Cvoid +end + function la04dd(a, la, irn, ip, m, n, b, c, bnd, kb, lb, job, cntl, x, ix, jx, z, g, rinfo, ba, indb, ipb, iwb, w, v, ir, y, yy, ib, i15, c15) @ccall libhsl.la04dd_(a::Ptr{Float64}, la::Ref{Cint}, irn::Ptr{Cint}, ip::Ptr{Cint}, m::Ref{Cint}, @@ -43,6 +82,20 @@ function la04dd(a, la, irn, ip, m, n, b, c, bnd, kb, lb, job, cntl, x, ix, jx, z i15::Ptr{Cint}, c15::Ptr{Float64})::Cvoid end +function la04dd_64(a, la, irn, ip, m, n, b, c, bnd, kb, lb, job, cntl, x, ix, jx, z, g, rinfo, ba, + indb, ipb, iwb, w, v, ir, y, yy, ib, i15, c15) + @ccall libhsl_subset_64.la04dd_64_(a::Ptr{Float64}, la::Ref{Int64}, irn::Ptr{Int64}, + ip::Ptr{Int64}, m::Ref{Int64}, n::Ref{Int64}, b::Ptr{Float64}, + c::Ptr{Float64}, bnd::Ptr{Float64}, kb::Ref{Int64}, + lb::Ref{Int64}, job::Ref{Int64}, cntl::Ptr{Float64}, + x::Ptr{Float64}, ix::Ptr{Int64}, jx::Ptr{Int64}, + z::Ptr{Float64}, g::Ptr{Float64}, rinfo::Ptr{Float64}, + ba::Ptr{Float64}, indb::Ptr{Int64}, ipb::Ptr{Int64}, + iwb::Ptr{Int64}, w::Ptr{Float64}, v::Ptr{Float64}, + ir::Ptr{Int64}, y::Ptr{Float64}, yy::Ptr{Float64}, + ib::Ref{Int64}, i15::Ptr{Int64}, c15::Ptr{Float64})::Cvoid +end + function la04ed(a, la, irn, ip, m, n, b, x, dx, ix, jin, rinfo, ba, indb, ipb, iwb, w, y, ib, trans, i15, c15) @ccall libhsl.la04ed_(a::Ptr{Float64}, la::Ref{Cint}, irn::Ptr{Cint}, ip::Ptr{Cint}, m::Ref{Cint}, @@ -53,6 +106,17 @@ function la04ed(a, la, irn, ip, m, n, b, x, dx, ix, jin, rinfo, ba, indb, ipb, i c15::Ptr{Float64})::Cvoid end +function la04ed_64(a, la, irn, ip, m, n, b, x, dx, ix, jin, rinfo, ba, indb, ipb, iwb, w, y, ib, + trans, i15, c15) + @ccall libhsl_subset_64.la04ed_64_(a::Ptr{Float64}, la::Ref{Int64}, irn::Ptr{Int64}, + ip::Ptr{Int64}, m::Ref{Int64}, n::Ref{Int64}, b::Ptr{Float64}, + x::Ptr{Float64}, dx::Ref{Float64}, ix::Ptr{Int64}, + jin::Ref{Int64}, rinfo::Ptr{Float64}, ba::Ptr{Float64}, + indb::Ptr{Int64}, ipb::Ptr{Int64}, iwb::Ptr{Int64}, + w::Ptr{Float64}, y::Ptr{Float64}, ib::Ref{Int64}, + trans::Ref{Int64}, i15::Ptr{Int64}, c15::Ptr{Float64})::Cvoid +end + function la04sd(a, la, irn, ip, m, n, b, c, bnd, kb, sigma, rs, cs, ws, jcn) @ccall libhsl.la04sd_(a::Ptr{Float64}, la::Ref{Cint}, irn::Ptr{Cint}, ip::Ptr{Cint}, m::Ref{Cint}, n::Ref{Cint}, b::Ptr{Float64}, c::Ptr{Float64}, bnd::Ptr{Float64}, @@ -60,6 +124,14 @@ function la04sd(a, la, irn, ip, m, n, b, c, bnd, kb, sigma, rs, cs, ws, jcn) ws::Ptr{Float64}, jcn::Ptr{Cint})::Cvoid end +function la04sd_64(a, la, irn, ip, m, n, b, c, bnd, kb, sigma, rs, cs, ws, jcn) + @ccall libhsl_subset_64.la04sd_64_(a::Ptr{Float64}, la::Ref{Int64}, irn::Ptr{Int64}, + ip::Ptr{Int64}, m::Ref{Int64}, n::Ref{Int64}, b::Ptr{Float64}, + c::Ptr{Float64}, bnd::Ptr{Float64}, kb::Ref{Int64}, + sigma::Ref{Float64}, rs::Ptr{Float64}, cs::Ptr{Float64}, + ws::Ptr{Float64}, jcn::Ptr{Int64})::Cvoid +end + function la04a(a, la, irn, ip, m, n, b, c, bnd, kb, lb, job, cntl, ix, jx, x, z, g, rinfo, ws, lws, iws, liws) @ccall libhsl.la04a_(a::Ptr{Float32}, la::Ref{Cint}, irn::Ptr{Cint}, ip::Ptr{Cint}, m::Ref{Cint}, @@ -70,10 +142,26 @@ function la04a(a, la, irn, ip, m, n, b, c, bnd, kb, lb, job, cntl, ix, jx, x, z, iws::Ptr{Cint}, liws::Ref{Cint})::Cvoid end +function la04a_64(a, la, irn, ip, m, n, b, c, bnd, kb, lb, job, cntl, ix, jx, x, z, g, rinfo, ws, + lws, iws, liws) + @ccall libhsl_subset_64.la04a_64_(a::Ptr{Float32}, la::Ref{Int64}, irn::Ptr{Int64}, + ip::Ptr{Int64}, m::Ref{Int64}, n::Ref{Int64}, b::Ptr{Float32}, + c::Ptr{Float32}, bnd::Ptr{Float32}, kb::Ref{Int64}, + lb::Ref{Int64}, job::Ref{Int64}, cntl::Ptr{Float32}, + ix::Ptr{Int64}, jx::Ptr{Int64}, x::Ptr{Float32}, + z::Ptr{Float32}, g::Ptr{Float32}, rinfo::Ptr{Float32}, + ws::Ptr{Float32}, lws::Ref{Int64}, iws::Ptr{Int64}, + liws::Ref{Int64})::Cvoid +end + function la04i(cntl) @ccall libhsl.la04i_(cntl::Ptr{Float32})::Cvoid end +function la04i_64(cntl) + @ccall libhsl_subset_64.la04i_64_(cntl::Ptr{Float32})::Cvoid +end + function la04b(a, la, irn, ip, m, n, bnd, kb, cntl, ix, g, rinfo, iw, irow, pv, y) @ccall libhsl.la04b_(a::Ptr{Float32}, la::Ref{Cint}, irn::Ptr{Cint}, ip::Ptr{Cint}, m::Ref{Cint}, n::Ref{Cint}, bnd::Ptr{Float32}, kb::Ref{Cint}, cntl::Ptr{Float32}, @@ -81,6 +169,14 @@ function la04b(a, la, irn, ip, m, n, bnd, kb, cntl, ix, g, rinfo, iw, irow, pv, irow::Ptr{Cint}, pv::Ptr{Float32}, y::Ptr{Float32})::Cvoid end +function la04b_64(a, la, irn, ip, m, n, bnd, kb, cntl, ix, g, rinfo, iw, irow, pv, y) + @ccall libhsl_subset_64.la04b_64_(a::Ptr{Float32}, la::Ref{Int64}, irn::Ptr{Int64}, + ip::Ptr{Int64}, m::Ref{Int64}, n::Ref{Int64}, bnd::Ptr{Float32}, + kb::Ref{Int64}, cntl::Ptr{Float32}, ix::Ptr{Int64}, + g::Ptr{Float32}, rinfo::Ptr{Float32}, iw::Ptr{Int64}, + irow::Ptr{Int64}, pv::Ptr{Float32}, y::Ptr{Float32})::Cvoid +end + function la04c(a, la, irn, ip, m, n, b, c, bnd, kb, lb, job, cntl, ix, jx, g, rinfo, x, z, ba, ib, indb, ipb, iwb, v, w, y, yy, i15, c15, iseed) @ccall libhsl.la04c_(a::Ptr{Float32}, la::Ref{Cint}, irn::Ptr{Cint}, ip::Ptr{Cint}, m::Ref{Cint}, @@ -93,6 +189,20 @@ function la04c(a, la, irn, ip, m, n, b, c, bnd, kb, lb, job, cntl, ix, jx, g, ri c15::Ptr{Float32}, iseed::Ref{Cint})::Cvoid end +function la04c_64(a, la, irn, ip, m, n, b, c, bnd, kb, lb, job, cntl, ix, jx, g, rinfo, x, z, ba, + ib, indb, ipb, iwb, v, w, y, yy, i15, c15, iseed) + @ccall libhsl_subset_64.la04c_64_(a::Ptr{Float32}, la::Ref{Int64}, irn::Ptr{Int64}, + ip::Ptr{Int64}, m::Ref{Int64}, n::Ref{Int64}, b::Ptr{Float32}, + c::Ptr{Float32}, bnd::Ptr{Float32}, kb::Ref{Int64}, + lb::Ref{Int64}, job::Ref{Int64}, cntl::Ptr{Float32}, + ix::Ptr{Int64}, jx::Ptr{Int64}, g::Ptr{Float32}, + rinfo::Ptr{Float32}, x::Ptr{Float32}, z::Ptr{Float32}, + ba::Ptr{Float32}, ib::Ref{Int64}, indb::Ptr{Int64}, + ipb::Ptr{Int64}, iwb::Ptr{Int64}, v::Ptr{Float32}, + w::Ptr{Float32}, y::Ptr{Float32}, yy::Ptr{Float32}, + i15::Ptr{Int64}, c15::Ptr{Float32}, iseed::Ref{Int64})::Cvoid +end + function la04d(a, la, irn, ip, m, n, b, c, bnd, kb, lb, job, cntl, x, ix, jx, z, g, rinfo, ba, indb, ipb, iwb, w, v, ir, y, yy, ib, i15, c15) @ccall libhsl.la04d_(a::Ptr{Float32}, la::Ref{Cint}, irn::Ptr{Cint}, ip::Ptr{Cint}, m::Ref{Cint}, @@ -105,6 +215,20 @@ function la04d(a, la, irn, ip, m, n, b, c, bnd, kb, lb, job, cntl, x, ix, jx, z, i15::Ptr{Cint}, c15::Ptr{Float32})::Cvoid end +function la04d_64(a, la, irn, ip, m, n, b, c, bnd, kb, lb, job, cntl, x, ix, jx, z, g, rinfo, ba, + indb, ipb, iwb, w, v, ir, y, yy, ib, i15, c15) + @ccall libhsl_subset_64.la04d_64_(a::Ptr{Float32}, la::Ref{Int64}, irn::Ptr{Int64}, + ip::Ptr{Int64}, m::Ref{Int64}, n::Ref{Int64}, b::Ptr{Float32}, + c::Ptr{Float32}, bnd::Ptr{Float32}, kb::Ref{Int64}, + lb::Ref{Int64}, job::Ref{Int64}, cntl::Ptr{Float32}, + x::Ptr{Float32}, ix::Ptr{Int64}, jx::Ptr{Int64}, + z::Ptr{Float32}, g::Ptr{Float32}, rinfo::Ptr{Float32}, + ba::Ptr{Float32}, indb::Ptr{Int64}, ipb::Ptr{Int64}, + iwb::Ptr{Int64}, w::Ptr{Float32}, v::Ptr{Float32}, + ir::Ptr{Int64}, y::Ptr{Float32}, yy::Ptr{Float32}, + ib::Ref{Int64}, i15::Ptr{Int64}, c15::Ptr{Float32})::Cvoid +end + function la04e(a, la, irn, ip, m, n, b, x, dx, ix, jin, rinfo, ba, indb, ipb, iwb, w, y, ib, trans, i15, c15) @ccall libhsl.la04e_(a::Ptr{Float32}, la::Ref{Cint}, irn::Ptr{Cint}, ip::Ptr{Cint}, m::Ref{Cint}, @@ -115,9 +239,28 @@ function la04e(a, la, irn, ip, m, n, b, x, dx, ix, jin, rinfo, ba, indb, ipb, iw c15::Ptr{Float32})::Cvoid end +function la04e_64(a, la, irn, ip, m, n, b, x, dx, ix, jin, rinfo, ba, indb, ipb, iwb, w, y, ib, + trans, i15, c15) + @ccall libhsl_subset_64.la04e_64_(a::Ptr{Float32}, la::Ref{Int64}, irn::Ptr{Int64}, + ip::Ptr{Int64}, m::Ref{Int64}, n::Ref{Int64}, b::Ptr{Float32}, + x::Ptr{Float32}, dx::Ref{Float32}, ix::Ptr{Int64}, + jin::Ref{Int64}, rinfo::Ptr{Float32}, ba::Ptr{Float32}, + indb::Ptr{Int64}, ipb::Ptr{Int64}, iwb::Ptr{Int64}, + w::Ptr{Float32}, y::Ptr{Float32}, ib::Ref{Int64}, + trans::Ref{Int64}, i15::Ptr{Int64}, c15::Ptr{Float32})::Cvoid +end + function la04s(a, la, irn, ip, m, n, b, c, bnd, kb, sigma, rs, cs, ws, jcn) @ccall libhsl.la04s_(a::Ptr{Float32}, la::Ref{Cint}, irn::Ptr{Cint}, ip::Ptr{Cint}, m::Ref{Cint}, n::Ref{Cint}, b::Ptr{Float32}, c::Ptr{Float32}, bnd::Ptr{Float32}, kb::Ref{Cint}, sigma::Ref{Float32}, rs::Ptr{Float32}, cs::Ptr{Float32}, ws::Ptr{Float32}, jcn::Ptr{Cint})::Cvoid end + +function la04s_64(a, la, irn, ip, m, n, b, c, bnd, kb, sigma, rs, cs, ws, jcn) + @ccall libhsl_subset_64.la04s_64_(a::Ptr{Float32}, la::Ref{Int64}, irn::Ptr{Int64}, + ip::Ptr{Int64}, m::Ref{Int64}, n::Ref{Int64}, b::Ptr{Float32}, + c::Ptr{Float32}, bnd::Ptr{Float32}, kb::Ref{Int64}, + sigma::Ref{Float32}, rs::Ptr{Float32}, cs::Ptr{Float32}, + ws::Ptr{Float32}, jcn::Ptr{Int64})::Cvoid +end diff --git a/src/Fortran/la15.jl b/src/Fortran/la15.jl index e15215b..db3fce9 100644 --- a/src/Fortran/la15.jl +++ b/src/Fortran/la15.jl @@ -2,6 +2,10 @@ function la15id(icntl, cntl, keep) @ccall libhsl.la15id_(icntl::Ptr{Cint}, cntl::Ptr{Float64}, keep::Ptr{Cint})::Cvoid end +function la15id_64(icntl, cntl, keep) + @ccall libhsl_subset_64.la15id_64_(icntl::Ptr{Int64}, cntl::Ptr{Float64}, keep::Ptr{Int64})::Cvoid +end + function la15ad(a, ind, nzero, ia, n, ip, iw, w, g, u, icntl, cntl, keep) @ccall libhsl.la15ad_(a::Ptr{Float64}, ind::Ptr{Cint}, nzero::Ref{Cint}, ia::Ref{Cint}, n::Ref{Cint}, ip::Ptr{Cint}, iw::Ptr{Cint}, w::Ptr{Float64}, @@ -9,28 +13,60 @@ function la15ad(a, ind, nzero, ia, n, ip, iw, w, g, u, icntl, cntl, keep) keep::Ptr{Cint})::Cvoid end +function la15ad_64(a, ind, nzero, ia, n, ip, iw, w, g, u, icntl, cntl, keep) + @ccall libhsl_subset_64.la15ad_64_(a::Ptr{Float64}, ind::Ptr{Int64}, nzero::Ref{Int64}, + ia::Ref{Int64}, n::Ref{Int64}, ip::Ptr{Int64}, iw::Ptr{Int64}, + w::Ptr{Float64}, g::Ref{Float64}, u::Ref{Float64}, + icntl::Ptr{Int64}, cntl::Ptr{Float64}, keep::Ptr{Int64})::Cvoid +end + function la15bd(a, ind, ia, n, ip, iw, w, g, b, trans, icntl, keep) @ccall libhsl.la15bd_(a::Ptr{Float64}, ind::Ptr{Cint}, ia::Ref{Cint}, n::Ref{Cint}, ip::Ptr{Cint}, iw::Ptr{Cint}, w::Ptr{Float64}, g::Ref{Float64}, b::Ptr{Float64}, trans::Ref{Cint}, icntl::Ptr{Cint}, keep::Ptr{Cint})::Cvoid end +function la15bd_64(a, ind, ia, n, ip, iw, w, g, b, trans, icntl, keep) + @ccall libhsl_subset_64.la15bd_64_(a::Ptr{Float64}, ind::Ptr{Int64}, ia::Ref{Int64}, + n::Ref{Int64}, ip::Ptr{Int64}, iw::Ptr{Int64}, w::Ptr{Float64}, + g::Ref{Float64}, b::Ptr{Float64}, trans::Ref{Int64}, + icntl::Ptr{Int64}, keep::Ptr{Int64})::Cvoid +end + function la15cd(a, ind, ia, n, ip, iw, w, g, u, mm, icntl, cntl, keep) @ccall libhsl.la15cd_(a::Ptr{Float64}, ind::Ptr{Cint}, ia::Ref{Cint}, n::Ref{Cint}, ip::Ptr{Cint}, iw::Ptr{Cint}, w::Ptr{Float64}, g::Ref{Float64}, u::Ref{Float64}, mm::Ref{Cint}, icntl::Ptr{Cint}, cntl::Ptr{Float64}, keep::Ptr{Cint})::Cvoid end +function la15cd_64(a, ind, ia, n, ip, iw, w, g, u, mm, icntl, cntl, keep) + @ccall libhsl_subset_64.la15cd_64_(a::Ptr{Float64}, ind::Ptr{Int64}, ia::Ref{Int64}, + n::Ref{Int64}, ip::Ptr{Int64}, iw::Ptr{Int64}, w::Ptr{Float64}, + g::Ref{Float64}, u::Ref{Float64}, mm::Ref{Int64}, + icntl::Ptr{Int64}, cntl::Ptr{Float64}, keep::Ptr{Int64})::Cvoid +end + function la15ed(a, irn, ip, n, iw, ia, reals, ncp, lrow, lcol) @ccall libhsl.la15ed_(a::Ptr{Float64}, irn::Ptr{Cint}, ip::Ptr{Cint}, n::Ref{Cint}, iw::Ptr{Cint}, ia::Ref{Cint}, reals::Ref{Cint}, ncp::Ref{Cint}, lrow::Ref{Cint}, lcol::Ref{Cint})::Cvoid end +function la15ed_64(a, irn, ip, n, iw, ia, reals, ncp, lrow, lcol) + @ccall libhsl_subset_64.la15ed_64_(a::Ptr{Float64}, irn::Ptr{Int64}, ip::Ptr{Int64}, + n::Ref{Int64}, iw::Ptr{Int64}, ia::Ref{Int64}, + reals::Ref{Int64}, ncp::Ref{Int64}, lrow::Ref{Int64}, + lcol::Ref{Int64})::Cvoid +end + function la15i(icntl, cntl, keep) @ccall libhsl.la15i_(icntl::Ptr{Cint}, cntl::Ptr{Float32}, keep::Ptr{Cint})::Cvoid end +function la15i_64(icntl, cntl, keep) + @ccall libhsl_subset_64.la15i_64_(icntl::Ptr{Int64}, cntl::Ptr{Float32}, keep::Ptr{Int64})::Cvoid +end + function la15a(a, ind, nzero, ia, n, ip, iw, w, g, u, icntl, cntl, keep) @ccall libhsl.la15a_(a::Ptr{Float32}, ind::Ptr{Cint}, nzero::Ref{Cint}, ia::Ref{Cint}, n::Ref{Cint}, ip::Ptr{Cint}, iw::Ptr{Cint}, w::Ptr{Float32}, g::Ref{Float32}, @@ -38,20 +74,47 @@ function la15a(a, ind, nzero, ia, n, ip, iw, w, g, u, icntl, cntl, keep) keep::Ptr{Cint})::Cvoid end +function la15a_64(a, ind, nzero, ia, n, ip, iw, w, g, u, icntl, cntl, keep) + @ccall libhsl_subset_64.la15a_64_(a::Ptr{Float32}, ind::Ptr{Int64}, nzero::Ref{Int64}, + ia::Ref{Int64}, n::Ref{Int64}, ip::Ptr{Int64}, iw::Ptr{Int64}, + w::Ptr{Float32}, g::Ref{Float32}, u::Ref{Float32}, + icntl::Ptr{Int64}, cntl::Ptr{Float32}, keep::Ptr{Int64})::Cvoid +end + function la15b(a, ind, ia, n, ip, iw, w, g, b, trans, icntl, keep) @ccall libhsl.la15b_(a::Ptr{Float32}, ind::Ptr{Cint}, ia::Ref{Cint}, n::Ref{Cint}, ip::Ptr{Cint}, iw::Ptr{Cint}, w::Ptr{Float32}, g::Ref{Float32}, b::Ptr{Float32}, trans::Ref{Cint}, icntl::Ptr{Cint}, keep::Ptr{Cint})::Cvoid end +function la15b_64(a, ind, ia, n, ip, iw, w, g, b, trans, icntl, keep) + @ccall libhsl_subset_64.la15b_64_(a::Ptr{Float32}, ind::Ptr{Int64}, ia::Ref{Int64}, n::Ref{Int64}, + ip::Ptr{Int64}, iw::Ptr{Int64}, w::Ptr{Float32}, + g::Ref{Float32}, b::Ptr{Float32}, trans::Ref{Int64}, + icntl::Ptr{Int64}, keep::Ptr{Int64})::Cvoid +end + function la15c(a, ind, ia, n, ip, iw, w, g, u, mm, icntl, cntl, keep) @ccall libhsl.la15c_(a::Ptr{Float32}, ind::Ptr{Cint}, ia::Ref{Cint}, n::Ref{Cint}, ip::Ptr{Cint}, iw::Ptr{Cint}, w::Ptr{Float32}, g::Ref{Float32}, u::Ref{Float32}, mm::Ref{Cint}, icntl::Ptr{Cint}, cntl::Ptr{Float32}, keep::Ptr{Cint})::Cvoid end +function la15c_64(a, ind, ia, n, ip, iw, w, g, u, mm, icntl, cntl, keep) + @ccall libhsl_subset_64.la15c_64_(a::Ptr{Float32}, ind::Ptr{Int64}, ia::Ref{Int64}, n::Ref{Int64}, + ip::Ptr{Int64}, iw::Ptr{Int64}, w::Ptr{Float32}, + g::Ref{Float32}, u::Ref{Float32}, mm::Ref{Int64}, + icntl::Ptr{Int64}, cntl::Ptr{Float32}, keep::Ptr{Int64})::Cvoid +end + function la15e(a, irn, ip, n, iw, ia, reals, ncp, lrow, lcol) @ccall libhsl.la15e_(a::Ptr{Float32}, irn::Ptr{Cint}, ip::Ptr{Cint}, n::Ref{Cint}, iw::Ptr{Cint}, ia::Ref{Cint}, reals::Ref{Cint}, ncp::Ref{Cint}, lrow::Ref{Cint}, lcol::Ref{Cint})::Cvoid end + +function la15e_64(a, irn, ip, n, iw, ia, reals, ncp, lrow, lcol) + @ccall libhsl_subset_64.la15e_64_(a::Ptr{Float32}, irn::Ptr{Int64}, ip::Ptr{Int64}, n::Ref{Int64}, + iw::Ptr{Int64}, ia::Ref{Int64}, reals::Ref{Int64}, + ncp::Ref{Int64}, lrow::Ref{Int64}, lcol::Ref{Int64})::Cvoid +end diff --git a/src/Fortran/ma27.jl b/src/Fortran/ma27.jl index e56f466..9665280 100644 --- a/src/Fortran/ma27.jl +++ b/src/Fortran/ma27.jl @@ -2,6 +2,10 @@ function ma27id(icntl, cntl) @ccall libhsl.ma27id_(icntl::Ptr{Cint}, cntl::Ptr{Float64})::Cvoid end +function ma27id_64(icntl, cntl) + @ccall libhsl_subset_64.ma27id_64_(icntl::Ptr{Int64}, cntl::Ptr{Float64})::Cvoid +end + function ma27ad(n, nz, irn, icn, iw, liw, ikeep, iw1, nsteps, iflag, icntl, cntl, info, ops) @ccall libhsl.ma27ad_(n::Ref{Cint}, nz::Ref{Cint}, irn::Ptr{Cint}, icn::Ptr{Cint}, iw::Ptr{Cint}, liw::Ref{Cint}, ikeep::Ptr{Cint}, iw1::Ptr{Cint}, nsteps::Ref{Cint}, @@ -9,6 +13,14 @@ function ma27ad(n, nz, irn, icn, iw, liw, ikeep, iw1, nsteps, iflag, icntl, cntl ops::Ref{Float64})::Cvoid end +function ma27ad_64(n, nz, irn, icn, iw, liw, ikeep, iw1, nsteps, iflag, icntl, cntl, info, ops) + @ccall libhsl_subset_64.ma27ad_64_(n::Ref{Int64}, nz::Ref{Int64}, irn::Ptr{Int64}, + icn::Ptr{Int64}, iw::Ptr{Int64}, liw::Ref{Int64}, + ikeep::Ptr{Int64}, iw1::Ptr{Int64}, nsteps::Ref{Int64}, + iflag::Ref{Int64}, icntl::Ptr{Int64}, cntl::Ptr{Float64}, + info::Ptr{Int64}, ops::Ref{Float64})::Cvoid +end + function ma27bd(n, nz, irn, icn, a, la, iw, liw, ikeep, nsteps, maxfrt, iw1, icntl, cntl, info) @ccall libhsl.ma27bd_(n::Ref{Cint}, nz::Ref{Cint}, irn::Ptr{Cint}, icn::Ptr{Cint}, a::Ptr{Float64}, la::Ref{Cint}, iw::Ptr{Cint}, liw::Ref{Cint}, @@ -16,18 +28,40 @@ function ma27bd(n, nz, irn, icn, a, la, iw, liw, ikeep, nsteps, maxfrt, iw1, icn icntl::Ptr{Cint}, cntl::Ptr{Float64}, info::Ptr{Cint})::Cvoid end +function ma27bd_64(n, nz, irn, icn, a, la, iw, liw, ikeep, nsteps, maxfrt, iw1, icntl, cntl, info) + @ccall libhsl_subset_64.ma27bd_64_(n::Ref{Int64}, nz::Ref{Int64}, irn::Ptr{Int64}, + icn::Ptr{Int64}, a::Ptr{Float64}, la::Ref{Int64}, + iw::Ptr{Int64}, liw::Ref{Int64}, ikeep::Ptr{Int64}, + nsteps::Ref{Int64}, maxfrt::Ref{Int64}, iw1::Ptr{Int64}, + icntl::Ptr{Int64}, cntl::Ptr{Float64}, info::Ptr{Int64})::Cvoid +end + function ma27cd(n, a, la, iw, liw, w, maxfrt, rhs, iw1, nsteps, icntl, info) @ccall libhsl.ma27cd_(n::Ref{Cint}, a::Ptr{Float64}, la::Ref{Cint}, iw::Ptr{Cint}, liw::Ref{Cint}, w::Ptr{Float64}, maxfrt::Ref{Cint}, rhs::Ptr{Float64}, iw1::Ptr{Cint}, nsteps::Ref{Cint}, icntl::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function ma27cd_64(n, a, la, iw, liw, w, maxfrt, rhs, iw1, nsteps, icntl, info) + @ccall libhsl_subset_64.ma27cd_64_(n::Ref{Int64}, a::Ptr{Float64}, la::Ref{Int64}, iw::Ptr{Int64}, + liw::Ref{Int64}, w::Ptr{Float64}, maxfrt::Ref{Int64}, + rhs::Ptr{Float64}, iw1::Ptr{Int64}, nsteps::Ref{Int64}, + icntl::Ptr{Int64}, info::Ptr{Int64})::Cvoid +end + function ma27gd(n, nz, irn, icn, iw, lw, ipe, iq, flag, iwfr, icntl, info) @ccall libhsl.ma27gd_(n::Ref{Cint}, nz::Ref{Cint}, irn::Ptr{Cint}, icn::Ptr{Cint}, iw::Ptr{Cint}, lw::Ref{Cint}, ipe::Ptr{Cint}, iq::Ptr{Cint}, flag::Ptr{Cint}, iwfr::Ref{Cint}, icntl::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function ma27gd_64(n, nz, irn, icn, iw, lw, ipe, iq, flag, iwfr, icntl, info) + @ccall libhsl_subset_64.ma27gd_64_(n::Ref{Int64}, nz::Ref{Int64}, irn::Ptr{Int64}, + icn::Ptr{Int64}, iw::Ptr{Int64}, lw::Ref{Int64}, + ipe::Ptr{Int64}, iq::Ptr{Int64}, flag::Ptr{Int64}, + iwfr::Ref{Int64}, icntl::Ptr{Int64}, info::Ptr{Int64})::Cvoid +end + function ma27hd(n, ipe, iw, lw, iwfr, nv, nxt, lst, ipd, flag, iovflo, ncmpa, fratio) @ccall libhsl.ma27hd_(n::Ref{Cint}, ipe::Ptr{Cint}, iw::Ptr{Cint}, lw::Ref{Cint}, iwfr::Ref{Cint}, nv::Ptr{Cint}, nxt::Ptr{Cint}, lst::Ptr{Cint}, ipd::Ptr{Cint}, @@ -35,11 +69,24 @@ function ma27hd(n, ipe, iw, lw, iwfr, nv, nxt, lst, ipd, flag, iovflo, ncmpa, fr fratio::Ref{Float64})::Cvoid end +function ma27hd_64(n, ipe, iw, lw, iwfr, nv, nxt, lst, ipd, flag, iovflo, ncmpa, fratio) + @ccall libhsl_subset_64.ma27hd_64_(n::Ref{Int64}, ipe::Ptr{Int64}, iw::Ptr{Int64}, lw::Ref{Int64}, + iwfr::Ref{Int64}, nv::Ptr{Int64}, nxt::Ptr{Int64}, + lst::Ptr{Int64}, ipd::Ptr{Int64}, flag::Ptr{Int64}, + iovflo::Ref{Int64}, ncmpa::Ref{Int64}, + fratio::Ref{Float64})::Cvoid +end + function ma27ud(n, ipe, iw, lw, iwfr, ncmpa) @ccall libhsl.ma27ud_(n::Ref{Cint}, ipe::Ptr{Cint}, iw::Ptr{Cint}, lw::Ref{Cint}, iwfr::Ref{Cint}, ncmpa::Ref{Cint})::Cvoid end +function ma27ud_64(n, ipe, iw, lw, iwfr, ncmpa) + @ccall libhsl_subset_64.ma27ud_64_(n::Ref{Int64}, ipe::Ptr{Int64}, iw::Ptr{Int64}, lw::Ref{Int64}, + iwfr::Ref{Int64}, ncmpa::Ref{Int64})::Cvoid +end + function ma27jd(n, nz, irn, icn, perm, iw, lw, ipe, iq, flag, iwfr, icntl, info) @ccall libhsl.ma27jd_(n::Ref{Cint}, nz::Ref{Cint}, irn::Ptr{Cint}, icn::Ptr{Cint}, perm::Ptr{Cint}, iw::Ptr{Cint}, lw::Ref{Cint}, ipe::Ptr{Cint}, @@ -47,17 +94,37 @@ function ma27jd(n, nz, irn, icn, perm, iw, lw, ipe, iq, flag, iwfr, icntl, info) info::Ptr{Cint})::Cvoid end +function ma27jd_64(n, nz, irn, icn, perm, iw, lw, ipe, iq, flag, iwfr, icntl, info) + @ccall libhsl_subset_64.ma27jd_64_(n::Ref{Int64}, nz::Ref{Int64}, irn::Ptr{Int64}, + icn::Ptr{Int64}, perm::Ptr{Int64}, iw::Ptr{Int64}, + lw::Ref{Int64}, ipe::Ptr{Int64}, iq::Ptr{Int64}, + flag::Ptr{Int64}, iwfr::Ref{Int64}, icntl::Ptr{Int64}, + info::Ptr{Int64})::Cvoid +end + function ma27kd(n, ipe, iw, lw, iwfr, ips, ipv, nv, flag, ncmpa) @ccall libhsl.ma27kd_(n::Ref{Cint}, ipe::Ptr{Cint}, iw::Ptr{Cint}, lw::Ref{Cint}, iwfr::Ref{Cint}, ips::Ptr{Cint}, ipv::Ptr{Cint}, nv::Ptr{Cint}, flag::Ptr{Cint}, ncmpa::Ref{Cint})::Cvoid end +function ma27kd_64(n, ipe, iw, lw, iwfr, ips, ipv, nv, flag, ncmpa) + @ccall libhsl_subset_64.ma27kd_64_(n::Ref{Int64}, ipe::Ptr{Int64}, iw::Ptr{Int64}, lw::Ref{Int64}, + iwfr::Ref{Int64}, ips::Ptr{Int64}, ipv::Ptr{Int64}, + nv::Ptr{Int64}, flag::Ptr{Int64}, ncmpa::Ref{Int64})::Cvoid +end + function ma27ld(n, ipe, nv, ips, ne, na, nd, nsteps, nemin) @ccall libhsl.ma27ld_(n::Ref{Cint}, ipe::Ptr{Cint}, nv::Ptr{Cint}, ips::Ptr{Cint}, ne::Ptr{Cint}, na::Ptr{Cint}, nd::Ptr{Cint}, nsteps::Ref{Cint}, nemin::Ref{Cint})::Cvoid end +function ma27ld_64(n, ipe, nv, ips, ne, na, nd, nsteps, nemin) + @ccall libhsl_subset_64.ma27ld_64_(n::Ref{Int64}, ipe::Ptr{Int64}, nv::Ptr{Int64}, + ips::Ptr{Int64}, ne::Ptr{Int64}, na::Ptr{Int64}, + nd::Ptr{Int64}, nsteps::Ref{Int64}, nemin::Ref{Int64})::Cvoid +end + function ma27md(n, nz, irn, icn, perm, na, ne, nd, nsteps, lstki, lstkr, iw, info, ops) @ccall libhsl.ma27md_(n::Ref{Cint}, nz::Ref{Cint}, irn::Ptr{Cint}, icn::Ptr{Cint}, perm::Ptr{Cint}, na::Ptr{Cint}, ne::Ptr{Cint}, nd::Ptr{Cint}, @@ -65,12 +132,28 @@ function ma27md(n, nz, irn, icn, perm, na, ne, nd, nsteps, lstki, lstkr, iw, inf info::Ptr{Cint}, ops::Ref{Float64})::Cvoid end +function ma27md_64(n, nz, irn, icn, perm, na, ne, nd, nsteps, lstki, lstkr, iw, info, ops) + @ccall libhsl_subset_64.ma27md_64_(n::Ref{Int64}, nz::Ref{Int64}, irn::Ptr{Int64}, + icn::Ptr{Int64}, perm::Ptr{Int64}, na::Ptr{Int64}, + ne::Ptr{Int64}, nd::Ptr{Int64}, nsteps::Ref{Int64}, + lstki::Ptr{Int64}, lstkr::Ptr{Int64}, iw::Ptr{Int64}, + info::Ptr{Int64}, ops::Ref{Float64})::Cvoid +end + function ma27nd(n, nz, nz1, a, la, irn, icn, iw, liw, perm, iw2, icntl, info) @ccall libhsl.ma27nd_(n::Ref{Cint}, nz::Ref{Cint}, nz1::Ref{Cint}, a::Ptr{Float64}, la::Ref{Cint}, irn::Ptr{Cint}, icn::Ptr{Cint}, iw::Ptr{Cint}, liw::Ref{Cint}, perm::Ptr{Cint}, iw2::Ptr{Cint}, icntl::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function ma27nd_64(n, nz, nz1, a, la, irn, icn, iw, liw, perm, iw2, icntl, info) + @ccall libhsl_subset_64.ma27nd_64_(n::Ref{Int64}, nz::Ref{Int64}, nz1::Ref{Int64}, + a::Ptr{Float64}, la::Ref{Int64}, irn::Ptr{Int64}, + icn::Ptr{Int64}, iw::Ptr{Int64}, liw::Ref{Int64}, + perm::Ptr{Int64}, iw2::Ptr{Int64}, icntl::Ptr{Int64}, + info::Ptr{Int64})::Cvoid +end + function ma27od(n, nz, a, la, iw, liw, perm, nstk, nsteps, maxfrt, nelim, iw2, icntl, cntl, info) @ccall libhsl.ma27od_(n::Ref{Cint}, nz::Ref{Cint}, a::Ptr{Float64}, la::Ref{Cint}, iw::Ptr{Cint}, liw::Ref{Cint}, perm::Ptr{Cint}, nstk::Ptr{Cint}, nsteps::Ref{Cint}, @@ -78,28 +161,60 @@ function ma27od(n, nz, a, la, iw, liw, perm, nstk, nsteps, maxfrt, nelim, iw2, i cntl::Ptr{Float64}, info::Ptr{Cint})::Cvoid end +function ma27od_64(n, nz, a, la, iw, liw, perm, nstk, nsteps, maxfrt, nelim, iw2, icntl, cntl, info) + @ccall libhsl_subset_64.ma27od_64_(n::Ref{Int64}, nz::Ref{Int64}, a::Ptr{Float64}, la::Ref{Int64}, + iw::Ptr{Int64}, liw::Ref{Int64}, perm::Ptr{Int64}, + nstk::Ptr{Int64}, nsteps::Ref{Int64}, maxfrt::Ref{Int64}, + nelim::Ptr{Int64}, iw2::Ptr{Int64}, icntl::Ptr{Int64}, + cntl::Ptr{Float64}, info::Ptr{Int64})::Cvoid +end + function ma27pd(a, iw, j1, j2, itop, ireal, ncmpbr, ncmpbi) @ccall libhsl.ma27pd_(a::Ptr{Float64}, iw::Ptr{Cint}, j1::Ref{Cint}, j2::Ref{Cint}, itop::Ref{Cint}, ireal::Ref{Cint}, ncmpbr::Ref{Cint}, ncmpbi::Ref{Cint})::Cvoid end +function ma27pd_64(a, iw, j1, j2, itop, ireal, ncmpbr, ncmpbi) + @ccall libhsl_subset_64.ma27pd_64_(a::Ptr{Float64}, iw::Ptr{Int64}, j1::Ref{Int64}, + j2::Ref{Int64}, itop::Ref{Int64}, ireal::Ref{Int64}, + ncmpbr::Ref{Int64}, ncmpbi::Ref{Int64})::Cvoid +end + function ma27qd(n, a, la, iw, liw, w, maxfnt, rhs, iw2, nblk, latop, icntl) @ccall libhsl.ma27qd_(n::Ref{Cint}, a::Ptr{Float64}, la::Ref{Cint}, iw::Ptr{Cint}, liw::Ref{Cint}, w::Ptr{Float64}, maxfnt::Ref{Cint}, rhs::Ptr{Float64}, iw2::Ptr{Cint}, nblk::Ref{Cint}, latop::Ref{Cint}, icntl::Ptr{Cint})::Cvoid end +function ma27qd_64(n, a, la, iw, liw, w, maxfnt, rhs, iw2, nblk, latop, icntl) + @ccall libhsl_subset_64.ma27qd_64_(n::Ref{Int64}, a::Ptr{Float64}, la::Ref{Int64}, iw::Ptr{Int64}, + liw::Ref{Int64}, w::Ptr{Float64}, maxfnt::Ref{Int64}, + rhs::Ptr{Float64}, iw2::Ptr{Int64}, nblk::Ref{Int64}, + latop::Ref{Int64}, icntl::Ptr{Int64})::Cvoid +end + function ma27rd(n, a, la, iw, liw, w, maxfnt, rhs, iw2, nblk, latop, icntl) @ccall libhsl.ma27rd_(n::Ref{Cint}, a::Ptr{Float64}, la::Ref{Cint}, iw::Ptr{Cint}, liw::Ref{Cint}, w::Ptr{Float64}, maxfnt::Ref{Cint}, rhs::Ptr{Float64}, iw2::Ptr{Cint}, nblk::Ref{Cint}, latop::Ref{Cint}, icntl::Ptr{Cint})::Cvoid end +function ma27rd_64(n, a, la, iw, liw, w, maxfnt, rhs, iw2, nblk, latop, icntl) + @ccall libhsl_subset_64.ma27rd_64_(n::Ref{Int64}, a::Ptr{Float64}, la::Ref{Int64}, iw::Ptr{Int64}, + liw::Ref{Int64}, w::Ptr{Float64}, maxfnt::Ref{Int64}, + rhs::Ptr{Float64}, iw2::Ptr{Int64}, nblk::Ref{Int64}, + latop::Ref{Int64}, icntl::Ptr{Int64})::Cvoid +end + function ma27i(icntl, cntl) @ccall libhsl.ma27i_(icntl::Ptr{Cint}, cntl::Ptr{Float32})::Cvoid end +function ma27i_64(icntl, cntl) + @ccall libhsl_subset_64.ma27i_64_(icntl::Ptr{Int64}, cntl::Ptr{Float32})::Cvoid +end + function ma27a(n, nz, irn, icn, iw, liw, ikeep, iw1, nsteps, iflag, icntl, cntl, info, ops) @ccall libhsl.ma27a_(n::Ref{Cint}, nz::Ref{Cint}, irn::Ptr{Cint}, icn::Ptr{Cint}, iw::Ptr{Cint}, liw::Ref{Cint}, ikeep::Ptr{Cint}, iw1::Ptr{Cint}, nsteps::Ref{Cint}, @@ -107,6 +222,14 @@ function ma27a(n, nz, irn, icn, iw, liw, ikeep, iw1, nsteps, iflag, icntl, cntl, ops::Ref{Float32})::Cvoid end +function ma27a_64(n, nz, irn, icn, iw, liw, ikeep, iw1, nsteps, iflag, icntl, cntl, info, ops) + @ccall libhsl_subset_64.ma27a_64_(n::Ref{Int64}, nz::Ref{Int64}, irn::Ptr{Int64}, icn::Ptr{Int64}, + iw::Ptr{Int64}, liw::Ref{Int64}, ikeep::Ptr{Int64}, + iw1::Ptr{Int64}, nsteps::Ref{Int64}, iflag::Ref{Int64}, + icntl::Ptr{Int64}, cntl::Ptr{Float32}, info::Ptr{Int64}, + ops::Ref{Float32})::Cvoid +end + function ma27b(n, nz, irn, icn, a, la, iw, liw, ikeep, nsteps, maxfrt, iw1, icntl, cntl, info) @ccall libhsl.ma27b_(n::Ref{Cint}, nz::Ref{Cint}, irn::Ptr{Cint}, icn::Ptr{Cint}, a::Ptr{Float32}, la::Ref{Cint}, iw::Ptr{Cint}, liw::Ref{Cint}, ikeep::Ptr{Cint}, @@ -114,18 +237,40 @@ function ma27b(n, nz, irn, icn, a, la, iw, liw, ikeep, nsteps, maxfrt, iw1, icnt cntl::Ptr{Float32}, info::Ptr{Cint})::Cvoid end +function ma27b_64(n, nz, irn, icn, a, la, iw, liw, ikeep, nsteps, maxfrt, iw1, icntl, cntl, info) + @ccall libhsl_subset_64.ma27b_64_(n::Ref{Int64}, nz::Ref{Int64}, irn::Ptr{Int64}, icn::Ptr{Int64}, + a::Ptr{Float32}, la::Ref{Int64}, iw::Ptr{Int64}, + liw::Ref{Int64}, ikeep::Ptr{Int64}, nsteps::Ref{Int64}, + maxfrt::Ref{Int64}, iw1::Ptr{Int64}, icntl::Ptr{Int64}, + cntl::Ptr{Float32}, info::Ptr{Int64})::Cvoid +end + function ma27c(n, a, la, iw, liw, w, maxfrt, rhs, iw1, nsteps, icntl, info) @ccall libhsl.ma27c_(n::Ref{Cint}, a::Ptr{Float32}, la::Ref{Cint}, iw::Ptr{Cint}, liw::Ref{Cint}, w::Ptr{Float32}, maxfrt::Ref{Cint}, rhs::Ptr{Float32}, iw1::Ptr{Cint}, nsteps::Ref{Cint}, icntl::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function ma27c_64(n, a, la, iw, liw, w, maxfrt, rhs, iw1, nsteps, icntl, info) + @ccall libhsl_subset_64.ma27c_64_(n::Ref{Int64}, a::Ptr{Float32}, la::Ref{Int64}, iw::Ptr{Int64}, + liw::Ref{Int64}, w::Ptr{Float32}, maxfrt::Ref{Int64}, + rhs::Ptr{Float32}, iw1::Ptr{Int64}, nsteps::Ref{Int64}, + icntl::Ptr{Int64}, info::Ptr{Int64})::Cvoid +end + function ma27g(n, nz, irn, icn, iw, lw, ipe, iq, flag, iwfr, icntl, info) @ccall libhsl.ma27g_(n::Ref{Cint}, nz::Ref{Cint}, irn::Ptr{Cint}, icn::Ptr{Cint}, iw::Ptr{Cint}, lw::Ref{Cint}, ipe::Ptr{Cint}, iq::Ptr{Cint}, flag::Ptr{Cint}, iwfr::Ref{Cint}, icntl::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function ma27g_64(n, nz, irn, icn, iw, lw, ipe, iq, flag, iwfr, icntl, info) + @ccall libhsl_subset_64.ma27g_64_(n::Ref{Int64}, nz::Ref{Int64}, irn::Ptr{Int64}, icn::Ptr{Int64}, + iw::Ptr{Int64}, lw::Ref{Int64}, ipe::Ptr{Int64}, iq::Ptr{Int64}, + flag::Ptr{Int64}, iwfr::Ref{Int64}, icntl::Ptr{Int64}, + info::Ptr{Int64})::Cvoid +end + function ma27h(n, ipe, iw, lw, iwfr, nv, nxt, lst, ipd, flag, iovflo, ncmpa, fratio) @ccall libhsl.ma27h_(n::Ref{Cint}, ipe::Ptr{Cint}, iw::Ptr{Cint}, lw::Ref{Cint}, iwfr::Ref{Cint}, nv::Ptr{Cint}, nxt::Ptr{Cint}, lst::Ptr{Cint}, ipd::Ptr{Cint}, @@ -133,28 +278,60 @@ function ma27h(n, ipe, iw, lw, iwfr, nv, nxt, lst, ipd, flag, iovflo, ncmpa, fra fratio::Ref{Float32})::Cvoid end +function ma27h_64(n, ipe, iw, lw, iwfr, nv, nxt, lst, ipd, flag, iovflo, ncmpa, fratio) + @ccall libhsl_subset_64.ma27h_64_(n::Ref{Int64}, ipe::Ptr{Int64}, iw::Ptr{Int64}, lw::Ref{Int64}, + iwfr::Ref{Int64}, nv::Ptr{Int64}, nxt::Ptr{Int64}, + lst::Ptr{Int64}, ipd::Ptr{Int64}, flag::Ptr{Int64}, + iovflo::Ref{Int64}, ncmpa::Ref{Int64}, + fratio::Ref{Float32})::Cvoid +end + function ma27u(n, ipe, iw, lw, iwfr, ncmpa) @ccall libhsl.ma27u_(n::Ref{Cint}, ipe::Ptr{Cint}, iw::Ptr{Cint}, lw::Ref{Cint}, iwfr::Ref{Cint}, ncmpa::Ref{Cint})::Cvoid end +function ma27u_64(n, ipe, iw, lw, iwfr, ncmpa) + @ccall libhsl_subset_64.ma27u_64_(n::Ref{Int64}, ipe::Ptr{Int64}, iw::Ptr{Int64}, lw::Ref{Int64}, + iwfr::Ref{Int64}, ncmpa::Ref{Int64})::Cvoid +end + function ma27j(n, nz, irn, icn, perm, iw, lw, ipe, iq, flag, iwfr, icntl, info) @ccall libhsl.ma27j_(n::Ref{Cint}, nz::Ref{Cint}, irn::Ptr{Cint}, icn::Ptr{Cint}, perm::Ptr{Cint}, iw::Ptr{Cint}, lw::Ref{Cint}, ipe::Ptr{Cint}, iq::Ptr{Cint}, flag::Ptr{Cint}, iwfr::Ref{Cint}, icntl::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function ma27j_64(n, nz, irn, icn, perm, iw, lw, ipe, iq, flag, iwfr, icntl, info) + @ccall libhsl_subset_64.ma27j_64_(n::Ref{Int64}, nz::Ref{Int64}, irn::Ptr{Int64}, icn::Ptr{Int64}, + perm::Ptr{Int64}, iw::Ptr{Int64}, lw::Ref{Int64}, + ipe::Ptr{Int64}, iq::Ptr{Int64}, flag::Ptr{Int64}, + iwfr::Ref{Int64}, icntl::Ptr{Int64}, info::Ptr{Int64})::Cvoid +end + function ma27k(n, ipe, iw, lw, iwfr, ips, ipv, nv, flag, ncmpa) @ccall libhsl.ma27k_(n::Ref{Cint}, ipe::Ptr{Cint}, iw::Ptr{Cint}, lw::Ref{Cint}, iwfr::Ref{Cint}, ips::Ptr{Cint}, ipv::Ptr{Cint}, nv::Ptr{Cint}, flag::Ptr{Cint}, ncmpa::Ref{Cint})::Cvoid end +function ma27k_64(n, ipe, iw, lw, iwfr, ips, ipv, nv, flag, ncmpa) + @ccall libhsl_subset_64.ma27k_64_(n::Ref{Int64}, ipe::Ptr{Int64}, iw::Ptr{Int64}, lw::Ref{Int64}, + iwfr::Ref{Int64}, ips::Ptr{Int64}, ipv::Ptr{Int64}, + nv::Ptr{Int64}, flag::Ptr{Int64}, ncmpa::Ref{Int64})::Cvoid +end + function ma27l(n, ipe, nv, ips, ne, na, nd, nsteps, nemin) @ccall libhsl.ma27l_(n::Ref{Cint}, ipe::Ptr{Cint}, nv::Ptr{Cint}, ips::Ptr{Cint}, ne::Ptr{Cint}, na::Ptr{Cint}, nd::Ptr{Cint}, nsteps::Ref{Cint}, nemin::Ref{Cint})::Cvoid end +function ma27l_64(n, ipe, nv, ips, ne, na, nd, nsteps, nemin) + @ccall libhsl_subset_64.ma27l_64_(n::Ref{Int64}, ipe::Ptr{Int64}, nv::Ptr{Int64}, ips::Ptr{Int64}, + ne::Ptr{Int64}, na::Ptr{Int64}, nd::Ptr{Int64}, + nsteps::Ref{Int64}, nemin::Ref{Int64})::Cvoid +end + function ma27m(n, nz, irn, icn, perm, na, ne, nd, nsteps, lstki, lstkr, iw, info, ops) @ccall libhsl.ma27m_(n::Ref{Cint}, nz::Ref{Cint}, irn::Ptr{Cint}, icn::Ptr{Cint}, perm::Ptr{Cint}, na::Ptr{Cint}, ne::Ptr{Cint}, nd::Ptr{Cint}, nsteps::Ref{Cint}, @@ -162,12 +339,27 @@ function ma27m(n, nz, irn, icn, perm, na, ne, nd, nsteps, lstki, lstkr, iw, info ops::Ref{Float32})::Cvoid end +function ma27m_64(n, nz, irn, icn, perm, na, ne, nd, nsteps, lstki, lstkr, iw, info, ops) + @ccall libhsl_subset_64.ma27m_64_(n::Ref{Int64}, nz::Ref{Int64}, irn::Ptr{Int64}, icn::Ptr{Int64}, + perm::Ptr{Int64}, na::Ptr{Int64}, ne::Ptr{Int64}, + nd::Ptr{Int64}, nsteps::Ref{Int64}, lstki::Ptr{Int64}, + lstkr::Ptr{Int64}, iw::Ptr{Int64}, info::Ptr{Int64}, + ops::Ref{Float32})::Cvoid +end + function ma27n(n, nz, nz1, a, la, irn, icn, iw, liw, perm, iw2, icntl, info) @ccall libhsl.ma27n_(n::Ref{Cint}, nz::Ref{Cint}, nz1::Ref{Cint}, a::Ptr{Float32}, la::Ref{Cint}, irn::Ptr{Cint}, icn::Ptr{Cint}, iw::Ptr{Cint}, liw::Ref{Cint}, perm::Ptr{Cint}, iw2::Ptr{Cint}, icntl::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function ma27n_64(n, nz, nz1, a, la, irn, icn, iw, liw, perm, iw2, icntl, info) + @ccall libhsl_subset_64.ma27n_64_(n::Ref{Int64}, nz::Ref{Int64}, nz1::Ref{Int64}, a::Ptr{Float32}, + la::Ref{Int64}, irn::Ptr{Int64}, icn::Ptr{Int64}, + iw::Ptr{Int64}, liw::Ref{Int64}, perm::Ptr{Int64}, + iw2::Ptr{Int64}, icntl::Ptr{Int64}, info::Ptr{Int64})::Cvoid +end + function ma27o(n, nz, a, la, iw, liw, perm, nstk, nsteps, maxfrt, nelim, iw2, icntl, cntl, info) @ccall libhsl.ma27o_(n::Ref{Cint}, nz::Ref{Cint}, a::Ptr{Float32}, la::Ref{Cint}, iw::Ptr{Cint}, liw::Ref{Cint}, perm::Ptr{Cint}, nstk::Ptr{Cint}, nsteps::Ref{Cint}, @@ -175,20 +367,48 @@ function ma27o(n, nz, a, la, iw, liw, perm, nstk, nsteps, maxfrt, nelim, iw2, ic cntl::Ptr{Float32}, info::Ptr{Cint})::Cvoid end +function ma27o_64(n, nz, a, la, iw, liw, perm, nstk, nsteps, maxfrt, nelim, iw2, icntl, cntl, info) + @ccall libhsl_subset_64.ma27o_64_(n::Ref{Int64}, nz::Ref{Int64}, a::Ptr{Float32}, la::Ref{Int64}, + iw::Ptr{Int64}, liw::Ref{Int64}, perm::Ptr{Int64}, + nstk::Ptr{Int64}, nsteps::Ref{Int64}, maxfrt::Ref{Int64}, + nelim::Ptr{Int64}, iw2::Ptr{Int64}, icntl::Ptr{Int64}, + cntl::Ptr{Float32}, info::Ptr{Int64})::Cvoid +end + function ma27p(a, iw, j1, j2, itop, ireal, ncmpbr, ncmpbi) @ccall libhsl.ma27p_(a::Ptr{Float32}, iw::Ptr{Cint}, j1::Ref{Cint}, j2::Ref{Cint}, itop::Ref{Cint}, ireal::Ref{Cint}, ncmpbr::Ref{Cint}, ncmpbi::Ref{Cint})::Cvoid end +function ma27p_64(a, iw, j1, j2, itop, ireal, ncmpbr, ncmpbi) + @ccall libhsl_subset_64.ma27p_64_(a::Ptr{Float32}, iw::Ptr{Int64}, j1::Ref{Int64}, j2::Ref{Int64}, + itop::Ref{Int64}, ireal::Ref{Int64}, ncmpbr::Ref{Int64}, + ncmpbi::Ref{Int64})::Cvoid +end + function ma27q(n, a, la, iw, liw, w, maxfnt, rhs, iw2, nblk, latop, icntl) @ccall libhsl.ma27q_(n::Ref{Cint}, a::Ptr{Float32}, la::Ref{Cint}, iw::Ptr{Cint}, liw::Ref{Cint}, w::Ptr{Float32}, maxfnt::Ref{Cint}, rhs::Ptr{Float32}, iw2::Ptr{Cint}, nblk::Ref{Cint}, latop::Ref{Cint}, icntl::Ptr{Cint})::Cvoid end +function ma27q_64(n, a, la, iw, liw, w, maxfnt, rhs, iw2, nblk, latop, icntl) + @ccall libhsl_subset_64.ma27q_64_(n::Ref{Int64}, a::Ptr{Float32}, la::Ref{Int64}, iw::Ptr{Int64}, + liw::Ref{Int64}, w::Ptr{Float32}, maxfnt::Ref{Int64}, + rhs::Ptr{Float32}, iw2::Ptr{Int64}, nblk::Ref{Int64}, + latop::Ref{Int64}, icntl::Ptr{Int64})::Cvoid +end + function ma27r(n, a, la, iw, liw, w, maxfnt, rhs, iw2, nblk, latop, icntl) @ccall libhsl.ma27r_(n::Ref{Cint}, a::Ptr{Float32}, la::Ref{Cint}, iw::Ptr{Cint}, liw::Ref{Cint}, w::Ptr{Float32}, maxfnt::Ref{Cint}, rhs::Ptr{Float32}, iw2::Ptr{Cint}, nblk::Ref{Cint}, latop::Ref{Cint}, icntl::Ptr{Cint})::Cvoid end + +function ma27r_64(n, a, la, iw, liw, w, maxfnt, rhs, iw2, nblk, latop, icntl) + @ccall libhsl_subset_64.ma27r_64_(n::Ref{Int64}, a::Ptr{Float32}, la::Ref{Int64}, iw::Ptr{Int64}, + liw::Ref{Int64}, w::Ptr{Float32}, maxfnt::Ref{Int64}, + rhs::Ptr{Float32}, iw2::Ptr{Int64}, nblk::Ref{Int64}, + latop::Ref{Int64}, icntl::Ptr{Int64})::Cvoid +end diff --git a/src/Fortran/ma28.jl b/src/Fortran/ma28.jl index b65ec38..2b103d6 100644 --- a/src/Fortran/ma28.jl +++ b/src/Fortran/ma28.jl @@ -4,18 +4,38 @@ function ma28ad(n, nz, a, licn, irn, lirn, icn, u, ikeep, iw, w, iflag) ikeep::Ptr{Cint}, iw::Ptr{Cint}, w::Ptr{Float64}, iflag::Ref{Cint})::Cvoid end +function ma28ad_64(n, nz, a, licn, irn, lirn, icn, u, ikeep, iw, w, iflag) + @ccall libhsl_subset_64.ma28ad_64_(n::Ref{Int64}, nz::Ref{Int64}, a::Ptr{Float64}, + licn::Ref{Int64}, irn::Ptr{Int64}, lirn::Ref{Int64}, + icn::Ptr{Int64}, u::Ref{Float64}, ikeep::Ptr{Int64}, + iw::Ptr{Int64}, w::Ptr{Float64}, iflag::Ref{Int64})::Cvoid +end + function ma28bd(n, nz, a, licn, ivect, jvect, icn, ikeep, iw, w, iflag) @ccall libhsl.ma28bd_(n::Ref{Cint}, nz::Ref{Cint}, a::Ptr{Float64}, licn::Ref{Cint}, ivect::Ptr{Cint}, jvect::Ptr{Cint}, icn::Ptr{Cint}, ikeep::Ptr{Cint}, iw::Ptr{Cint}, w::Ptr{Float64}, iflag::Ref{Cint})::Cvoid end +function ma28bd_64(n, nz, a, licn, ivect, jvect, icn, ikeep, iw, w, iflag) + @ccall libhsl_subset_64.ma28bd_64_(n::Ref{Int64}, nz::Ref{Int64}, a::Ptr{Float64}, + licn::Ref{Int64}, ivect::Ptr{Int64}, jvect::Ptr{Int64}, + icn::Ptr{Int64}, ikeep::Ptr{Int64}, iw::Ptr{Int64}, + w::Ptr{Float64}, iflag::Ref{Int64})::Cvoid +end + function ma28cd(n, a, licn, icn, ikeep, rhs, w, mtype) @ccall libhsl.ma28cd_(n::Ref{Cint}, a::Ptr{Float64}, licn::Ref{Cint}, icn::Ptr{Cint}, ikeep::Ptr{Cint}, rhs::Ptr{Float64}, w::Ptr{Float64}, mtype::Ref{Cint})::Cvoid end +function ma28cd_64(n, a, licn, icn, ikeep, rhs, w, mtype) + @ccall libhsl_subset_64.ma28cd_64_(n::Ref{Int64}, a::Ptr{Float64}, licn::Ref{Int64}, + icn::Ptr{Int64}, ikeep::Ptr{Int64}, rhs::Ptr{Float64}, + w::Ptr{Float64}, mtype::Ref{Int64})::Cvoid +end + function ma28dd(n, a, licn, ivect, jvect, nz, icn, lenr, lenrl, lenoff, ip, iq, iw1, iw, w1, iflag) @ccall libhsl.ma28dd_(n::Ref{Cint}, a::Ptr{Float64}, licn::Ref{Cint}, ivect::Ptr{Cint}, jvect::Ptr{Cint}, nz::Ref{Cint}, icn::Ptr{Cint}, lenr::Ptr{Cint}, @@ -23,6 +43,16 @@ function ma28dd(n, a, licn, ivect, jvect, nz, icn, lenr, lenrl, lenoff, ip, iq, iw1::Ptr{Cint}, iw::Ptr{Cint}, w1::Ref{Float64}, iflag::Ref{Cint})::Cvoid end +function ma28dd_64(n, a, licn, ivect, jvect, nz, icn, lenr, lenrl, lenoff, ip, iq, iw1, iw, w1, + iflag) + @ccall libhsl_subset_64.ma28dd_64_(n::Ref{Int64}, a::Ptr{Float64}, licn::Ref{Int64}, + ivect::Ptr{Int64}, jvect::Ptr{Int64}, nz::Ref{Int64}, + icn::Ptr{Int64}, lenr::Ptr{Int64}, lenrl::Ptr{Int64}, + lenoff::Ptr{Int64}, ip::Ptr{Int64}, iq::Ptr{Int64}, + iw1::Ptr{Int64}, iw::Ptr{Int64}, w1::Ref{Float64}, + iflag::Ref{Int64})::Cvoid +end + function ma28id(n, nz, aorg, irnorg, icnorg, licn, a, icn, ikeep, rhs, x, r, w, mtype, prec, iflag) @ccall libhsl.ma28id_(n::Ref{Cint}, nz::Ref{Cint}, aorg::Ptr{Float64}, irnorg::Ptr{Cint}, icnorg::Ptr{Cint}, licn::Ref{Cint}, a::Ptr{Float64}, icn::Ptr{Cint}, @@ -31,24 +61,54 @@ function ma28id(n, nz, aorg, irnorg, icnorg, licn, a, icn, ikeep, rhs, x, r, w, iflag::Ref{Cint})::Cvoid end +function ma28id_64(n, nz, aorg, irnorg, icnorg, licn, a, icn, ikeep, rhs, x, r, w, mtype, prec, + iflag) + @ccall libhsl_subset_64.ma28id_64_(n::Ref{Int64}, nz::Ref{Int64}, aorg::Ptr{Float64}, + irnorg::Ptr{Int64}, icnorg::Ptr{Int64}, licn::Ref{Int64}, + a::Ptr{Float64}, icn::Ptr{Int64}, ikeep::Ptr{Int64}, + rhs::Ptr{Float64}, x::Ptr{Float64}, r::Ptr{Float64}, + w::Ptr{Float64}, mtype::Ref{Int64}, prec::Ref{Float64}, + iflag::Ref{Int64})::Cvoid +end + function ma28a(n, nz, a, licn, irn, lirn, icn, u, ikeep, iw, w, iflag) @ccall libhsl.ma28a_(n::Ref{Cint}, nz::Ref{Cint}, a::Ptr{Float32}, licn::Ref{Cint}, irn::Ptr{Cint}, lirn::Ref{Cint}, icn::Ptr{Cint}, u::Ref{Float32}, ikeep::Ptr{Cint}, iw::Ptr{Cint}, w::Ptr{Float32}, iflag::Ref{Cint})::Cvoid end +function ma28a_64(n, nz, a, licn, irn, lirn, icn, u, ikeep, iw, w, iflag) + @ccall libhsl_subset_64.ma28a_64_(n::Ref{Int64}, nz::Ref{Int64}, a::Ptr{Float32}, + licn::Ref{Int64}, irn::Ptr{Int64}, lirn::Ref{Int64}, + icn::Ptr{Int64}, u::Ref{Float32}, ikeep::Ptr{Int64}, + iw::Ptr{Int64}, w::Ptr{Float32}, iflag::Ref{Int64})::Cvoid +end + function ma28b(n, nz, a, licn, ivect, jvect, icn, ikeep, iw, w, iflag) @ccall libhsl.ma28b_(n::Ref{Cint}, nz::Ref{Cint}, a::Ptr{Float32}, licn::Ref{Cint}, ivect::Ptr{Cint}, jvect::Ptr{Cint}, icn::Ptr{Cint}, ikeep::Ptr{Cint}, iw::Ptr{Cint}, w::Ptr{Float32}, iflag::Ref{Cint})::Cvoid end +function ma28b_64(n, nz, a, licn, ivect, jvect, icn, ikeep, iw, w, iflag) + @ccall libhsl_subset_64.ma28b_64_(n::Ref{Int64}, nz::Ref{Int64}, a::Ptr{Float32}, + licn::Ref{Int64}, ivect::Ptr{Int64}, jvect::Ptr{Int64}, + icn::Ptr{Int64}, ikeep::Ptr{Int64}, iw::Ptr{Int64}, + w::Ptr{Float32}, iflag::Ref{Int64})::Cvoid +end + function ma28c(n, a, licn, icn, ikeep, rhs, w, mtype) @ccall libhsl.ma28c_(n::Ref{Cint}, a::Ptr{Float32}, licn::Ref{Cint}, icn::Ptr{Cint}, ikeep::Ptr{Cint}, rhs::Ptr{Float32}, w::Ptr{Float32}, mtype::Ref{Cint})::Cvoid end +function ma28c_64(n, a, licn, icn, ikeep, rhs, w, mtype) + @ccall libhsl_subset_64.ma28c_64_(n::Ref{Int64}, a::Ptr{Float32}, licn::Ref{Int64}, + icn::Ptr{Int64}, ikeep::Ptr{Int64}, rhs::Ptr{Float32}, + w::Ptr{Float32}, mtype::Ref{Int64})::Cvoid +end + function ma28d(n, a, licn, ivect, jvect, nz, icn, lenr, lenrl, lenoff, ip, iq, iw1, iw, w1, iflag) @ccall libhsl.ma28d_(n::Ref{Cint}, a::Ptr{Float32}, licn::Ref{Cint}, ivect::Ptr{Cint}, jvect::Ptr{Cint}, nz::Ref{Cint}, icn::Ptr{Cint}, lenr::Ptr{Cint}, @@ -56,6 +116,16 @@ function ma28d(n, a, licn, ivect, jvect, nz, icn, lenr, lenrl, lenoff, ip, iq, i iw1::Ptr{Cint}, iw::Ptr{Cint}, w1::Ref{Float32}, iflag::Ref{Cint})::Cvoid end +function ma28d_64(n, a, licn, ivect, jvect, nz, icn, lenr, lenrl, lenoff, ip, iq, iw1, iw, w1, + iflag) + @ccall libhsl_subset_64.ma28d_64_(n::Ref{Int64}, a::Ptr{Float32}, licn::Ref{Int64}, + ivect::Ptr{Int64}, jvect::Ptr{Int64}, nz::Ref{Int64}, + icn::Ptr{Int64}, lenr::Ptr{Int64}, lenrl::Ptr{Int64}, + lenoff::Ptr{Int64}, ip::Ptr{Int64}, iq::Ptr{Int64}, + iw1::Ptr{Int64}, iw::Ptr{Int64}, w1::Ref{Float32}, + iflag::Ref{Int64})::Cvoid +end + function ma28i(n, nz, aorg, irnorg, icnorg, licn, a, icn, ikeep, rhs, x, r, w, mtype, prec, iflag) @ccall libhsl.ma28i_(n::Ref{Cint}, nz::Ref{Cint}, aorg::Ptr{Float32}, irnorg::Ptr{Cint}, icnorg::Ptr{Cint}, licn::Ref{Cint}, a::Ptr{Float32}, icn::Ptr{Cint}, @@ -63,3 +133,13 @@ function ma28i(n, nz, aorg, irnorg, icnorg, licn, a, icn, ikeep, rhs, x, r, w, m w::Ptr{Float32}, mtype::Ref{Cint}, prec::Ref{Float32}, iflag::Ref{Cint})::Cvoid end + +function ma28i_64(n, nz, aorg, irnorg, icnorg, licn, a, icn, ikeep, rhs, x, r, w, mtype, prec, + iflag) + @ccall libhsl_subset_64.ma28i_64_(n::Ref{Int64}, nz::Ref{Int64}, aorg::Ptr{Float32}, + irnorg::Ptr{Int64}, icnorg::Ptr{Int64}, licn::Ref{Int64}, + a::Ptr{Float32}, icn::Ptr{Int64}, ikeep::Ptr{Int64}, + rhs::Ptr{Float32}, x::Ptr{Float32}, r::Ptr{Float32}, + w::Ptr{Float32}, mtype::Ref{Int64}, prec::Ref{Float32}, + iflag::Ref{Int64})::Cvoid +end diff --git a/src/Fortran/ma30.jl b/src/Fortran/ma30.jl index afdd625..e0af02f 100644 --- a/src/Fortran/ma30.jl +++ b/src/Fortran/ma30.jl @@ -8,12 +8,30 @@ function ma30ad(nn, icn, a, licn, lenr, lenrl, idisp, ip, iq, irn, lirn, lenc, i iflag::Ref{Cint})::Cvoid end +function ma30ad_64(nn, icn, a, licn, lenr, lenrl, idisp, ip, iq, irn, lirn, lenc, ifirst, lastr, + nextr, lastc, nextc, iptr, ipc, u, iflag) + @ccall libhsl_subset_64.ma30ad_64_(nn::Ref{Int64}, icn::Ptr{Int64}, a::Ptr{Float64}, + licn::Ref{Int64}, lenr::Ptr{Int64}, lenrl::Ptr{Int64}, + idisp::Ptr{Int64}, ip::Ptr{Int64}, iq::Ptr{Int64}, + irn::Ptr{Int64}, lirn::Ref{Int64}, lenc::Ptr{Int64}, + ifirst::Ptr{Int64}, lastr::Ptr{Int64}, nextr::Ptr{Int64}, + lastc::Ptr{Int64}, nextc::Ptr{Int64}, iptr::Ptr{Int64}, + ipc::Ptr{Int64}, u::Ref{Float64}, iflag::Ref{Int64})::Cvoid +end + function ma30bd(n, icn, a, licn, lenr, lenrl, idisp, ip, iq, w, iw, iflag) @ccall libhsl.ma30bd_(n::Ref{Cint}, icn::Ptr{Cint}, a::Ptr{Float64}, licn::Ref{Cint}, lenr::Ptr{Cint}, lenrl::Ptr{Cint}, idisp::Ptr{Cint}, ip::Ptr{Cint}, iq::Ptr{Cint}, w::Ptr{Float64}, iw::Ptr{Cint}, iflag::Ref{Cint})::Cvoid end +function ma30bd_64(n, icn, a, licn, lenr, lenrl, idisp, ip, iq, w, iw, iflag) + @ccall libhsl_subset_64.ma30bd_64_(n::Ref{Int64}, icn::Ptr{Int64}, a::Ptr{Float64}, + licn::Ref{Int64}, lenr::Ptr{Int64}, lenrl::Ptr{Int64}, + idisp::Ptr{Int64}, ip::Ptr{Int64}, iq::Ptr{Int64}, + w::Ptr{Float64}, iw::Ptr{Int64}, iflag::Ref{Int64})::Cvoid +end + function ma30cd(n, icn, a, licn, lenr, lenrl, lenoff, idisp, ip, iq, x, w, mtype) @ccall libhsl.ma30cd_(n::Ref{Cint}, icn::Ptr{Cint}, a::Ptr{Float64}, licn::Ref{Cint}, lenr::Ptr{Cint}, lenrl::Ptr{Cint}, lenoff::Ptr{Cint}, idisp::Ptr{Cint}, @@ -21,11 +39,25 @@ function ma30cd(n, icn, a, licn, lenr, lenrl, lenoff, idisp, ip, iq, x, w, mtype mtype::Ref{Cint})::Cvoid end +function ma30cd_64(n, icn, a, licn, lenr, lenrl, lenoff, idisp, ip, iq, x, w, mtype) + @ccall libhsl_subset_64.ma30cd_64_(n::Ref{Int64}, icn::Ptr{Int64}, a::Ptr{Float64}, + licn::Ref{Int64}, lenr::Ptr{Int64}, lenrl::Ptr{Int64}, + lenoff::Ptr{Int64}, idisp::Ptr{Int64}, ip::Ptr{Int64}, + iq::Ptr{Int64}, x::Ptr{Float64}, w::Ptr{Float64}, + mtype::Ref{Int64})::Cvoid +end + function ma30dd(a, icn, iptr, n, iactiv, itop, reals) @ccall libhsl.ma30dd_(a::Ptr{Float64}, icn::Ptr{Cint}, iptr::Ptr{Cint}, n::Ref{Cint}, iactiv::Ref{Cint}, itop::Ref{Cint}, reals::Ref{Cint})::Cvoid end +function ma30dd_64(a, icn, iptr, n, iactiv, itop, reals) + @ccall libhsl_subset_64.ma30dd_64_(a::Ptr{Float64}, icn::Ptr{Int64}, iptr::Ptr{Int64}, + n::Ref{Int64}, iactiv::Ref{Int64}, itop::Ref{Int64}, + reals::Ref{Int64})::Cvoid +end + function ma30a(nn, icn, a, licn, lenr, lenrl, idisp, ip, iq, irn, lirn, lenc, ifirst, lastr, nextr, lastc, nextc, iptr, ipc, u, iflag) @ccall libhsl.ma30a_(nn::Ref{Cint}, icn::Ptr{Cint}, a::Ptr{Float32}, licn::Ref{Cint}, @@ -36,12 +68,30 @@ function ma30a(nn, icn, a, licn, lenr, lenrl, idisp, ip, iq, irn, lirn, lenc, if iflag::Ref{Cint})::Cvoid end +function ma30a_64(nn, icn, a, licn, lenr, lenrl, idisp, ip, iq, irn, lirn, lenc, ifirst, lastr, + nextr, lastc, nextc, iptr, ipc, u, iflag) + @ccall libhsl_subset_64.ma30a_64_(nn::Ref{Int64}, icn::Ptr{Int64}, a::Ptr{Float32}, + licn::Ref{Int64}, lenr::Ptr{Int64}, lenrl::Ptr{Int64}, + idisp::Ptr{Int64}, ip::Ptr{Int64}, iq::Ptr{Int64}, + irn::Ptr{Int64}, lirn::Ref{Int64}, lenc::Ptr{Int64}, + ifirst::Ptr{Int64}, lastr::Ptr{Int64}, nextr::Ptr{Int64}, + lastc::Ptr{Int64}, nextc::Ptr{Int64}, iptr::Ptr{Int64}, + ipc::Ptr{Int64}, u::Ref{Float32}, iflag::Ref{Int64})::Cvoid +end + function ma30b(n, icn, a, licn, lenr, lenrl, idisp, ip, iq, w, iw, iflag) @ccall libhsl.ma30b_(n::Ref{Cint}, icn::Ptr{Cint}, a::Ptr{Float32}, licn::Ref{Cint}, lenr::Ptr{Cint}, lenrl::Ptr{Cint}, idisp::Ptr{Cint}, ip::Ptr{Cint}, iq::Ptr{Cint}, w::Ptr{Float32}, iw::Ptr{Cint}, iflag::Ref{Cint})::Cvoid end +function ma30b_64(n, icn, a, licn, lenr, lenrl, idisp, ip, iq, w, iw, iflag) + @ccall libhsl_subset_64.ma30b_64_(n::Ref{Int64}, icn::Ptr{Int64}, a::Ptr{Float32}, + licn::Ref{Int64}, lenr::Ptr{Int64}, lenrl::Ptr{Int64}, + idisp::Ptr{Int64}, ip::Ptr{Int64}, iq::Ptr{Int64}, + w::Ptr{Float32}, iw::Ptr{Int64}, iflag::Ref{Int64})::Cvoid +end + function ma30c(n, icn, a, licn, lenr, lenrl, lenoff, idisp, ip, iq, x, w, mtype) @ccall libhsl.ma30c_(n::Ref{Cint}, icn::Ptr{Cint}, a::Ptr{Float32}, licn::Ref{Cint}, lenr::Ptr{Cint}, lenrl::Ptr{Cint}, lenoff::Ptr{Cint}, idisp::Ptr{Cint}, @@ -49,7 +99,21 @@ function ma30c(n, icn, a, licn, lenr, lenrl, lenoff, idisp, ip, iq, x, w, mtype) mtype::Ref{Cint})::Cvoid end +function ma30c_64(n, icn, a, licn, lenr, lenrl, lenoff, idisp, ip, iq, x, w, mtype) + @ccall libhsl_subset_64.ma30c_64_(n::Ref{Int64}, icn::Ptr{Int64}, a::Ptr{Float32}, + licn::Ref{Int64}, lenr::Ptr{Int64}, lenrl::Ptr{Int64}, + lenoff::Ptr{Int64}, idisp::Ptr{Int64}, ip::Ptr{Int64}, + iq::Ptr{Int64}, x::Ptr{Float32}, w::Ptr{Float32}, + mtype::Ref{Int64})::Cvoid +end + function ma30d(a, icn, iptr, n, iactiv, itop, reals) @ccall libhsl.ma30d_(a::Ptr{Float32}, icn::Ptr{Cint}, iptr::Ptr{Cint}, n::Ref{Cint}, iactiv::Ref{Cint}, itop::Ref{Cint}, reals::Ref{Cint})::Cvoid end + +function ma30d_64(a, icn, iptr, n, iactiv, itop, reals) + @ccall libhsl_subset_64.ma30d_64_(a::Ptr{Float32}, icn::Ptr{Int64}, iptr::Ptr{Int64}, + n::Ref{Int64}, iactiv::Ref{Int64}, itop::Ref{Int64}, + reals::Ref{Int64})::Cvoid +end diff --git a/src/Fortran/ma33.jl b/src/Fortran/ma33.jl index 65c330d..9aaa3e5 100644 --- a/src/Fortran/ma33.jl +++ b/src/Fortran/ma33.jl @@ -2,6 +2,10 @@ function ma33id(icntl, cntl) @ccall libhsl.ma33id_(icntl::Ptr{Cint}, cntl::Ptr{Float64})::Cvoid end +function ma33id_64(icntl, cntl) + @ccall libhsl_subset_64.ma33id_64_(icntl::Ptr{Int64}, cntl::Ptr{Float64})::Cvoid +end + function ma33ad(nn, icn, a, licn, lenr, lenrl, idisp, ip, iq, irn, lirn, lenc, ifirst, lastr, nextr, lastc, nextc, iptr, ipc, u, iflag, icntl, cntl, info, rinfo) @ccall libhsl.ma33ad_(nn::Ref{Cint}, icn::Ptr{Cint}, a::Ptr{Float64}, licn::Ref{Cint}, @@ -13,6 +17,19 @@ function ma33ad(nn, icn, a, licn, lenr, lenrl, idisp, ip, iq, irn, lirn, lenc, i rinfo::Ptr{Float64})::Cvoid end +function ma33ad_64(nn, icn, a, licn, lenr, lenrl, idisp, ip, iq, irn, lirn, lenc, ifirst, lastr, + nextr, lastc, nextc, iptr, ipc, u, iflag, icntl, cntl, info, rinfo) + @ccall libhsl_subset_64.ma33ad_64_(nn::Ref{Int64}, icn::Ptr{Int64}, a::Ptr{Float64}, + licn::Ref{Int64}, lenr::Ptr{Int64}, lenrl::Ptr{Int64}, + idisp::Ptr{Int64}, ip::Ptr{Int64}, iq::Ptr{Int64}, + irn::Ptr{Int64}, lirn::Ref{Int64}, lenc::Ptr{Int64}, + ifirst::Ptr{Int64}, lastr::Ptr{Int64}, nextr::Ptr{Int64}, + lastc::Ptr{Int64}, nextc::Ptr{Int64}, iptr::Ptr{Int64}, + ipc::Ptr{Int64}, u::Ref{Float64}, iflag::Ref{Int64}, + icntl::Ptr{Int64}, cntl::Ptr{Float64}, info::Ptr{Int64}, + rinfo::Ptr{Float64})::Cvoid +end + function ma33bd(n, icn, a, licn, lenr, lenrl, idisp, ip, iq, w, iw, iflag, icntl, cntl, rinfo) @ccall libhsl.ma33bd_(n::Ref{Cint}, icn::Ptr{Cint}, a::Ptr{Float64}, licn::Ref{Cint}, lenr::Ptr{Cint}, lenrl::Ptr{Cint}, idisp::Ptr{Cint}, ip::Ptr{Cint}, @@ -20,6 +37,15 @@ function ma33bd(n, icn, a, licn, lenr, lenrl, idisp, ip, iq, w, iw, iflag, icntl icntl::Ptr{Cint}, cntl::Ptr{Float64}, rinfo::Ptr{Float64})::Cvoid end +function ma33bd_64(n, icn, a, licn, lenr, lenrl, idisp, ip, iq, w, iw, iflag, icntl, cntl, rinfo) + @ccall libhsl_subset_64.ma33bd_64_(n::Ref{Int64}, icn::Ptr{Int64}, a::Ptr{Float64}, + licn::Ref{Int64}, lenr::Ptr{Int64}, lenrl::Ptr{Int64}, + idisp::Ptr{Int64}, ip::Ptr{Int64}, iq::Ptr{Int64}, + w::Ptr{Float64}, iw::Ptr{Int64}, iflag::Ref{Int64}, + icntl::Ptr{Int64}, cntl::Ptr{Float64}, + rinfo::Ptr{Float64})::Cvoid +end + function ma33cd(n, icn, a, licn, lenr, lenrl, lenoff, idisp, ip, iq, x, w, mtype, rinfo) @ccall libhsl.ma33cd_(n::Ref{Cint}, icn::Ptr{Cint}, a::Ptr{Float64}, licn::Ref{Cint}, lenr::Ptr{Cint}, lenrl::Ptr{Cint}, lenoff::Ptr{Cint}, idisp::Ptr{Cint}, @@ -27,16 +53,34 @@ function ma33cd(n, icn, a, licn, lenr, lenrl, lenoff, idisp, ip, iq, x, w, mtype mtype::Ref{Cint}, rinfo::Ptr{Float64})::Cvoid end +function ma33cd_64(n, icn, a, licn, lenr, lenrl, lenoff, idisp, ip, iq, x, w, mtype, rinfo) + @ccall libhsl_subset_64.ma33cd_64_(n::Ref{Int64}, icn::Ptr{Int64}, a::Ptr{Float64}, + licn::Ref{Int64}, lenr::Ptr{Int64}, lenrl::Ptr{Int64}, + lenoff::Ptr{Int64}, idisp::Ptr{Int64}, ip::Ptr{Int64}, + iq::Ptr{Int64}, x::Ptr{Float64}, w::Ptr{Float64}, + mtype::Ref{Int64}, rinfo::Ptr{Float64})::Cvoid +end + function ma33dd(a, icn, iptr, n, iactiv, itop, reals, info) @ccall libhsl.ma33dd_(a::Ptr{Float64}, icn::Ptr{Cint}, iptr::Ptr{Cint}, n::Ref{Cint}, iactiv::Ref{Cint}, itop::Ref{Cint}, reals::Ref{Cint}, info::Ptr{Cint})::Cvoid end +function ma33dd_64(a, icn, iptr, n, iactiv, itop, reals, info) + @ccall libhsl_subset_64.ma33dd_64_(a::Ptr{Float64}, icn::Ptr{Int64}, iptr::Ptr{Int64}, + n::Ref{Int64}, iactiv::Ref{Int64}, itop::Ref{Int64}, + reals::Ref{Int64}, info::Ptr{Int64})::Cvoid +end + function ma33i(icntl, cntl) @ccall libhsl.ma33i_(icntl::Ptr{Cint}, cntl::Ptr{Float32})::Cvoid end +function ma33i_64(icntl, cntl) + @ccall libhsl_subset_64.ma33i_64_(icntl::Ptr{Int64}, cntl::Ptr{Float32})::Cvoid +end + function ma33a(nn, icn, a, licn, lenr, lenrl, idisp, ip, iq, irn, lirn, lenc, ifirst, lastr, nextr, lastc, nextc, iptr, ipc, u, iflag, icntl, cntl, info, rinfo) @ccall libhsl.ma33a_(nn::Ref{Cint}, icn::Ptr{Cint}, a::Ptr{Float32}, licn::Ref{Cint}, @@ -48,6 +92,19 @@ function ma33a(nn, icn, a, licn, lenr, lenrl, idisp, ip, iq, irn, lirn, lenc, if rinfo::Ptr{Float32})::Cvoid end +function ma33a_64(nn, icn, a, licn, lenr, lenrl, idisp, ip, iq, irn, lirn, lenc, ifirst, lastr, + nextr, lastc, nextc, iptr, ipc, u, iflag, icntl, cntl, info, rinfo) + @ccall libhsl_subset_64.ma33a_64_(nn::Ref{Int64}, icn::Ptr{Int64}, a::Ptr{Float32}, + licn::Ref{Int64}, lenr::Ptr{Int64}, lenrl::Ptr{Int64}, + idisp::Ptr{Int64}, ip::Ptr{Int64}, iq::Ptr{Int64}, + irn::Ptr{Int64}, lirn::Ref{Int64}, lenc::Ptr{Int64}, + ifirst::Ptr{Int64}, lastr::Ptr{Int64}, nextr::Ptr{Int64}, + lastc::Ptr{Int64}, nextc::Ptr{Int64}, iptr::Ptr{Int64}, + ipc::Ptr{Int64}, u::Ref{Float32}, iflag::Ref{Int64}, + icntl::Ptr{Int64}, cntl::Ptr{Float32}, info::Ptr{Int64}, + rinfo::Ptr{Float32})::Cvoid +end + function ma33b(n, icn, a, licn, lenr, lenrl, idisp, ip, iq, w, iw, iflag, icntl, cntl, rinfo) @ccall libhsl.ma33b_(n::Ref{Cint}, icn::Ptr{Cint}, a::Ptr{Float32}, licn::Ref{Cint}, lenr::Ptr{Cint}, lenrl::Ptr{Cint}, idisp::Ptr{Cint}, ip::Ptr{Cint}, @@ -55,6 +112,15 @@ function ma33b(n, icn, a, licn, lenr, lenrl, idisp, ip, iq, w, iw, iflag, icntl, icntl::Ptr{Cint}, cntl::Ptr{Float32}, rinfo::Ptr{Float32})::Cvoid end +function ma33b_64(n, icn, a, licn, lenr, lenrl, idisp, ip, iq, w, iw, iflag, icntl, cntl, rinfo) + @ccall libhsl_subset_64.ma33b_64_(n::Ref{Int64}, icn::Ptr{Int64}, a::Ptr{Float32}, + licn::Ref{Int64}, lenr::Ptr{Int64}, lenrl::Ptr{Int64}, + idisp::Ptr{Int64}, ip::Ptr{Int64}, iq::Ptr{Int64}, + w::Ptr{Float32}, iw::Ptr{Int64}, iflag::Ref{Int64}, + icntl::Ptr{Int64}, cntl::Ptr{Float32}, + rinfo::Ptr{Float32})::Cvoid +end + function ma33c(n, icn, a, licn, lenr, lenrl, lenoff, idisp, ip, iq, x, w, mtype, rinfo) @ccall libhsl.ma33c_(n::Ref{Cint}, icn::Ptr{Cint}, a::Ptr{Float32}, licn::Ref{Cint}, lenr::Ptr{Cint}, lenrl::Ptr{Cint}, lenoff::Ptr{Cint}, idisp::Ptr{Cint}, @@ -62,7 +128,21 @@ function ma33c(n, icn, a, licn, lenr, lenrl, lenoff, idisp, ip, iq, x, w, mtype, mtype::Ref{Cint}, rinfo::Ptr{Float32})::Cvoid end +function ma33c_64(n, icn, a, licn, lenr, lenrl, lenoff, idisp, ip, iq, x, w, mtype, rinfo) + @ccall libhsl_subset_64.ma33c_64_(n::Ref{Int64}, icn::Ptr{Int64}, a::Ptr{Float32}, + licn::Ref{Int64}, lenr::Ptr{Int64}, lenrl::Ptr{Int64}, + lenoff::Ptr{Int64}, idisp::Ptr{Int64}, ip::Ptr{Int64}, + iq::Ptr{Int64}, x::Ptr{Float32}, w::Ptr{Float32}, + mtype::Ref{Int64}, rinfo::Ptr{Float32})::Cvoid +end + function ma33d(a, icn, iptr, n, iactiv, itop, reals, info) @ccall libhsl.ma33d_(a::Ptr{Float32}, icn::Ptr{Cint}, iptr::Ptr{Cint}, n::Ref{Cint}, iactiv::Ref{Cint}, itop::Ref{Cint}, reals::Ref{Cint}, info::Ptr{Cint})::Cvoid end + +function ma33d_64(a, icn, iptr, n, iactiv, itop, reals, info) + @ccall libhsl_subset_64.ma33d_64_(a::Ptr{Float32}, icn::Ptr{Int64}, iptr::Ptr{Int64}, + n::Ref{Int64}, iactiv::Ref{Int64}, itop::Ref{Int64}, + reals::Ref{Int64}, info::Ptr{Int64})::Cvoid +end diff --git a/src/Fortran/ma57.jl b/src/Fortran/ma57.jl index cf706a3..3052a6f 100644 --- a/src/Fortran/ma57.jl +++ b/src/Fortran/ma57.jl @@ -2,12 +2,23 @@ function ma57id(cntl, icntl) @ccall libhsl.ma57id_(cntl::Ptr{Float64}, icntl::Ptr{Cint})::Cvoid end +function ma57id_64(cntl, icntl) + @ccall libhsl_subset_64.ma57id_64_(cntl::Ptr{Float64}, icntl::Ptr{Int64})::Cvoid +end + function ma57ad(n, ne, irn, jcn, lkeep, keep, iwork, icntl, info, rinfo) @ccall libhsl.ma57ad_(n::Ref{Cint}, ne::Ref{Cint}, irn::Ptr{Cint}, jcn::Ptr{Cint}, lkeep::Ref{Cint}, keep::Ptr{Cint}, iwork::Ptr{Cint}, icntl::Ptr{Cint}, info::Ptr{Cint}, rinfo::Ptr{Float64})::Cvoid end +function ma57ad_64(n, ne, irn, jcn, lkeep, keep, iwork, icntl, info, rinfo) + @ccall libhsl_subset_64.ma57ad_64_(n::Ref{Int64}, ne::Ref{Int64}, irn::Ptr{Int64}, + jcn::Ptr{Int64}, lkeep::Ref{Int64}, keep::Ptr{Int64}, + iwork::Ptr{Int64}, icntl::Ptr{Int64}, info::Ptr{Int64}, + rinfo::Ptr{Float64})::Cvoid +end + function ma57bd(n, ne, a, fact, lfact, ifact, lifact, lkeep, keep, ppos, icntl, cntl, info, rinfo) @ccall libhsl.ma57bd_(n::Ref{Cint}, ne::Ref{Cint}, a::Ptr{Float64}, fact::Ptr{Float64}, lfact::Ref{Cint}, ifact::Ptr{Cint}, lifact::Ref{Cint}, lkeep::Ref{Cint}, @@ -15,6 +26,15 @@ function ma57bd(n, ne, a, fact, lfact, ifact, lifact, lkeep, keep, ppos, icntl, info::Ptr{Cint}, rinfo::Ptr{Float64})::Cvoid end +function ma57bd_64(n, ne, a, fact, lfact, ifact, lifact, lkeep, keep, ppos, icntl, cntl, info, + rinfo) + @ccall libhsl_subset_64.ma57bd_64_(n::Ref{Int64}, ne::Ref{Int64}, a::Ptr{Float64}, + fact::Ptr{Float64}, lfact::Ref{Int64}, ifact::Ptr{Int64}, + lifact::Ref{Int64}, lkeep::Ref{Int64}, keep::Ptr{Int64}, + ppos::Ptr{Int64}, icntl::Ptr{Int64}, cntl::Ptr{Float64}, + info::Ptr{Int64}, rinfo::Ptr{Float64})::Cvoid +end + function ma57cd(job, n, fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, iw1, icntl, info) @ccall libhsl.ma57cd_(job::Ref{Cint}, n::Ref{Cint}, fact::Ptr{Float64}, lfact::Ref{Cint}, ifact::Ptr{Cint}, lifact::Ref{Cint}, nrhs::Ref{Cint}, rhs::Ptr{Float64}, @@ -22,35 +42,76 @@ function ma57cd(job, n, fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, iw1, icntl::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function ma57cd_64(job, n, fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, iw1, icntl, info) + @ccall libhsl_subset_64.ma57cd_64_(job::Ref{Int64}, n::Ref{Int64}, fact::Ptr{Float64}, + lfact::Ref{Int64}, ifact::Ptr{Int64}, lifact::Ref{Int64}, + nrhs::Ref{Int64}, rhs::Ptr{Float64}, lrhs::Ref{Int64}, + w::Ptr{Float64}, lw::Ref{Int64}, iw1::Ptr{Int64}, + icntl::Ptr{Int64}, info::Ptr{Int64})::Cvoid +end + function ma57qd(n, fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, iw1, icntl) @ccall libhsl.ma57qd_(n::Ref{Cint}, fact::Ptr{Float64}, lfact::Ref{Cint}, ifact::Ptr{Cint}, lifact::Ref{Cint}, nrhs::Ref{Cint}, rhs::Ptr{Float64}, lrhs::Ref{Cint}, w::Ptr{Float64}, lw::Ref{Cint}, iw1::Ptr{Cint}, icntl::Ptr{Cint})::Cvoid end +function ma57qd_64(n, fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, iw1, icntl) + @ccall libhsl_subset_64.ma57qd_64_(n::Ref{Int64}, fact::Ptr{Float64}, lfact::Ref{Int64}, + ifact::Ptr{Int64}, lifact::Ref{Int64}, nrhs::Ref{Int64}, + rhs::Ptr{Float64}, lrhs::Ref{Int64}, w::Ptr{Float64}, + lw::Ref{Int64}, iw1::Ptr{Int64}, icntl::Ptr{Int64})::Cvoid +end + function ma57rd(n, fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, iw1, icntl) @ccall libhsl.ma57rd_(n::Ref{Cint}, fact::Ptr{Float64}, lfact::Ref{Cint}, ifact::Ptr{Cint}, lifact::Ref{Cint}, nrhs::Ref{Cint}, rhs::Ptr{Float64}, lrhs::Ref{Cint}, w::Ptr{Float64}, lw::Ref{Cint}, iw1::Ptr{Cint}, icntl::Ptr{Cint})::Cvoid end +function ma57rd_64(n, fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, iw1, icntl) + @ccall libhsl_subset_64.ma57rd_64_(n::Ref{Int64}, fact::Ptr{Float64}, lfact::Ref{Int64}, + ifact::Ptr{Int64}, lifact::Ref{Int64}, nrhs::Ref{Int64}, + rhs::Ptr{Float64}, lrhs::Ref{Int64}, w::Ptr{Float64}, + lw::Ref{Int64}, iw1::Ptr{Int64}, icntl::Ptr{Int64})::Cvoid +end + function ma57ud(fact, lfact, ifact, lifact, icntl) @ccall libhsl.ma57ud_(fact::Ptr{Float64}, lfact::Ref{Cint}, ifact::Ptr{Cint}, lifact::Ref{Cint}, icntl::Ptr{Cint})::Cvoid end +function ma57ud_64(fact, lfact, ifact, lifact, icntl) + @ccall libhsl_subset_64.ma57ud_64_(fact::Ptr{Float64}, lfact::Ref{Int64}, ifact::Ptr{Int64}, + lifact::Ref{Int64}, icntl::Ptr{Int64})::Cvoid +end + function ma57sd(fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, icntl) @ccall libhsl.ma57sd_(fact::Ptr{Float64}, lfact::Ref{Cint}, ifact::Ptr{Cint}, lifact::Ref{Cint}, nrhs::Ref{Cint}, rhs::Ptr{Float64}, lrhs::Ref{Cint}, w::Ptr{Float64}, lw::Ref{Cint}, icntl::Ptr{Cint})::Cvoid end +function ma57sd_64(fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, icntl) + @ccall libhsl_subset_64.ma57sd_64_(fact::Ptr{Float64}, lfact::Ref{Int64}, ifact::Ptr{Int64}, + lifact::Ref{Int64}, nrhs::Ref{Int64}, rhs::Ptr{Float64}, + lrhs::Ref{Int64}, w::Ptr{Float64}, lw::Ref{Int64}, + icntl::Ptr{Int64})::Cvoid +end + function ma57td(n, fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, iw1, icntl) @ccall libhsl.ma57td_(n::Ref{Cint}, fact::Ptr{Float64}, lfact::Ref{Cint}, ifact::Ptr{Cint}, lifact::Ref{Cint}, nrhs::Ref{Cint}, rhs::Ptr{Float64}, lrhs::Ref{Cint}, w::Ptr{Float64}, lw::Ref{Cint}, iw1::Ptr{Cint}, icntl::Ptr{Cint})::Cvoid end +function ma57td_64(n, fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, iw1, icntl) + @ccall libhsl_subset_64.ma57td_64_(n::Ref{Int64}, fact::Ptr{Float64}, lfact::Ref{Int64}, + ifact::Ptr{Int64}, lifact::Ref{Int64}, nrhs::Ref{Int64}, + rhs::Ptr{Float64}, lrhs::Ref{Int64}, w::Ptr{Float64}, + lw::Ref{Int64}, iw1::Ptr{Int64}, icntl::Ptr{Int64})::Cvoid +end + function ma57dd(job, n, ne, a, irn, jcn, fact, lfact, ifact, lifact, rhs, x, resid, w, iw, icntl, cntl, info, rinfo) @ccall libhsl.ma57dd_(job::Ref{Cint}, n::Ref{Cint}, ne::Ref{Cint}, a::Ptr{Float64}, @@ -60,6 +121,17 @@ function ma57dd(job, n, ne, a, irn, jcn, fact, lfact, ifact, lifact, rhs, x, res cntl::Ptr{Float64}, info::Ptr{Cint}, rinfo::Ptr{Float64})::Cvoid end +function ma57dd_64(job, n, ne, a, irn, jcn, fact, lfact, ifact, lifact, rhs, x, resid, w, iw, icntl, + cntl, info, rinfo) + @ccall libhsl_subset_64.ma57dd_64_(job::Ref{Int64}, n::Ref{Int64}, ne::Ref{Int64}, + a::Ptr{Float64}, irn::Ptr{Int64}, jcn::Ptr{Int64}, + fact::Ptr{Float64}, lfact::Ref{Int64}, ifact::Ptr{Int64}, + lifact::Ref{Int64}, rhs::Ptr{Float64}, x::Ptr{Float64}, + resid::Ptr{Float64}, w::Ptr{Float64}, iw::Ptr{Int64}, + icntl::Ptr{Int64}, cntl::Ptr{Float64}, info::Ptr{Int64}, + rinfo::Ptr{Float64})::Cvoid +end + function ma57ed(n, ic, keep, fact, lfact, newfac, lnew, ifact, lifact, newifc, linew, info) @ccall libhsl.ma57ed_(n::Ref{Cint}, ic::Ref{Cint}, keep::Ptr{Cint}, fact::Ptr{Float64}, lfact::Ref{Cint}, newfac::Ptr{Float64}, lnew::Ref{Cint}, ifact::Ptr{Cint}, @@ -67,29 +139,61 @@ function ma57ed(n, ic, keep, fact, lfact, newfac, lnew, ifact, lifact, newifc, l info::Ptr{Cint})::Cvoid end +function ma57ed_64(n, ic, keep, fact, lfact, newfac, lnew, ifact, lifact, newifc, linew, info) + @ccall libhsl_subset_64.ma57ed_64_(n::Ref{Int64}, ic::Ref{Int64}, keep::Ptr{Int64}, + fact::Ptr{Float64}, lfact::Ref{Int64}, newfac::Ptr{Float64}, + lnew::Ref{Int64}, ifact::Ptr{Int64}, lifact::Ref{Int64}, + newifc::Ptr{Int64}, linew::Ref{Int64}, info::Ptr{Int64})::Cvoid +end + function ma57gd(n, ne, irn, jcn, iw, ipe, count, flag, iwfr, icntl, info) @ccall libhsl.ma57gd_(n::Ref{Cint}, ne::Ref{Cint}, irn::Ptr{Cint}, jcn::Ptr{Cint}, iw::Ptr{Cint}, ipe::Ptr{Cint}, count::Ptr{Cint}, flag::Ptr{Cint}, iwfr::Ref{Cint}, icntl::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function ma57gd_64(n, ne, irn, jcn, iw, ipe, count, flag, iwfr, icntl, info) + @ccall libhsl_subset_64.ma57gd_64_(n::Ref{Int64}, ne::Ref{Int64}, irn::Ptr{Int64}, + jcn::Ptr{Int64}, iw::Ptr{Int64}, ipe::Ptr{Int64}, + count::Ptr{Int64}, flag::Ptr{Int64}, iwfr::Ref{Int64}, + icntl::Ptr{Int64}, info::Ptr{Int64})::Cvoid +end + function ma57jd(n, ne, irn, jcn, perm, iw, ipe, count, flag, iwfr, icntl, info) @ccall libhsl.ma57jd_(n::Ref{Cint}, ne::Ref{Cint}, irn::Ptr{Cint}, jcn::Ptr{Cint}, perm::Ptr{Cint}, iw::Ptr{Cint}, ipe::Ptr{Cint}, count::Ptr{Cint}, flag::Ptr{Cint}, iwfr::Ref{Cint}, icntl::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function ma57jd_64(n, ne, irn, jcn, perm, iw, ipe, count, flag, iwfr, icntl, info) + @ccall libhsl_subset_64.ma57jd_64_(n::Ref{Int64}, ne::Ref{Int64}, irn::Ptr{Int64}, + jcn::Ptr{Int64}, perm::Ptr{Int64}, iw::Ptr{Int64}, + ipe::Ptr{Int64}, count::Ptr{Int64}, flag::Ptr{Int64}, + iwfr::Ref{Int64}, icntl::Ptr{Int64}, info::Ptr{Int64})::Cvoid +end + function ma57kd(n, ipe, iw, lw, iwfr, perm, ips, nv, flag, ncmpa) @ccall libhsl.ma57kd_(n::Ref{Cint}, ipe::Ptr{Cint}, iw::Ptr{Cint}, lw::Ref{Cint}, iwfr::Ref{Cint}, perm::Ptr{Cint}, ips::Ptr{Cint}, nv::Ptr{Cint}, flag::Ptr{Cint}, ncmpa::Ref{Cint})::Cvoid end +function ma57kd_64(n, ipe, iw, lw, iwfr, perm, ips, nv, flag, ncmpa) + @ccall libhsl_subset_64.ma57kd_64_(n::Ref{Int64}, ipe::Ptr{Int64}, iw::Ptr{Int64}, lw::Ref{Int64}, + iwfr::Ref{Int64}, perm::Ptr{Int64}, ips::Ptr{Int64}, + nv::Ptr{Int64}, flag::Ptr{Int64}, ncmpa::Ref{Int64})::Cvoid +end + function ma57fd(n, ipe, iw, lw, iwfr, ncmpa) @ccall libhsl.ma57fd_(n::Ref{Cint}, ipe::Ptr{Cint}, iw::Ptr{Cint}, lw::Ref{Cint}, iwfr::Ref{Cint}, ncmpa::Ref{Cint})::Cvoid end +function ma57fd_64(n, ipe, iw, lw, iwfr, ncmpa) + @ccall libhsl_subset_64.ma57fd_64_(n::Ref{Int64}, ipe::Ptr{Int64}, iw::Ptr{Int64}, lw::Ref{Int64}, + iwfr::Ref{Int64}, ncmpa::Ref{Int64})::Cvoid +end + function ma57ld(n, ipe, nv, ips, ne, na, node, perm, nsteps, fils, frere, nd, nemin, subord) @ccall libhsl.ma57ld_(n::Ref{Cint}, ipe::Ptr{Cint}, nv::Ptr{Cint}, ips::Ptr{Cint}, ne::Ptr{Cint}, na::Ptr{Cint}, node::Ptr{Cint}, perm::Ptr{Cint}, nsteps::Ref{Cint}, @@ -97,18 +201,40 @@ function ma57ld(n, ipe, nv, ips, ne, na, node, perm, nsteps, fils, frere, nd, ne subord::Ptr{Cint})::Cvoid end +function ma57ld_64(n, ipe, nv, ips, ne, na, node, perm, nsteps, fils, frere, nd, nemin, subord) + @ccall libhsl_subset_64.ma57ld_64_(n::Ref{Int64}, ipe::Ptr{Int64}, nv::Ptr{Int64}, + ips::Ptr{Int64}, ne::Ptr{Int64}, na::Ptr{Int64}, + node::Ptr{Int64}, perm::Ptr{Int64}, nsteps::Ref{Int64}, + fils::Ptr{Int64}, frere::Ptr{Int64}, nd::Ptr{Int64}, + nemin::Ref{Int64}, subord::Ptr{Int64})::Cvoid +end + function ma57md(n, ne, irn, jcn, map, irnprm, lrow, perm, count, idiag) @ccall libhsl.ma57md_(n::Ref{Cint}, ne::Ref{Cint}, irn::Ptr{Cint}, jcn::Ptr{Cint}, map::Ptr{Cint}, irnprm::Ptr{Cint}, lrow::Ptr{Cint}, perm::Ptr{Cint}, count::Ptr{Cint}, idiag::Ptr{Cint})::Cvoid end +function ma57md_64(n, ne, irn, jcn, map, irnprm, lrow, perm, count, idiag) + @ccall libhsl_subset_64.ma57md_64_(n::Ref{Int64}, ne::Ref{Int64}, irn::Ptr{Int64}, + jcn::Ptr{Int64}, map::Ptr{Int64}, irnprm::Ptr{Int64}, + lrow::Ptr{Int64}, perm::Ptr{Int64}, count::Ptr{Int64}, + idiag::Ptr{Int64})::Cvoid +end + function ma57nd(n, lenr, na, ne, nd, nsteps, lstki, lstkr, info, rinfo) @ccall libhsl.ma57nd_(n::Ref{Cint}, lenr::Ptr{Cint}, na::Ptr{Cint}, ne::Ptr{Cint}, nd::Ptr{Cint}, nsteps::Ref{Cint}, lstki::Ptr{Cint}, lstkr::Ptr{Cint}, info::Ptr{Cint}, rinfo::Ptr{Float64})::Cvoid end +function ma57nd_64(n, lenr, na, ne, nd, nsteps, lstki, lstkr, info, rinfo) + @ccall libhsl_subset_64.ma57nd_64_(n::Ref{Int64}, lenr::Ptr{Int64}, na::Ptr{Int64}, + ne::Ptr{Int64}, nd::Ptr{Int64}, nsteps::Ref{Int64}, + lstki::Ptr{Int64}, lstkr::Ptr{Int64}, info::Ptr{Int64}, + rinfo::Ptr{Float64})::Cvoid +end + function ma57od(n, ne, a, la, iw, liw, lrow, perm, nsteps, nstk, node, diag, schnab, ppos, cntl, icntl, info, rinfo, hold, biga) @ccall libhsl.ma57od_(n::Ref{Cint}, ne::Ref{Cint}, a::Ptr{Float64}, la::Ref{Cint}, iw::Ptr{Cint}, @@ -118,34 +244,76 @@ function ma57od(n, ne, a, la, iw, liw, lrow, perm, nsteps, nstk, node, diag, sch rinfo::Ptr{Float64}, hold::Ptr{Cint}, biga::Ref{Float64})::Cvoid end +function ma57od_64(n, ne, a, la, iw, liw, lrow, perm, nsteps, nstk, node, diag, schnab, ppos, cntl, + icntl, info, rinfo, hold, biga) + @ccall libhsl_subset_64.ma57od_64_(n::Ref{Int64}, ne::Ref{Int64}, a::Ptr{Float64}, la::Ref{Int64}, + iw::Ptr{Int64}, liw::Ref{Int64}, lrow::Ptr{Int64}, + perm::Ptr{Int64}, nsteps::Ref{Int64}, nstk::Ptr{Int64}, + node::Ptr{Int64}, diag::Ptr{Float64}, schnab::Ptr{Float64}, + ppos::Ptr{Int64}, cntl::Ptr{Float64}, icntl::Ptr{Int64}, + info::Ptr{Int64}, rinfo::Ptr{Float64}, hold::Ptr{Int64}, + biga::Ref{Float64})::Cvoid +end + function ma57pd(a, iw, j1, j2, itop, real) @ccall libhsl.ma57pd_(a::Ptr{Float64}, iw::Ptr{Cint}, j1::Ref{Cint}, j2::Ref{Cint}, itop::Ref{Cint}, real::Ref{Cint})::Cvoid end +function ma57pd_64(a, iw, j1, j2, itop, real) + @ccall libhsl_subset_64.ma57pd_64_(a::Ptr{Float64}, iw::Ptr{Int64}, j1::Ref{Int64}, + j2::Ref{Int64}, itop::Ref{Int64}, real::Ref{Int64})::Cvoid +end + function ma57wd(a, la, iw, liw, nrlbdu) @ccall libhsl.ma57wd_(a::Ptr{Float64}, la::Ref{Cint}, iw::Ptr{Cint}, liw::Ref{Cint}, nrlbdu::Ref{Cint})::Cvoid end +function ma57wd_64(a, la, iw, liw, nrlbdu) + @ccall libhsl_subset_64.ma57wd_64_(a::Ptr{Float64}, la::Ref{Int64}, iw::Ptr{Int64}, + liw::Ref{Int64}, nrlbdu::Ref{Int64})::Cvoid +end + function ma57xd(n, fact, lfact, ifact, lifact, rhs, lrhs, w, lw, iw1, icntl) @ccall libhsl.ma57xd_(n::Ref{Cint}, fact::Ptr{Float64}, lfact::Ref{Cint}, ifact::Ptr{Cint}, lifact::Ref{Cint}, rhs::Ptr{Float64}, lrhs::Ref{Cint}, w::Ptr{Float64}, lw::Ref{Cint}, iw1::Ptr{Cint}, icntl::Ptr{Cint})::Cvoid end +function ma57xd_64(n, fact, lfact, ifact, lifact, rhs, lrhs, w, lw, iw1, icntl) + @ccall libhsl_subset_64.ma57xd_64_(n::Ref{Int64}, fact::Ptr{Float64}, lfact::Ref{Int64}, + ifact::Ptr{Int64}, lifact::Ref{Int64}, rhs::Ptr{Float64}, + lrhs::Ref{Int64}, w::Ptr{Float64}, lw::Ref{Int64}, + iw1::Ptr{Int64}, icntl::Ptr{Int64})::Cvoid +end + function ma57yd(n, fact, lfact, ifact, lifact, rhs, lrhs, w, lw, iw1, icntl) @ccall libhsl.ma57yd_(n::Ref{Cint}, fact::Ptr{Float64}, lfact::Ref{Cint}, ifact::Ptr{Cint}, lifact::Ref{Cint}, rhs::Ptr{Float64}, lrhs::Ref{Cint}, w::Ptr{Float64}, lw::Ref{Cint}, iw1::Ptr{Cint}, icntl::Ptr{Cint})::Cvoid end +function ma57yd_64(n, fact, lfact, ifact, lifact, rhs, lrhs, w, lw, iw1, icntl) + @ccall libhsl_subset_64.ma57yd_64_(n::Ref{Int64}, fact::Ptr{Float64}, lfact::Ref{Int64}, + ifact::Ptr{Int64}, lifact::Ref{Int64}, rhs::Ptr{Float64}, + lrhs::Ref{Int64}, w::Ptr{Float64}, lw::Ref{Int64}, + iw1::Ptr{Int64}, icntl::Ptr{Int64})::Cvoid +end + function ma57vd(n, nz, irn, icn, iw, lw, ipe, iq, flag, iwfr, icntl, info) @ccall libhsl.ma57vd_(n::Ref{Cint}, nz::Ref{Cint}, irn::Ptr{Cint}, icn::Ptr{Cint}, iw::Ptr{Cint}, lw::Ref{Cint}, ipe::Ptr{Cint}, iq::Ptr{Cint}, flag::Ptr{Cint}, iwfr::Ref{Cint}, icntl::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function ma57vd_64(n, nz, irn, icn, iw, lw, ipe, iq, flag, iwfr, icntl, info) + @ccall libhsl_subset_64.ma57vd_64_(n::Ref{Int64}, nz::Ref{Int64}, irn::Ptr{Int64}, + icn::Ptr{Int64}, iw::Ptr{Int64}, lw::Ref{Int64}, + ipe::Ptr{Int64}, iq::Ptr{Int64}, flag::Ptr{Int64}, + iwfr::Ref{Int64}, icntl::Ptr{Int64}, info::Ptr{Int64})::Cvoid +end + function ma57hd(n, ipe, iw, lw, iwfr, nv, nxt, lst, ipd, flag, iovflo, ncmpa, fratio) @ccall libhsl.ma57hd_(n::Ref{Cint}, ipe::Ptr{Cint}, iw::Ptr{Cint}, lw::Ref{Cint}, iwfr::Ref{Cint}, nv::Ptr{Cint}, nxt::Ptr{Cint}, lst::Ptr{Cint}, ipd::Ptr{Cint}, @@ -153,21 +321,44 @@ function ma57hd(n, ipe, iw, lw, iwfr, nv, nxt, lst, ipd, flag, iovflo, ncmpa, fr fratio::Ref{Float64})::Cvoid end +function ma57hd_64(n, ipe, iw, lw, iwfr, nv, nxt, lst, ipd, flag, iovflo, ncmpa, fratio) + @ccall libhsl_subset_64.ma57hd_64_(n::Ref{Int64}, ipe::Ptr{Int64}, iw::Ptr{Int64}, lw::Ref{Int64}, + iwfr::Ref{Int64}, nv::Ptr{Int64}, nxt::Ptr{Int64}, + lst::Ptr{Int64}, ipd::Ptr{Int64}, flag::Ptr{Int64}, + iovflo::Ref{Int64}, ncmpa::Ref{Int64}, + fratio::Ref{Float64})::Cvoid +end + function ma57zd(n, ipe, iw, lw, iwfr, ncmpa) @ccall libhsl.ma57zd_(n::Ref{Cint}, ipe::Ptr{Cint}, iw::Ptr{Cint}, lw::Ref{Cint}, iwfr::Ref{Cint}, ncmpa::Ref{Cint})::Cvoid end +function ma57zd_64(n, ipe, iw, lw, iwfr, ncmpa) + @ccall libhsl_subset_64.ma57zd_64_(n::Ref{Int64}, ipe::Ptr{Int64}, iw::Ptr{Int64}, lw::Ref{Int64}, + iwfr::Ref{Int64}, ncmpa::Ref{Int64})::Cvoid +end + function ma57i(cntl, icntl) @ccall libhsl.ma57i_(cntl::Ptr{Float32}, icntl::Ptr{Cint})::Cvoid end +function ma57i_64(cntl, icntl) + @ccall libhsl_subset_64.ma57i_64_(cntl::Ptr{Float32}, icntl::Ptr{Int64})::Cvoid +end + function ma57a(n, ne, irn, jcn, lkeep, keep, iwork, icntl, info, rinfo) @ccall libhsl.ma57a_(n::Ref{Cint}, ne::Ref{Cint}, irn::Ptr{Cint}, jcn::Ptr{Cint}, lkeep::Ref{Cint}, keep::Ptr{Cint}, iwork::Ptr{Cint}, icntl::Ptr{Cint}, info::Ptr{Cint}, rinfo::Ptr{Float32})::Cvoid end +function ma57a_64(n, ne, irn, jcn, lkeep, keep, iwork, icntl, info, rinfo) + @ccall libhsl_subset_64.ma57a_64_(n::Ref{Int64}, ne::Ref{Int64}, irn::Ptr{Int64}, jcn::Ptr{Int64}, + lkeep::Ref{Int64}, keep::Ptr{Int64}, iwork::Ptr{Int64}, + icntl::Ptr{Int64}, info::Ptr{Int64}, rinfo::Ptr{Float32})::Cvoid +end + function ma57b(n, ne, a, fact, lfact, ifact, lifact, lkeep, keep, ppos, icntl, cntl, info, rinfo) @ccall libhsl.ma57b_(n::Ref{Cint}, ne::Ref{Cint}, a::Ptr{Float32}, fact::Ptr{Float32}, lfact::Ref{Cint}, ifact::Ptr{Cint}, lifact::Ref{Cint}, lkeep::Ref{Cint}, @@ -175,6 +366,14 @@ function ma57b(n, ne, a, fact, lfact, ifact, lifact, lkeep, keep, ppos, icntl, c info::Ptr{Cint}, rinfo::Ptr{Float32})::Cvoid end +function ma57b_64(n, ne, a, fact, lfact, ifact, lifact, lkeep, keep, ppos, icntl, cntl, info, rinfo) + @ccall libhsl_subset_64.ma57b_64_(n::Ref{Int64}, ne::Ref{Int64}, a::Ptr{Float32}, + fact::Ptr{Float32}, lfact::Ref{Int64}, ifact::Ptr{Int64}, + lifact::Ref{Int64}, lkeep::Ref{Int64}, keep::Ptr{Int64}, + ppos::Ptr{Int64}, icntl::Ptr{Int64}, cntl::Ptr{Float32}, + info::Ptr{Int64}, rinfo::Ptr{Float32})::Cvoid +end + function ma57c(job, n, fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, iw1, icntl, info) @ccall libhsl.ma57c_(job::Ref{Cint}, n::Ref{Cint}, fact::Ptr{Float32}, lfact::Ref{Cint}, ifact::Ptr{Cint}, lifact::Ref{Cint}, nrhs::Ref{Cint}, rhs::Ptr{Float32}, @@ -182,35 +381,76 @@ function ma57c(job, n, fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, iw1, icntl::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function ma57c_64(job, n, fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, iw1, icntl, info) + @ccall libhsl_subset_64.ma57c_64_(job::Ref{Int64}, n::Ref{Int64}, fact::Ptr{Float32}, + lfact::Ref{Int64}, ifact::Ptr{Int64}, lifact::Ref{Int64}, + nrhs::Ref{Int64}, rhs::Ptr{Float32}, lrhs::Ref{Int64}, + w::Ptr{Float32}, lw::Ref{Int64}, iw1::Ptr{Int64}, + icntl::Ptr{Int64}, info::Ptr{Int64})::Cvoid +end + function ma57q(n, fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, iw1, icntl) @ccall libhsl.ma57q_(n::Ref{Cint}, fact::Ptr{Float32}, lfact::Ref{Cint}, ifact::Ptr{Cint}, lifact::Ref{Cint}, nrhs::Ref{Cint}, rhs::Ptr{Float32}, lrhs::Ref{Cint}, w::Ptr{Float32}, lw::Ref{Cint}, iw1::Ptr{Cint}, icntl::Ptr{Cint})::Cvoid end +function ma57q_64(n, fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, iw1, icntl) + @ccall libhsl_subset_64.ma57q_64_(n::Ref{Int64}, fact::Ptr{Float32}, lfact::Ref{Int64}, + ifact::Ptr{Int64}, lifact::Ref{Int64}, nrhs::Ref{Int64}, + rhs::Ptr{Float32}, lrhs::Ref{Int64}, w::Ptr{Float32}, + lw::Ref{Int64}, iw1::Ptr{Int64}, icntl::Ptr{Int64})::Cvoid +end + function ma57r(n, fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, iw1, icntl) @ccall libhsl.ma57r_(n::Ref{Cint}, fact::Ptr{Float32}, lfact::Ref{Cint}, ifact::Ptr{Cint}, lifact::Ref{Cint}, nrhs::Ref{Cint}, rhs::Ptr{Float32}, lrhs::Ref{Cint}, w::Ptr{Float32}, lw::Ref{Cint}, iw1::Ptr{Cint}, icntl::Ptr{Cint})::Cvoid end +function ma57r_64(n, fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, iw1, icntl) + @ccall libhsl_subset_64.ma57r_64_(n::Ref{Int64}, fact::Ptr{Float32}, lfact::Ref{Int64}, + ifact::Ptr{Int64}, lifact::Ref{Int64}, nrhs::Ref{Int64}, + rhs::Ptr{Float32}, lrhs::Ref{Int64}, w::Ptr{Float32}, + lw::Ref{Int64}, iw1::Ptr{Int64}, icntl::Ptr{Int64})::Cvoid +end + function ma57u(fact, lfact, ifact, lifact, icntl) @ccall libhsl.ma57u_(fact::Ptr{Float32}, lfact::Ref{Cint}, ifact::Ptr{Cint}, lifact::Ref{Cint}, icntl::Ptr{Cint})::Cvoid end +function ma57u_64(fact, lfact, ifact, lifact, icntl) + @ccall libhsl_subset_64.ma57u_64_(fact::Ptr{Float32}, lfact::Ref{Int64}, ifact::Ptr{Int64}, + lifact::Ref{Int64}, icntl::Ptr{Int64})::Cvoid +end + function ma57s(fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, icntl) @ccall libhsl.ma57s_(fact::Ptr{Float32}, lfact::Ref{Cint}, ifact::Ptr{Cint}, lifact::Ref{Cint}, nrhs::Ref{Cint}, rhs::Ptr{Float32}, lrhs::Ref{Cint}, w::Ptr{Float32}, lw::Ref{Cint}, icntl::Ptr{Cint})::Cvoid end +function ma57s_64(fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, icntl) + @ccall libhsl_subset_64.ma57s_64_(fact::Ptr{Float32}, lfact::Ref{Int64}, ifact::Ptr{Int64}, + lifact::Ref{Int64}, nrhs::Ref{Int64}, rhs::Ptr{Float32}, + lrhs::Ref{Int64}, w::Ptr{Float32}, lw::Ref{Int64}, + icntl::Ptr{Int64})::Cvoid +end + function ma57t(n, fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, iw1, icntl) @ccall libhsl.ma57t_(n::Ref{Cint}, fact::Ptr{Float32}, lfact::Ref{Cint}, ifact::Ptr{Cint}, lifact::Ref{Cint}, nrhs::Ref{Cint}, rhs::Ptr{Float32}, lrhs::Ref{Cint}, w::Ptr{Float32}, lw::Ref{Cint}, iw1::Ptr{Cint}, icntl::Ptr{Cint})::Cvoid end +function ma57t_64(n, fact, lfact, ifact, lifact, nrhs, rhs, lrhs, w, lw, iw1, icntl) + @ccall libhsl_subset_64.ma57t_64_(n::Ref{Int64}, fact::Ptr{Float32}, lfact::Ref{Int64}, + ifact::Ptr{Int64}, lifact::Ref{Int64}, nrhs::Ref{Int64}, + rhs::Ptr{Float32}, lrhs::Ref{Int64}, w::Ptr{Float32}, + lw::Ref{Int64}, iw1::Ptr{Int64}, icntl::Ptr{Int64})::Cvoid +end + function ma57d(job, n, ne, a, irn, jcn, fact, lfact, ifact, lifact, rhs, x, resid, w, iw, icntl, cntl, info, rinfo) @ccall libhsl.ma57d_(job::Ref{Cint}, n::Ref{Cint}, ne::Ref{Cint}, a::Ptr{Float32}, irn::Ptr{Cint}, @@ -220,6 +460,17 @@ function ma57d(job, n, ne, a, irn, jcn, fact, lfact, ifact, lifact, rhs, x, resi info::Ptr{Cint}, rinfo::Ptr{Float32})::Cvoid end +function ma57d_64(job, n, ne, a, irn, jcn, fact, lfact, ifact, lifact, rhs, x, resid, w, iw, icntl, + cntl, info, rinfo) + @ccall libhsl_subset_64.ma57d_64_(job::Ref{Int64}, n::Ref{Int64}, ne::Ref{Int64}, a::Ptr{Float32}, + irn::Ptr{Int64}, jcn::Ptr{Int64}, fact::Ptr{Float32}, + lfact::Ref{Int64}, ifact::Ptr{Int64}, lifact::Ref{Int64}, + rhs::Ptr{Float32}, x::Ptr{Float32}, resid::Ptr{Float32}, + w::Ptr{Float32}, iw::Ptr{Int64}, icntl::Ptr{Int64}, + cntl::Ptr{Float32}, info::Ptr{Int64}, + rinfo::Ptr{Float32})::Cvoid +end + function ma57e(n, ic, keep, fact, lfact, newfac, lnew, ifact, lifact, newifc, linew, info) @ccall libhsl.ma57e_(n::Ref{Cint}, ic::Ref{Cint}, keep::Ptr{Cint}, fact::Ptr{Float32}, lfact::Ref{Cint}, newfac::Ptr{Float32}, lnew::Ref{Cint}, ifact::Ptr{Cint}, @@ -227,29 +478,61 @@ function ma57e(n, ic, keep, fact, lfact, newfac, lnew, ifact, lifact, newifc, li info::Ptr{Cint})::Cvoid end +function ma57e_64(n, ic, keep, fact, lfact, newfac, lnew, ifact, lifact, newifc, linew, info) + @ccall libhsl_subset_64.ma57e_64_(n::Ref{Int64}, ic::Ref{Int64}, keep::Ptr{Int64}, + fact::Ptr{Float32}, lfact::Ref{Int64}, newfac::Ptr{Float32}, + lnew::Ref{Int64}, ifact::Ptr{Int64}, lifact::Ref{Int64}, + newifc::Ptr{Int64}, linew::Ref{Int64}, info::Ptr{Int64})::Cvoid +end + function ma57g(n, ne, irn, jcn, iw, ipe, count, flag, iwfr, icntl, info) @ccall libhsl.ma57g_(n::Ref{Cint}, ne::Ref{Cint}, irn::Ptr{Cint}, jcn::Ptr{Cint}, iw::Ptr{Cint}, ipe::Ptr{Cint}, count::Ptr{Cint}, flag::Ptr{Cint}, iwfr::Ref{Cint}, icntl::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function ma57g_64(n, ne, irn, jcn, iw, ipe, count, flag, iwfr, icntl, info) + @ccall libhsl_subset_64.ma57g_64_(n::Ref{Int64}, ne::Ref{Int64}, irn::Ptr{Int64}, jcn::Ptr{Int64}, + iw::Ptr{Int64}, ipe::Ptr{Int64}, count::Ptr{Int64}, + flag::Ptr{Int64}, iwfr::Ref{Int64}, icntl::Ptr{Int64}, + info::Ptr{Int64})::Cvoid +end + function ma57j(n, ne, irn, jcn, perm, iw, ipe, count, flag, iwfr, icntl, info) @ccall libhsl.ma57j_(n::Ref{Cint}, ne::Ref{Cint}, irn::Ptr{Cint}, jcn::Ptr{Cint}, perm::Ptr{Cint}, iw::Ptr{Cint}, ipe::Ptr{Cint}, count::Ptr{Cint}, flag::Ptr{Cint}, iwfr::Ref{Cint}, icntl::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function ma57j_64(n, ne, irn, jcn, perm, iw, ipe, count, flag, iwfr, icntl, info) + @ccall libhsl_subset_64.ma57j_64_(n::Ref{Int64}, ne::Ref{Int64}, irn::Ptr{Int64}, jcn::Ptr{Int64}, + perm::Ptr{Int64}, iw::Ptr{Int64}, ipe::Ptr{Int64}, + count::Ptr{Int64}, flag::Ptr{Int64}, iwfr::Ref{Int64}, + icntl::Ptr{Int64}, info::Ptr{Int64})::Cvoid +end + function ma57k(n, ipe, iw, lw, iwfr, perm, ips, nv, flag, ncmpa) @ccall libhsl.ma57k_(n::Ref{Cint}, ipe::Ptr{Cint}, iw::Ptr{Cint}, lw::Ref{Cint}, iwfr::Ref{Cint}, perm::Ptr{Cint}, ips::Ptr{Cint}, nv::Ptr{Cint}, flag::Ptr{Cint}, ncmpa::Ref{Cint})::Cvoid end +function ma57k_64(n, ipe, iw, lw, iwfr, perm, ips, nv, flag, ncmpa) + @ccall libhsl_subset_64.ma57k_64_(n::Ref{Int64}, ipe::Ptr{Int64}, iw::Ptr{Int64}, lw::Ref{Int64}, + iwfr::Ref{Int64}, perm::Ptr{Int64}, ips::Ptr{Int64}, + nv::Ptr{Int64}, flag::Ptr{Int64}, ncmpa::Ref{Int64})::Cvoid +end + function ma57f(n, ipe, iw, lw, iwfr, ncmpa) @ccall libhsl.ma57f_(n::Ref{Cint}, ipe::Ptr{Cint}, iw::Ptr{Cint}, lw::Ref{Cint}, iwfr::Ref{Cint}, ncmpa::Ref{Cint})::Cvoid end +function ma57f_64(n, ipe, iw, lw, iwfr, ncmpa) + @ccall libhsl_subset_64.ma57f_64_(n::Ref{Int64}, ipe::Ptr{Int64}, iw::Ptr{Int64}, lw::Ref{Int64}, + iwfr::Ref{Int64}, ncmpa::Ref{Int64})::Cvoid +end + function ma57l(n, ipe, nv, ips, ne, na, node, perm, nsteps, fils, frere, nd, nemin, subord) @ccall libhsl.ma57l_(n::Ref{Cint}, ipe::Ptr{Cint}, nv::Ptr{Cint}, ips::Ptr{Cint}, ne::Ptr{Cint}, na::Ptr{Cint}, node::Ptr{Cint}, perm::Ptr{Cint}, nsteps::Ref{Cint}, @@ -257,18 +540,38 @@ function ma57l(n, ipe, nv, ips, ne, na, node, perm, nsteps, fils, frere, nd, nem subord::Ptr{Cint})::Cvoid end +function ma57l_64(n, ipe, nv, ips, ne, na, node, perm, nsteps, fils, frere, nd, nemin, subord) + @ccall libhsl_subset_64.ma57l_64_(n::Ref{Int64}, ipe::Ptr{Int64}, nv::Ptr{Int64}, ips::Ptr{Int64}, + ne::Ptr{Int64}, na::Ptr{Int64}, node::Ptr{Int64}, + perm::Ptr{Int64}, nsteps::Ref{Int64}, fils::Ptr{Int64}, + frere::Ptr{Int64}, nd::Ptr{Int64}, nemin::Ref{Int64}, + subord::Ptr{Int64})::Cvoid +end + function ma57m(n, ne, irn, jcn, map, irnprm, lrow, perm, count, idiag) @ccall libhsl.ma57m_(n::Ref{Cint}, ne::Ref{Cint}, irn::Ptr{Cint}, jcn::Ptr{Cint}, map::Ptr{Cint}, irnprm::Ptr{Cint}, lrow::Ptr{Cint}, perm::Ptr{Cint}, count::Ptr{Cint}, idiag::Ptr{Cint})::Cvoid end +function ma57m_64(n, ne, irn, jcn, map, irnprm, lrow, perm, count, idiag) + @ccall libhsl_subset_64.ma57m_64_(n::Ref{Int64}, ne::Ref{Int64}, irn::Ptr{Int64}, jcn::Ptr{Int64}, + map::Ptr{Int64}, irnprm::Ptr{Int64}, lrow::Ptr{Int64}, + perm::Ptr{Int64}, count::Ptr{Int64}, idiag::Ptr{Int64})::Cvoid +end + function ma57n(n, lenr, na, ne, nd, nsteps, lstki, lstkr, info, rinfo) @ccall libhsl.ma57n_(n::Ref{Cint}, lenr::Ptr{Cint}, na::Ptr{Cint}, ne::Ptr{Cint}, nd::Ptr{Cint}, nsteps::Ref{Cint}, lstki::Ptr{Cint}, lstkr::Ptr{Cint}, info::Ptr{Cint}, rinfo::Ptr{Float32})::Cvoid end +function ma57n_64(n, lenr, na, ne, nd, nsteps, lstki, lstkr, info, rinfo) + @ccall libhsl_subset_64.ma57n_64_(n::Ref{Int64}, lenr::Ptr{Int64}, na::Ptr{Int64}, ne::Ptr{Int64}, + nd::Ptr{Int64}, nsteps::Ref{Int64}, lstki::Ptr{Int64}, + lstkr::Ptr{Int64}, info::Ptr{Int64}, rinfo::Ptr{Float32})::Cvoid +end + function ma57o(n, ne, a, la, iw, liw, lrow, perm, nsteps, nstk, node, diag, schnab, ppos, cntl, icntl, info, rinfo, hold, biga) @ccall libhsl.ma57o_(n::Ref{Cint}, ne::Ref{Cint}, a::Ptr{Float32}, la::Ref{Cint}, iw::Ptr{Cint}, @@ -278,34 +581,76 @@ function ma57o(n, ne, a, la, iw, liw, lrow, perm, nsteps, nstk, node, diag, schn rinfo::Ptr{Float32}, hold::Ptr{Cint}, biga::Ref{Float32})::Cvoid end +function ma57o_64(n, ne, a, la, iw, liw, lrow, perm, nsteps, nstk, node, diag, schnab, ppos, cntl, + icntl, info, rinfo, hold, biga) + @ccall libhsl_subset_64.ma57o_64_(n::Ref{Int64}, ne::Ref{Int64}, a::Ptr{Float32}, la::Ref{Int64}, + iw::Ptr{Int64}, liw::Ref{Int64}, lrow::Ptr{Int64}, + perm::Ptr{Int64}, nsteps::Ref{Int64}, nstk::Ptr{Int64}, + node::Ptr{Int64}, diag::Ptr{Float32}, schnab::Ptr{Float32}, + ppos::Ptr{Int64}, cntl::Ptr{Float32}, icntl::Ptr{Int64}, + info::Ptr{Int64}, rinfo::Ptr{Float32}, hold::Ptr{Int64}, + biga::Ref{Float32})::Cvoid +end + function ma57p(a, iw, j1, j2, itop, real) @ccall libhsl.ma57p_(a::Ptr{Float32}, iw::Ptr{Cint}, j1::Ref{Cint}, j2::Ref{Cint}, itop::Ref{Cint}, real::Ref{Cint})::Cvoid end +function ma57p_64(a, iw, j1, j2, itop, real) + @ccall libhsl_subset_64.ma57p_64_(a::Ptr{Float32}, iw::Ptr{Int64}, j1::Ref{Int64}, j2::Ref{Int64}, + itop::Ref{Int64}, real::Ref{Int64})::Cvoid +end + function ma57w(a, la, iw, liw, nrlbdu) @ccall libhsl.ma57w_(a::Ptr{Float32}, la::Ref{Cint}, iw::Ptr{Cint}, liw::Ref{Cint}, nrlbdu::Ref{Cint})::Cvoid end +function ma57w_64(a, la, iw, liw, nrlbdu) + @ccall libhsl_subset_64.ma57w_64_(a::Ptr{Float32}, la::Ref{Int64}, iw::Ptr{Int64}, + liw::Ref{Int64}, nrlbdu::Ref{Int64})::Cvoid +end + function ma57x(n, fact, lfact, ifact, lifact, rhs, lrhs, w, lw, iw1, icntl) @ccall libhsl.ma57x_(n::Ref{Cint}, fact::Ptr{Float32}, lfact::Ref{Cint}, ifact::Ptr{Cint}, lifact::Ref{Cint}, rhs::Ptr{Float32}, lrhs::Ref{Cint}, w::Ptr{Float32}, lw::Ref{Cint}, iw1::Ptr{Cint}, icntl::Ptr{Cint})::Cvoid end +function ma57x_64(n, fact, lfact, ifact, lifact, rhs, lrhs, w, lw, iw1, icntl) + @ccall libhsl_subset_64.ma57x_64_(n::Ref{Int64}, fact::Ptr{Float32}, lfact::Ref{Int64}, + ifact::Ptr{Int64}, lifact::Ref{Int64}, rhs::Ptr{Float32}, + lrhs::Ref{Int64}, w::Ptr{Float32}, lw::Ref{Int64}, + iw1::Ptr{Int64}, icntl::Ptr{Int64})::Cvoid +end + function ma57y(n, fact, lfact, ifact, lifact, rhs, lrhs, w, lw, iw1, icntl) @ccall libhsl.ma57y_(n::Ref{Cint}, fact::Ptr{Float32}, lfact::Ref{Cint}, ifact::Ptr{Cint}, lifact::Ref{Cint}, rhs::Ptr{Float32}, lrhs::Ref{Cint}, w::Ptr{Float32}, lw::Ref{Cint}, iw1::Ptr{Cint}, icntl::Ptr{Cint})::Cvoid end +function ma57y_64(n, fact, lfact, ifact, lifact, rhs, lrhs, w, lw, iw1, icntl) + @ccall libhsl_subset_64.ma57y_64_(n::Ref{Int64}, fact::Ptr{Float32}, lfact::Ref{Int64}, + ifact::Ptr{Int64}, lifact::Ref{Int64}, rhs::Ptr{Float32}, + lrhs::Ref{Int64}, w::Ptr{Float32}, lw::Ref{Int64}, + iw1::Ptr{Int64}, icntl::Ptr{Int64})::Cvoid +end + function ma57v(n, nz, irn, icn, iw, lw, ipe, iq, flag, iwfr, icntl, info) @ccall libhsl.ma57v_(n::Ref{Cint}, nz::Ref{Cint}, irn::Ptr{Cint}, icn::Ptr{Cint}, iw::Ptr{Cint}, lw::Ref{Cint}, ipe::Ptr{Cint}, iq::Ptr{Cint}, flag::Ptr{Cint}, iwfr::Ref{Cint}, icntl::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function ma57v_64(n, nz, irn, icn, iw, lw, ipe, iq, flag, iwfr, icntl, info) + @ccall libhsl_subset_64.ma57v_64_(n::Ref{Int64}, nz::Ref{Int64}, irn::Ptr{Int64}, icn::Ptr{Int64}, + iw::Ptr{Int64}, lw::Ref{Int64}, ipe::Ptr{Int64}, iq::Ptr{Int64}, + flag::Ptr{Int64}, iwfr::Ref{Int64}, icntl::Ptr{Int64}, + info::Ptr{Int64})::Cvoid +end + function ma57h(n, ipe, iw, lw, iwfr, nv, nxt, lst, ipd, flag, iovflo, ncmpa, fratio) @ccall libhsl.ma57h_(n::Ref{Cint}, ipe::Ptr{Cint}, iw::Ptr{Cint}, lw::Ref{Cint}, iwfr::Ref{Cint}, nv::Ptr{Cint}, nxt::Ptr{Cint}, lst::Ptr{Cint}, ipd::Ptr{Cint}, @@ -313,7 +658,20 @@ function ma57h(n, ipe, iw, lw, iwfr, nv, nxt, lst, ipd, flag, iovflo, ncmpa, fra fratio::Ref{Float32})::Cvoid end +function ma57h_64(n, ipe, iw, lw, iwfr, nv, nxt, lst, ipd, flag, iovflo, ncmpa, fratio) + @ccall libhsl_subset_64.ma57h_64_(n::Ref{Int64}, ipe::Ptr{Int64}, iw::Ptr{Int64}, lw::Ref{Int64}, + iwfr::Ref{Int64}, nv::Ptr{Int64}, nxt::Ptr{Int64}, + lst::Ptr{Int64}, ipd::Ptr{Int64}, flag::Ptr{Int64}, + iovflo::Ref{Int64}, ncmpa::Ref{Int64}, + fratio::Ref{Float32})::Cvoid +end + function ma57z(n, ipe, iw, lw, iwfr, ncmpa) @ccall libhsl.ma57z_(n::Ref{Cint}, ipe::Ptr{Cint}, iw::Ptr{Cint}, lw::Ref{Cint}, iwfr::Ref{Cint}, ncmpa::Ref{Cint})::Cvoid end + +function ma57z_64(n, ipe, iw, lw, iwfr, ncmpa) + @ccall libhsl_subset_64.ma57z_64_(n::Ref{Int64}, ipe::Ptr{Int64}, iw::Ptr{Int64}, lw::Ref{Int64}, + iwfr::Ref{Int64}, ncmpa::Ref{Int64})::Cvoid +end diff --git a/src/Fortran/ma61.jl b/src/Fortran/ma61.jl index f3be2e5..ae59eee 100644 --- a/src/Fortran/ma61.jl +++ b/src/Fortran/ma61.jl @@ -2,6 +2,10 @@ function ma61id(icntl, cntl, keep) @ccall libhsl.ma61id_(icntl::Ptr{Cint}, cntl::Ptr{Float64}, keep::Ptr{Cint})::Cvoid end +function ma61id_64(icntl, cntl, keep) + @ccall libhsl_subset_64.ma61id_64_(icntl::Ptr{Int64}, cntl::Ptr{Float64}, keep::Ptr{Int64})::Cvoid +end + function ma61ad(n, nz, a, ini, inj, iai, iaj, ik, iw, w, c, icntl, cntl, info, keep) @ccall libhsl.ma61ad_(n::Ref{Cint}, nz::Ref{Cint}, a::Ptr{Float64}, ini::Ptr{Cint}, inj::Ptr{Cint}, iai::Ref{Cint}, iaj::Ref{Cint}, ik::Ptr{Cint}, @@ -9,6 +13,14 @@ function ma61ad(n, nz, a, ini, inj, iai, iaj, ik, iw, w, c, icntl, cntl, info, k cntl::Ptr{Float64}, info::Ptr{Cint}, keep::Ptr{Cint})::Cvoid end +function ma61ad_64(n, nz, a, ini, inj, iai, iaj, ik, iw, w, c, icntl, cntl, info, keep) + @ccall libhsl_subset_64.ma61ad_64_(n::Ref{Int64}, nz::Ref{Int64}, a::Ptr{Float64}, + ini::Ptr{Int64}, inj::Ptr{Int64}, iai::Ref{Int64}, + iaj::Ref{Int64}, ik::Ptr{Int64}, iw::Ptr{Int64}, + w::Ptr{Float64}, c::Ref{Float64}, icntl::Ptr{Int64}, + cntl::Ptr{Float64}, info::Ptr{Int64}, keep::Ptr{Int64})::Cvoid +end + function ma61cd(n, nz, d, a, ini, inj, iai, iaj, ik, ip, iw, w, iflag, c, icntl, cntl, keep) @ccall libhsl.ma61cd_(n::Ref{Cint}, nz::Ref{Cint}, d::Ptr{Float64}, a::Ptr{Float64}, ini::Ptr{Cint}, inj::Ptr{Cint}, iai::Ref{Cint}, iaj::Ref{Cint}, @@ -17,22 +29,48 @@ function ma61cd(n, nz, d, a, ini, inj, iai, iaj, ik, ip, iw, w, iflag, c, icntl, keep::Ptr{Cint})::Cvoid end +function ma61cd_64(n, nz, d, a, ini, inj, iai, iaj, ik, ip, iw, w, iflag, c, icntl, cntl, keep) + @ccall libhsl_subset_64.ma61cd_64_(n::Ref{Int64}, nz::Ref{Int64}, d::Ptr{Float64}, + a::Ptr{Float64}, ini::Ptr{Int64}, inj::Ptr{Int64}, + iai::Ref{Int64}, iaj::Ref{Int64}, ik::Ptr{Int64}, + ip::Ptr{Int64}, iw::Ptr{Int64}, w::Ptr{Float64}, + iflag::Ref{Int64}, c::Ref{Float64}, icntl::Ptr{Int64}, + cntl::Ptr{Float64}, keep::Ptr{Int64})::Cvoid +end + function ma61dd(a, irn, ia, n, ik, ip, row, ncp, nucl, nual) @ccall libhsl.ma61dd_(a::Ptr{Float64}, irn::Ptr{Cint}, ia::Ref{Cint}, n::Ref{Cint}, ik::Ptr{Cint}, ip::Ptr{Cint}, row::Ref{Cint}, ncp::Ref{Cint}, nucl::Ref{Cint}, nual::Ref{Cint})::Cvoid end +function ma61dd_64(a, irn, ia, n, ik, ip, row, ncp, nucl, nual) + @ccall libhsl_subset_64.ma61dd_64_(a::Ptr{Float64}, irn::Ptr{Int64}, ia::Ref{Int64}, + n::Ref{Int64}, ik::Ptr{Int64}, ip::Ptr{Int64}, row::Ref{Int64}, + ncp::Ref{Int64}, nucl::Ref{Int64}, nual::Ref{Int64})::Cvoid +end + function ma61ed(in1, in2, nz, ip, n, a) @ccall libhsl.ma61ed_(in1::Ptr{Cint}, in2::Ptr{Cint}, nz::Ref{Cint}, ip::Ptr{Cint}, n::Ref{Cint}, a::Ptr{Float64})::Cvoid end +function ma61ed_64(in1, in2, nz, ip, n, a) + @ccall libhsl_subset_64.ma61ed_64_(in1::Ptr{Int64}, in2::Ptr{Int64}, nz::Ref{Int64}, + ip::Ptr{Int64}, n::Ref{Int64}, a::Ptr{Float64})::Cvoid +end + function ma61gd(n, a, inj, iaj, d, ik, b, lrow) @ccall libhsl.ma61gd_(n::Ref{Cint}, a::Ptr{Float64}, inj::Ptr{Cint}, iaj::Ref{Cint}, d::Ptr{Float64}, ik::Ptr{Cint}, b::Ptr{Float64}, lrow::Ref{Cint})::Cvoid end +function ma61gd_64(n, a, inj, iaj, d, ik, b, lrow) + @ccall libhsl_subset_64.ma61gd_64_(n::Ref{Int64}, a::Ptr{Float64}, inj::Ptr{Int64}, + iaj::Ref{Int64}, d::Ptr{Float64}, ik::Ptr{Int64}, + b::Ptr{Float64}, lrow::Ref{Int64})::Cvoid +end + function ma61bd(n, nz, a, ini, inj, iaj, ik, b, w, w1, kmax, eps, icntl, info, keep) @ccall libhsl.ma61bd_(n::Ref{Cint}, nz::Ref{Cint}, a::Ptr{Float64}, ini::Ptr{Cint}, inj::Ptr{Cint}, iaj::Ref{Cint}, ik::Ptr{Cint}, b::Ptr{Float64}, @@ -40,6 +78,14 @@ function ma61bd(n, nz, a, ini, inj, iaj, ik, b, w, w1, kmax, eps, icntl, info, k icntl::Ptr{Cint}, info::Ptr{Cint}, keep::Ptr{Cint})::Cvoid end +function ma61bd_64(n, nz, a, ini, inj, iaj, ik, b, w, w1, kmax, eps, icntl, info, keep) + @ccall libhsl_subset_64.ma61bd_64_(n::Ref{Int64}, nz::Ref{Int64}, a::Ptr{Float64}, + ini::Ptr{Int64}, inj::Ptr{Int64}, iaj::Ref{Int64}, + ik::Ptr{Int64}, b::Ptr{Float64}, w::Ptr{Float64}, + w1::Ptr{Float64}, kmax::Ptr{Int64}, eps::Ptr{Float64}, + icntl::Ptr{Int64}, info::Ptr{Int64}, keep::Ptr{Int64})::Cvoid +end + function ma61fd(n, nz, a, ini, inj, iaf, af, df, injf, ik, b, r, e, f, g, kmax, eps, lrow) @ccall libhsl.ma61fd_(n::Ref{Cint}, nz::Ref{Cint}, a::Ptr{Float64}, ini::Ptr{Cint}, inj::Ptr{Cint}, iaf::Ref{Cint}, af::Ptr{Float64}, df::Ptr{Float64}, @@ -48,15 +94,34 @@ function ma61fd(n, nz, a, ini, inj, iaf, af, df, injf, ik, b, r, e, f, g, kmax, eps::Ref{Float64}, lrow::Ref{Cint})::Cvoid end +function ma61fd_64(n, nz, a, ini, inj, iaf, af, df, injf, ik, b, r, e, f, g, kmax, eps, lrow) + @ccall libhsl_subset_64.ma61fd_64_(n::Ref{Int64}, nz::Ref{Int64}, a::Ptr{Float64}, + ini::Ptr{Int64}, inj::Ptr{Int64}, iaf::Ref{Int64}, + af::Ptr{Float64}, df::Ptr{Float64}, injf::Ptr{Int64}, + ik::Ptr{Int64}, b::Ptr{Float64}, r::Ptr{Float64}, + e::Ptr{Float64}, f::Ptr{Float64}, g::Ptr{Float64}, + kmax::Ref{Int64}, eps::Ref{Float64}, lrow::Ref{Int64})::Cvoid +end + function ma61hd(a, ini, inj, nz, n, b, z) @ccall libhsl.ma61hd_(a::Ptr{Float64}, ini::Ptr{Cint}, inj::Ptr{Cint}, nz::Ref{Cint}, n::Ref{Cint}, b::Ptr{Float64}, z::Ptr{Float64})::Cvoid end +function ma61hd_64(a, ini, inj, nz, n, b, z) + @ccall libhsl_subset_64.ma61hd_64_(a::Ptr{Float64}, ini::Ptr{Int64}, inj::Ptr{Int64}, + nz::Ref{Int64}, n::Ref{Int64}, b::Ptr{Float64}, + z::Ptr{Float64})::Cvoid +end + function ma61i(icntl, cntl, keep) @ccall libhsl.ma61i_(icntl::Ptr{Cint}, cntl::Ptr{Float32}, keep::Ptr{Cint})::Cvoid end +function ma61i_64(icntl, cntl, keep) + @ccall libhsl_subset_64.ma61i_64_(icntl::Ptr{Int64}, cntl::Ptr{Float32}, keep::Ptr{Int64})::Cvoid +end + function ma61a(n, nz, a, ini, inj, iai, iaj, ik, iw, w, c, icntl, cntl, info, keep) @ccall libhsl.ma61a_(n::Ref{Cint}, nz::Ref{Cint}, a::Ptr{Float32}, ini::Ptr{Cint}, inj::Ptr{Cint}, iai::Ref{Cint}, iaj::Ref{Cint}, ik::Ptr{Cint}, iw::Ptr{Cint}, @@ -64,6 +129,14 @@ function ma61a(n, nz, a, ini, inj, iai, iaj, ik, iw, w, c, icntl, cntl, info, ke info::Ptr{Cint}, keep::Ptr{Cint})::Cvoid end +function ma61a_64(n, nz, a, ini, inj, iai, iaj, ik, iw, w, c, icntl, cntl, info, keep) + @ccall libhsl_subset_64.ma61a_64_(n::Ref{Int64}, nz::Ref{Int64}, a::Ptr{Float32}, ini::Ptr{Int64}, + inj::Ptr{Int64}, iai::Ref{Int64}, iaj::Ref{Int64}, + ik::Ptr{Int64}, iw::Ptr{Int64}, w::Ptr{Float32}, + c::Ref{Float32}, icntl::Ptr{Int64}, cntl::Ptr{Float32}, + info::Ptr{Int64}, keep::Ptr{Int64})::Cvoid +end + function ma61c(n, nz, d, a, ini, inj, iai, iaj, ik, ip, iw, w, iflag, c, icntl, cntl, keep) @ccall libhsl.ma61c_(n::Ref{Cint}, nz::Ref{Cint}, d::Ptr{Float32}, a::Ptr{Float32}, ini::Ptr{Cint}, inj::Ptr{Cint}, iai::Ref{Cint}, iaj::Ref{Cint}, @@ -72,22 +145,47 @@ function ma61c(n, nz, d, a, ini, inj, iai, iaj, ik, ip, iw, w, iflag, c, icntl, keep::Ptr{Cint})::Cvoid end +function ma61c_64(n, nz, d, a, ini, inj, iai, iaj, ik, ip, iw, w, iflag, c, icntl, cntl, keep) + @ccall libhsl_subset_64.ma61c_64_(n::Ref{Int64}, nz::Ref{Int64}, d::Ptr{Float32}, a::Ptr{Float32}, + ini::Ptr{Int64}, inj::Ptr{Int64}, iai::Ref{Int64}, + iaj::Ref{Int64}, ik::Ptr{Int64}, ip::Ptr{Int64}, iw::Ptr{Int64}, + w::Ptr{Float32}, iflag::Ref{Int64}, c::Ref{Float32}, + icntl::Ptr{Int64}, cntl::Ptr{Float32}, keep::Ptr{Int64})::Cvoid +end + function ma61d(a, irn, ia, n, ik, ip, row, ncp, nucl, nual) @ccall libhsl.ma61d_(a::Ptr{Float32}, irn::Ptr{Cint}, ia::Ref{Cint}, n::Ref{Cint}, ik::Ptr{Cint}, ip::Ptr{Cint}, row::Ref{Cint}, ncp::Ref{Cint}, nucl::Ref{Cint}, nual::Ref{Cint})::Cvoid end +function ma61d_64(a, irn, ia, n, ik, ip, row, ncp, nucl, nual) + @ccall libhsl_subset_64.ma61d_64_(a::Ptr{Float32}, irn::Ptr{Int64}, ia::Ref{Int64}, n::Ref{Int64}, + ik::Ptr{Int64}, ip::Ptr{Int64}, row::Ref{Int64}, + ncp::Ref{Int64}, nucl::Ref{Int64}, nual::Ref{Int64})::Cvoid +end + function ma61e(in1, in2, nz, ip, n, a) @ccall libhsl.ma61e_(in1::Ptr{Cint}, in2::Ptr{Cint}, nz::Ref{Cint}, ip::Ptr{Cint}, n::Ref{Cint}, a::Ptr{Float32})::Cvoid end +function ma61e_64(in1, in2, nz, ip, n, a) + @ccall libhsl_subset_64.ma61e_64_(in1::Ptr{Int64}, in2::Ptr{Int64}, nz::Ref{Int64}, + ip::Ptr{Int64}, n::Ref{Int64}, a::Ptr{Float32})::Cvoid +end + function ma61g(n, a, inj, iaj, d, ik, b, lrow) @ccall libhsl.ma61g_(n::Ref{Cint}, a::Ptr{Float32}, inj::Ptr{Cint}, iaj::Ref{Cint}, d::Ptr{Float32}, ik::Ptr{Cint}, b::Ptr{Float32}, lrow::Ref{Cint})::Cvoid end +function ma61g_64(n, a, inj, iaj, d, ik, b, lrow) + @ccall libhsl_subset_64.ma61g_64_(n::Ref{Int64}, a::Ptr{Float32}, inj::Ptr{Int64}, + iaj::Ref{Int64}, d::Ptr{Float32}, ik::Ptr{Int64}, + b::Ptr{Float32}, lrow::Ref{Int64})::Cvoid +end + function ma61b(n, nz, a, ini, inj, iaj, ik, b, w, w1, kmax, eps, icntl, info, keep) @ccall libhsl.ma61b_(n::Ref{Cint}, nz::Ref{Cint}, a::Ptr{Float32}, ini::Ptr{Cint}, inj::Ptr{Cint}, iaj::Ref{Cint}, ik::Ptr{Cint}, b::Ptr{Float32}, w::Ptr{Float32}, @@ -95,6 +193,14 @@ function ma61b(n, nz, a, ini, inj, iaj, ik, b, w, w1, kmax, eps, icntl, info, ke info::Ptr{Cint}, keep::Ptr{Cint})::Cvoid end +function ma61b_64(n, nz, a, ini, inj, iaj, ik, b, w, w1, kmax, eps, icntl, info, keep) + @ccall libhsl_subset_64.ma61b_64_(n::Ref{Int64}, nz::Ref{Int64}, a::Ptr{Float32}, ini::Ptr{Int64}, + inj::Ptr{Int64}, iaj::Ref{Int64}, ik::Ptr{Int64}, + b::Ptr{Float32}, w::Ptr{Float32}, w1::Ptr{Float32}, + kmax::Ptr{Int64}, eps::Ptr{Float32}, icntl::Ptr{Int64}, + info::Ptr{Int64}, keep::Ptr{Int64})::Cvoid +end + function ma61f(n, nz, a, ini, inj, iaf, af, df, injf, ik, b, r, e, f, g, kmax, eps, lrow) @ccall libhsl.ma61f_(n::Ref{Cint}, nz::Ref{Cint}, a::Ptr{Float32}, ini::Ptr{Cint}, inj::Ptr{Cint}, iaf::Ref{Cint}, af::Ptr{Float32}, df::Ptr{Float32}, injf::Ptr{Cint}, @@ -103,7 +209,22 @@ function ma61f(n, nz, a, ini, inj, iaf, af, df, injf, ik, b, r, e, f, g, kmax, e lrow::Ref{Cint})::Cvoid end +function ma61f_64(n, nz, a, ini, inj, iaf, af, df, injf, ik, b, r, e, f, g, kmax, eps, lrow) + @ccall libhsl_subset_64.ma61f_64_(n::Ref{Int64}, nz::Ref{Int64}, a::Ptr{Float32}, ini::Ptr{Int64}, + inj::Ptr{Int64}, iaf::Ref{Int64}, af::Ptr{Float32}, + df::Ptr{Float32}, injf::Ptr{Int64}, ik::Ptr{Int64}, + b::Ptr{Float32}, r::Ptr{Float32}, e::Ptr{Float32}, + f::Ptr{Float32}, g::Ptr{Float32}, kmax::Ref{Int64}, + eps::Ref{Float32}, lrow::Ref{Int64})::Cvoid +end + function ma61h(a, ini, inj, nz, n, b, z) @ccall libhsl.ma61h_(a::Ptr{Float32}, ini::Ptr{Cint}, inj::Ptr{Cint}, nz::Ref{Cint}, n::Ref{Cint}, b::Ptr{Float32}, z::Ptr{Float32})::Cvoid end + +function ma61h_64(a, ini, inj, nz, n, b, z) + @ccall libhsl_subset_64.ma61h_64_(a::Ptr{Float32}, ini::Ptr{Int64}, inj::Ptr{Int64}, + nz::Ref{Int64}, n::Ref{Int64}, b::Ptr{Float32}, + z::Ptr{Float32})::Cvoid +end diff --git a/src/Fortran/mc13.jl b/src/Fortran/mc13.jl index 4d96699..4685a04 100644 --- a/src/Fortran/mc13.jl +++ b/src/Fortran/mc13.jl @@ -4,20 +4,46 @@ function mc13dd(n, icn, licn, ip, lenr, ior, ib, num, iw) iw::Ptr{Cint})::Cvoid end +function mc13dd_64(n, icn, licn, ip, lenr, ior, ib, num, iw) + @ccall libhsl_subset_64.mc13dd_64_(n::Ref{Int64}, icn::Ptr{Int64}, licn::Ref{Int64}, + ip::Ptr{Int64}, lenr::Ptr{Int64}, ior::Ptr{Int64}, + ib::Ptr{Int64}, num::Ref{Int64}, iw::Ptr{Int64})::Cvoid +end + function mc13ed(n, icn, licn, ip, lenr, arp, ib, num, lowl, numb, prev) @ccall libhsl.mc13ed_(n::Ref{Cint}, icn::Ptr{Cint}, licn::Ref{Cint}, ip::Ptr{Cint}, lenr::Ptr{Cint}, arp::Ptr{Cint}, ib::Ptr{Cint}, num::Ref{Cint}, lowl::Ptr{Cint}, numb::Ptr{Cint}, prev::Ptr{Cint})::Cvoid end +function mc13ed_64(n, icn, licn, ip, lenr, arp, ib, num, lowl, numb, prev) + @ccall libhsl_subset_64.mc13ed_64_(n::Ref{Int64}, icn::Ptr{Int64}, licn::Ref{Int64}, + ip::Ptr{Int64}, lenr::Ptr{Int64}, arp::Ptr{Int64}, + ib::Ptr{Int64}, num::Ref{Int64}, lowl::Ptr{Int64}, + numb::Ptr{Int64}, prev::Ptr{Int64})::Cvoid +end + function mc13d(n, icn, licn, ip, lenr, ior, ib, num, iw) @ccall libhsl.mc13d_(n::Ref{Cint}, icn::Ptr{Cint}, licn::Ref{Cint}, ip::Ptr{Cint}, lenr::Ptr{Cint}, ior::Ptr{Cint}, ib::Ptr{Cint}, num::Ref{Cint}, iw::Ptr{Cint})::Cvoid end +function mc13d_64(n, icn, licn, ip, lenr, ior, ib, num, iw) + @ccall libhsl_subset_64.mc13d_64_(n::Ref{Int64}, icn::Ptr{Int64}, licn::Ref{Int64}, + ip::Ptr{Int64}, lenr::Ptr{Int64}, ior::Ptr{Int64}, + ib::Ptr{Int64}, num::Ref{Int64}, iw::Ptr{Int64})::Cvoid +end + function mc13e(n, icn, licn, ip, lenr, arp, ib, num, lowl, numb, prev) @ccall libhsl.mc13e_(n::Ref{Cint}, icn::Ptr{Cint}, licn::Ref{Cint}, ip::Ptr{Cint}, lenr::Ptr{Cint}, arp::Ptr{Cint}, ib::Ptr{Cint}, num::Ref{Cint}, lowl::Ptr{Cint}, numb::Ptr{Cint}, prev::Ptr{Cint})::Cvoid end + +function mc13e_64(n, icn, licn, ip, lenr, arp, ib, num, lowl, numb, prev) + @ccall libhsl_subset_64.mc13e_64_(n::Ref{Int64}, icn::Ptr{Int64}, licn::Ref{Int64}, + ip::Ptr{Int64}, lenr::Ptr{Int64}, arp::Ptr{Int64}, + ib::Ptr{Int64}, num::Ref{Int64}, lowl::Ptr{Int64}, + numb::Ptr{Int64}, prev::Ptr{Int64})::Cvoid +end diff --git a/src/Fortran/mc19.jl b/src/Fortran/mc19.jl index 3c8f6f7..5937975 100644 --- a/src/Fortran/mc19.jl +++ b/src/Fortran/mc19.jl @@ -3,7 +3,19 @@ function mc19ad(n, na, a, irn, icn, r, c, w) icn::Ptr{Cint}, r::Ptr{Float32}, c::Ptr{Float32}, w::Ptr{Float32})::Cvoid end +function mc19ad_64(n, na, a, irn, icn, r, c, w) + @ccall libhsl_subset_64.mc19ad_64_(n::Ref{Int64}, na::Ref{Int64}, a::Ptr{Float64}, + irn::Ptr{Int64}, icn::Ptr{Int64}, r::Ptr{Float32}, + c::Ptr{Float32}, w::Ptr{Float32})::Cvoid +end + function mc19a(n, na, a, irn, icn, r, c, w) @ccall libhsl.mc19a_(n::Ref{Cint}, na::Ref{Cint}, a::Ptr{Float32}, irn::Ptr{Cint}, icn::Ptr{Cint}, r::Ptr{Float32}, c::Ptr{Float32}, w::Ptr{Float32})::Cvoid end + +function mc19a_64(n, na, a, irn, icn, r, c, w) + @ccall libhsl_subset_64.mc19a_64_(n::Ref{Int64}, na::Ref{Int64}, a::Ptr{Float32}, irn::Ptr{Int64}, + icn::Ptr{Int64}, r::Ptr{Float32}, c::Ptr{Float32}, + w::Ptr{Float32})::Cvoid +end diff --git a/src/Fortran/mc20.jl b/src/Fortran/mc20.jl index 3281c74..3adc959 100644 --- a/src/Fortran/mc20.jl +++ b/src/Fortran/mc20.jl @@ -3,17 +3,39 @@ function mc20ad(nc, maxa, a, inum, jptr, jnum, jdisp) jptr::Ptr{Cint}, jnum::Ptr{Cint}, jdisp::Ref{Cint})::Cvoid end +function mc20ad_64(nc, maxa, a, inum, jptr, jnum, jdisp) + @ccall libhsl_subset_64.mc20ad_64_(nc::Ref{Int64}, maxa::Ref{Int64}, a::Ptr{Float64}, + inum::Ptr{Int64}, jptr::Ptr{Int64}, jnum::Ptr{Int64}, + jdisp::Ref{Int64})::Cvoid +end + function mc20bd(nc, maxa, a, inum, jptr) @ccall libhsl.mc20bd_(nc::Ref{Cint}, maxa::Ref{Cint}, a::Ptr{Float64}, inum::Ptr{Cint}, jptr::Ptr{Cint})::Cvoid end +function mc20bd_64(nc, maxa, a, inum, jptr) + @ccall libhsl_subset_64.mc20bd_64_(nc::Ref{Int64}, maxa::Ref{Int64}, a::Ptr{Float64}, + inum::Ptr{Int64}, jptr::Ptr{Int64})::Cvoid +end + function mc20a(nc, maxa, a, inum, jptr, jnum, jdisp) @ccall libhsl.mc20a_(nc::Ref{Cint}, maxa::Ref{Cint}, a::Ptr{Float32}, inum::Ptr{Cint}, jptr::Ptr{Cint}, jnum::Ptr{Cint}, jdisp::Ref{Cint})::Cvoid end +function mc20a_64(nc, maxa, a, inum, jptr, jnum, jdisp) + @ccall libhsl_subset_64.mc20a_64_(nc::Ref{Int64}, maxa::Ref{Int64}, a::Ptr{Float32}, + inum::Ptr{Int64}, jptr::Ptr{Int64}, jnum::Ptr{Int64}, + jdisp::Ref{Int64})::Cvoid +end + function mc20b(nc, maxa, a, inum, jptr) @ccall libhsl.mc20b_(nc::Ref{Cint}, maxa::Ref{Cint}, a::Ptr{Float32}, inum::Ptr{Cint}, jptr::Ptr{Cint})::Cvoid end + +function mc20b_64(nc, maxa, a, inum, jptr) + @ccall libhsl_subset_64.mc20b_64_(nc::Ref{Int64}, maxa::Ref{Int64}, a::Ptr{Float32}, + inum::Ptr{Int64}, jptr::Ptr{Int64})::Cvoid +end diff --git a/src/Fortran/mc21.jl b/src/Fortran/mc21.jl index 3183bc3..e7cfd38 100644 --- a/src/Fortran/mc21.jl +++ b/src/Fortran/mc21.jl @@ -3,19 +3,45 @@ function mc21ad(n, icn, licn, ip, lenr, iperm, numnz, iw) lenr::Ptr{Cint}, iperm::Ptr{Cint}, numnz::Ref{Cint}, iw::Ptr{Cint})::Cvoid end +function mc21ad_64(n, icn, licn, ip, lenr, iperm, numnz, iw) + @ccall libhsl_subset_64.mc21ad_64_(n::Ref{Int64}, icn::Ptr{Int64}, licn::Ref{Int64}, + ip::Ptr{Int64}, lenr::Ptr{Int64}, iperm::Ptr{Int64}, + numnz::Ref{Int64}, iw::Ptr{Int64})::Cvoid +end + function mc21bd(n, icn, licn, ip, lenr, iperm, numnz, pr, arp, cv, out) @ccall libhsl.mc21bd_(n::Ref{Cint}, icn::Ptr{Cint}, licn::Ref{Cint}, ip::Ptr{Cint}, lenr::Ptr{Cint}, iperm::Ptr{Cint}, numnz::Ref{Cint}, pr::Ptr{Cint}, arp::Ptr{Cint}, cv::Ptr{Cint}, out::Ptr{Cint})::Cvoid end +function mc21bd_64(n, icn, licn, ip, lenr, iperm, numnz, pr, arp, cv, out) + @ccall libhsl_subset_64.mc21bd_64_(n::Ref{Int64}, icn::Ptr{Int64}, licn::Ref{Int64}, + ip::Ptr{Int64}, lenr::Ptr{Int64}, iperm::Ptr{Int64}, + numnz::Ref{Int64}, pr::Ptr{Int64}, arp::Ptr{Int64}, + cv::Ptr{Int64}, out::Ptr{Int64})::Cvoid +end + function mc21a(n, icn, licn, ip, lenr, iperm, numnz, iw) @ccall libhsl.mc21a_(n::Ref{Cint}, icn::Ptr{Cint}, licn::Ref{Cint}, ip::Ptr{Cint}, lenr::Ptr{Cint}, iperm::Ptr{Cint}, numnz::Ref{Cint}, iw::Ptr{Cint})::Cvoid end +function mc21a_64(n, icn, licn, ip, lenr, iperm, numnz, iw) + @ccall libhsl_subset_64.mc21a_64_(n::Ref{Int64}, icn::Ptr{Int64}, licn::Ref{Int64}, + ip::Ptr{Int64}, lenr::Ptr{Int64}, iperm::Ptr{Int64}, + numnz::Ref{Int64}, iw::Ptr{Int64})::Cvoid +end + function mc21b(n, icn, licn, ip, lenr, iperm, numnz, pr, arp, cv, out) @ccall libhsl.mc21b_(n::Ref{Cint}, icn::Ptr{Cint}, licn::Ref{Cint}, ip::Ptr{Cint}, lenr::Ptr{Cint}, iperm::Ptr{Cint}, numnz::Ref{Cint}, pr::Ptr{Cint}, arp::Ptr{Cint}, cv::Ptr{Cint}, out::Ptr{Cint})::Cvoid end + +function mc21b_64(n, icn, licn, ip, lenr, iperm, numnz, pr, arp, cv, out) + @ccall libhsl_subset_64.mc21b_64_(n::Ref{Int64}, icn::Ptr{Int64}, licn::Ref{Int64}, + ip::Ptr{Int64}, lenr::Ptr{Int64}, iperm::Ptr{Int64}, + numnz::Ref{Int64}, pr::Ptr{Int64}, arp::Ptr{Int64}, + cv::Ptr{Int64}, out::Ptr{Int64})::Cvoid +end diff --git a/src/Fortran/mc22.jl b/src/Fortran/mc22.jl index 4157885..141ebdf 100644 --- a/src/Fortran/mc22.jl +++ b/src/Fortran/mc22.jl @@ -10,12 +10,24 @@ function mc22ad(n, icn, a, nz, lenrow, ip, iq, iw, iw1) iw1::Ptr{Cint})::Cvoid end +function mc22ad_64(n, icn, a, nz, lenrow, ip, iq, iw, iw1) + @ccall libhsl_subset_64.mc22ad_64_(n::Ref{Int64}, icn::Ptr{Int64}, a::Ptr{Float64}, + nz::Ref{Int64}, lenrow::Ptr{Int64}, ip::Ptr{Int64}, + iq::Ptr{Int64}, iw::Ptr{Int64}, iw1::Ptr{Int64})::Cvoid +end + function mc22a(n, icn, a, nz, lenrow, ip, iq, iw, iw1) @ccall libhsl.mc22a_(n::Ref{Cint}, icn::Ptr{Cint}, a::Ptr{Float32}, nz::Ref{Cint}, lenrow::Ptr{Cint}, ip::Ptr{Cint}, iq::Ptr{Cint}, iw::Ptr{Cint}, iw1::Ptr{Cint})::Cvoid end +function mc22a_64(n, icn, a, nz, lenrow, ip, iq, iw, iw1) + @ccall libhsl_subset_64.mc22a_64_(n::Ref{Int64}, icn::Ptr{Int64}, a::Ptr{Float32}, nz::Ref{Int64}, + lenrow::Ptr{Int64}, ip::Ptr{Int64}, iq::Ptr{Int64}, + iw::Ptr{Int64}, iw1::Ptr{Int64})::Cvoid +end + function mc22az(n, icn, a, nz, lenrow, ip, iq, iw, iw1) @ccall libhsl.mc22az_(n::Ref{Cint}, icn::Ptr{Cint}, a::Ptr{ComplexF64}, nz::Ref{Cint}, lenrow::Ptr{Cint}, ip::Ptr{Cint}, iq::Ptr{Cint}, iw::Ptr{Cint}, diff --git a/src/Fortran/mc23.jl b/src/Fortran/mc23.jl index a49b707..889633f 100644 --- a/src/Fortran/mc23.jl +++ b/src/Fortran/mc23.jl @@ -4,8 +4,22 @@ function mc23ad(n, icn, a, licn, lenr, idisp, ip, iq, lenoff, iw, iw1) lenoff::Ptr{Cint}, iw::Ptr{Cint}, iw1::Ptr{Cint})::Cvoid end +function mc23ad_64(n, icn, a, licn, lenr, idisp, ip, iq, lenoff, iw, iw1) + @ccall libhsl_subset_64.mc23ad_64_(n::Ref{Int64}, icn::Ptr{Int64}, a::Ptr{Float64}, + licn::Ref{Int64}, lenr::Ptr{Int64}, idisp::Ptr{Int64}, + ip::Ptr{Int64}, iq::Ptr{Int64}, lenoff::Ptr{Int64}, + iw::Ptr{Int64}, iw1::Ptr{Int64})::Cvoid +end + function mc23a(n, icn, a, licn, lenr, idisp, ip, iq, lenoff, iw, iw1) @ccall libhsl.mc23a_(n::Ref{Cint}, icn::Ptr{Cint}, a::Ptr{Float32}, licn::Ref{Cint}, lenr::Ptr{Cint}, idisp::Ptr{Cint}, ip::Ptr{Cint}, iq::Ptr{Cint}, lenoff::Ptr{Cint}, iw::Ptr{Cint}, iw1::Ptr{Cint})::Cvoid end + +function mc23a_64(n, icn, a, licn, lenr, idisp, ip, iq, lenoff, iw, iw1) + @ccall libhsl_subset_64.mc23a_64_(n::Ref{Int64}, icn::Ptr{Int64}, a::Ptr{Float32}, + licn::Ref{Int64}, lenr::Ptr{Int64}, idisp::Ptr{Int64}, + ip::Ptr{Int64}, iq::Ptr{Int64}, lenoff::Ptr{Int64}, + iw::Ptr{Int64}, iw1::Ptr{Int64})::Cvoid +end diff --git a/src/Fortran/mc24.jl b/src/Fortran/mc24.jl index 66ccfac..25290f8 100644 --- a/src/Fortran/mc24.jl +++ b/src/Fortran/mc24.jl @@ -3,7 +3,19 @@ function mc24ad(n, icn, a, licn, lenr, lenrl, w) lenr::Ptr{Cint}, lenrl::Ptr{Cint}, w::Ptr{Float64})::Cvoid end +function mc24ad_64(n, icn, a, licn, lenr, lenrl, w) + @ccall libhsl_subset_64.mc24ad_64_(n::Ref{Int64}, icn::Ptr{Int64}, a::Ptr{Float64}, + licn::Ref{Int64}, lenr::Ptr{Int64}, lenrl::Ptr{Int64}, + w::Ptr{Float64})::Cvoid +end + function mc24a(n, icn, a, licn, lenr, lenrl, w) @ccall libhsl.mc24a_(n::Ref{Cint}, icn::Ptr{Cint}, a::Ptr{Float32}, licn::Ref{Cint}, lenr::Ptr{Cint}, lenrl::Ptr{Cint}, w::Ptr{Float32})::Cvoid end + +function mc24a_64(n, icn, a, licn, lenr, lenrl, w) + @ccall libhsl_subset_64.mc24a_64_(n::Ref{Int64}, icn::Ptr{Int64}, a::Ptr{Float32}, + licn::Ref{Int64}, lenr::Ptr{Int64}, lenrl::Ptr{Int64}, + w::Ptr{Float32})::Cvoid +end diff --git a/src/Fortran/mc29.jl b/src/Fortran/mc29.jl index cba0bd7..b79afeb 100644 --- a/src/Fortran/mc29.jl +++ b/src/Fortran/mc29.jl @@ -4,8 +4,22 @@ function mc29ad(m, n, ne, a, irn, icn, r, c, w, lp, ifail) lp::Ref{Cint}, ifail::Ref{Cint})::Cvoid end +function mc29ad_64(m, n, ne, a, irn, icn, r, c, w, lp, ifail) + @ccall libhsl_subset_64.mc29ad_64_(m::Ref{Int64}, n::Ref{Int64}, ne::Ref{Int64}, a::Ptr{Float64}, + irn::Ptr{Int64}, icn::Ptr{Int64}, r::Ptr{Float64}, + c::Ptr{Float64}, w::Ptr{Float64}, lp::Ref{Int64}, + ifail::Ref{Int64})::Cvoid +end + function mc29a(m, n, ne, a, irn, icn, r, c, w, lp, ifail) @ccall libhsl.mc29a_(m::Ref{Cint}, n::Ref{Cint}, ne::Ref{Cint}, a::Ptr{Float32}, irn::Ptr{Cint}, icn::Ptr{Cint}, r::Ptr{Float32}, c::Ptr{Float32}, w::Ptr{Float32}, lp::Ref{Cint}, ifail::Ref{Cint})::Cvoid end + +function mc29a_64(m, n, ne, a, irn, icn, r, c, w, lp, ifail) + @ccall libhsl_subset_64.mc29a_64_(m::Ref{Int64}, n::Ref{Int64}, ne::Ref{Int64}, a::Ptr{Float32}, + irn::Ptr{Int64}, icn::Ptr{Int64}, r::Ptr{Float32}, + c::Ptr{Float32}, w::Ptr{Float32}, lp::Ref{Int64}, + ifail::Ref{Int64})::Cvoid +end diff --git a/src/Fortran/mc30.jl b/src/Fortran/mc30.jl index 820b9e2..ded5cc6 100644 --- a/src/Fortran/mc30.jl +++ b/src/Fortran/mc30.jl @@ -4,7 +4,19 @@ function mc30ad(n, ne, a, irn, icn, s, w, lp, ifail) ifail::Ref{Cint})::Cvoid end +function mc30ad_64(n, ne, a, irn, icn, s, w, lp, ifail) + @ccall libhsl_subset_64.mc30ad_64_(n::Ref{Int64}, ne::Ref{Int64}, a::Ptr{Float64}, + irn::Ptr{Int64}, icn::Ptr{Int64}, s::Ptr{Float64}, + w::Ptr{Float64}, lp::Ref{Int64}, ifail::Ref{Int64})::Cvoid +end + function mc30a(n, ne, a, irn, icn, s, w, lp, ifail) @ccall libhsl.mc30a_(n::Ref{Cint}, ne::Ref{Cint}, a::Ptr{Float32}, irn::Ptr{Cint}, icn::Ptr{Cint}, s::Ptr{Float32}, w::Ptr{Float32}, lp::Ref{Cint}, ifail::Ref{Cint})::Cvoid end + +function mc30a_64(n, ne, a, irn, icn, s, w, lp, ifail) + @ccall libhsl_subset_64.mc30a_64_(n::Ref{Int64}, ne::Ref{Int64}, a::Ptr{Float32}, irn::Ptr{Int64}, + icn::Ptr{Int64}, s::Ptr{Float32}, w::Ptr{Float32}, + lp::Ref{Int64}, ifail::Ref{Int64})::Cvoid +end diff --git a/src/Fortran/mc34.jl b/src/Fortran/mc34.jl index dd9ef41..c25ff26 100644 --- a/src/Fortran/mc34.jl +++ b/src/Fortran/mc34.jl @@ -3,7 +3,17 @@ function mc34ad(n, irn, jcolst, yesa, a, iw) a::Ptr{Float64}, iw::Ptr{Cint})::Cvoid end +function mc34ad_64(n, irn, jcolst, yesa, a, iw) + @ccall libhsl_subset_64.mc34ad_64_(n::Ref{Int64}, irn::Ptr{Int64}, jcolst::Ptr{Int64}, + yesa::Ref{Int64}, a::Ptr{Float64}, iw::Ptr{Int64})::Cvoid +end + function mc34a(n, irn, jcolst, yesa, a, iw) @ccall libhsl.mc34a_(n::Ref{Cint}, irn::Ptr{Cint}, jcolst::Ptr{Cint}, yesa::Ref{Cint}, a::Ptr{Float32}, iw::Ptr{Cint})::Cvoid end + +function mc34a_64(n, irn, jcolst, yesa, a, iw) + @ccall libhsl_subset_64.mc34a_64_(n::Ref{Int64}, irn::Ptr{Int64}, jcolst::Ptr{Int64}, + yesa::Ref{Int64}, a::Ptr{Float32}, iw::Ptr{Int64})::Cvoid +end diff --git a/src/Fortran/mc37.jl b/src/Fortran/mc37.jl index 27e10fb..694ed64 100644 --- a/src/Fortran/mc37.jl +++ b/src/Fortran/mc37.jl @@ -5,6 +5,15 @@ function mc37ad(n, ne, irn, jcn, a, ip, lielt, numelt, ptrelt, ielt, laelt, aelt iw::Ptr{Cint}, icntl::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function mc37ad_64(n, ne, irn, jcn, a, ip, lielt, numelt, ptrelt, ielt, laelt, aelt, iw, icntl, + info) + @ccall libhsl_subset_64.mc37ad_64_(n::Ref{Int64}, ne::Ref{Int64}, irn::Ptr{Int64}, + jcn::Ptr{Int64}, a::Ptr{Float64}, ip::Ptr{Int64}, + lielt::Ref{Int64}, numelt::Ref{Int64}, ptrelt::Ptr{Int64}, + ielt::Ptr{Int64}, laelt::Ref{Int64}, aelt::Ptr{Float64}, + iw::Ptr{Int64}, icntl::Ptr{Int64}, info::Ptr{Int64})::Cvoid +end + function mc37bd(n, ne, a, irn, jcn, ip, numelt, ptrelt, ielt, lielt, aelt, laelt) @ccall libhsl.mc37bd_(n::Ref{Cint}, ne::Ref{Cint}, a::Ptr{Float64}, irn::Ptr{Cint}, jcn::Ptr{Cint}, ip::Ptr{Cint}, numelt::Ref{Cint}, ptrelt::Ptr{Cint}, @@ -12,6 +21,14 @@ function mc37bd(n, ne, a, irn, jcn, ip, numelt, ptrelt, ielt, lielt, aelt, laelt laelt::Ref{Cint})::Cvoid end +function mc37bd_64(n, ne, a, irn, jcn, ip, numelt, ptrelt, ielt, lielt, aelt, laelt) + @ccall libhsl_subset_64.mc37bd_64_(n::Ref{Int64}, ne::Ref{Int64}, a::Ptr{Float64}, + irn::Ptr{Int64}, jcn::Ptr{Int64}, ip::Ptr{Int64}, + numelt::Ref{Int64}, ptrelt::Ptr{Int64}, ielt::Ptr{Int64}, + lielt::Ref{Int64}, aelt::Ptr{Float64}, + laelt::Ref{Int64})::Cvoid +end + function mc37a(n, ne, irn, jcn, a, ip, lielt, numelt, ptrelt, ielt, laelt, aelt, iw, icntl, info) @ccall libhsl.mc37a_(n::Ref{Cint}, ne::Ref{Cint}, irn::Ptr{Cint}, jcn::Ptr{Cint}, a::Ptr{Float32}, ip::Ptr{Cint}, lielt::Ref{Cint}, numelt::Ref{Cint}, ptrelt::Ptr{Cint}, @@ -19,8 +36,23 @@ function mc37a(n, ne, irn, jcn, a, ip, lielt, numelt, ptrelt, ielt, laelt, aelt, icntl::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function mc37a_64(n, ne, irn, jcn, a, ip, lielt, numelt, ptrelt, ielt, laelt, aelt, iw, icntl, info) + @ccall libhsl_subset_64.mc37a_64_(n::Ref{Int64}, ne::Ref{Int64}, irn::Ptr{Int64}, jcn::Ptr{Int64}, + a::Ptr{Float32}, ip::Ptr{Int64}, lielt::Ref{Int64}, + numelt::Ref{Int64}, ptrelt::Ptr{Int64}, ielt::Ptr{Int64}, + laelt::Ref{Int64}, aelt::Ptr{Float32}, iw::Ptr{Int64}, + icntl::Ptr{Int64}, info::Ptr{Int64})::Cvoid +end + function mc37b(n, ne, a, irn, jcn, ip, numelt, ptrelt, ielt, lielt, aelt, laelt) @ccall libhsl.mc37b_(n::Ref{Cint}, ne::Ref{Cint}, a::Ptr{Float32}, irn::Ptr{Cint}, jcn::Ptr{Cint}, ip::Ptr{Cint}, numelt::Ref{Cint}, ptrelt::Ptr{Cint}, ielt::Ptr{Cint}, lielt::Ref{Cint}, aelt::Ptr{Float32}, laelt::Ref{Cint})::Cvoid end + +function mc37b_64(n, ne, a, irn, jcn, ip, numelt, ptrelt, ielt, lielt, aelt, laelt) + @ccall libhsl_subset_64.mc37b_64_(n::Ref{Int64}, ne::Ref{Int64}, a::Ptr{Float32}, irn::Ptr{Int64}, + jcn::Ptr{Int64}, ip::Ptr{Int64}, numelt::Ref{Int64}, + ptrelt::Ptr{Int64}, ielt::Ptr{Int64}, lielt::Ref{Int64}, + aelt::Ptr{Float32}, laelt::Ref{Int64})::Cvoid +end diff --git a/src/Fortran/mc47.jl b/src/Fortran/mc47.jl index c33453c..7f1b048 100644 --- a/src/Fortran/mc47.jl +++ b/src/Fortran/mc47.jl @@ -2,11 +2,21 @@ function mc47id(icntl) @ccall libhsl.mc47id_(icntl::Ptr{Cint})::Cvoid end +function mc47id_64(icntl) + @ccall libhsl_subset_64.mc47id_64_(icntl::Ptr{Int64})::Cvoid +end + function mc47ad(n, ne, pe, iw, iwlen, icntl, info, rinfo) @ccall libhsl.mc47ad_(n::Ref{Cint}, ne::Ref{Cint}, pe::Ptr{Cint}, iw::Ptr{Cint}, iwlen::Ref{Cint}, icntl::Ptr{Cint}, info::Ptr{Cint}, rinfo::Ptr{Float64})::Cvoid end +function mc47ad_64(n, ne, pe, iw, iwlen, icntl, info, rinfo) + @ccall libhsl_subset_64.mc47ad_64_(n::Ref{Int64}, ne::Ref{Int64}, pe::Ptr{Int64}, iw::Ptr{Int64}, + iwlen::Ref{Int64}, icntl::Ptr{Int64}, info::Ptr{Int64}, + rinfo::Ptr{Float64})::Cvoid +end + function mc47bd(n, iwlen, pe, pfree, len, iw, nv, elen, last, degree, head, denxt, w, icntl, jnfo, rjnfo) @ccall libhsl.mc47bd_(n::Ref{Cint}, iwlen::Ref{Cint}, pe::Ptr{Cint}, pfree::Ref{Cint}, @@ -15,15 +25,35 @@ function mc47bd(n, iwlen, pe, pfree, len, iw, nv, elen, last, degree, head, denx w::Ptr{Cint}, icntl::Ptr{Cint}, jnfo::Ptr{Cint}, rjnfo::Ptr{Float64})::Cvoid end +function mc47bd_64(n, iwlen, pe, pfree, len, iw, nv, elen, last, degree, head, denxt, w, icntl, + jnfo, rjnfo) + @ccall libhsl_subset_64.mc47bd_64_(n::Ref{Int64}, iwlen::Ref{Int64}, pe::Ptr{Int64}, + pfree::Ref{Int64}, len::Ptr{Int64}, iw::Ptr{Int64}, + nv::Ptr{Int64}, elen::Ptr{Int64}, last::Ptr{Int64}, + degree::Ptr{Int64}, head::Ptr{Int64}, denxt::Ptr{Int64}, + w::Ptr{Int64}, icntl::Ptr{Int64}, jnfo::Ptr{Int64}, + rjnfo::Ptr{Float64})::Cvoid +end + function mc47i(icntl) @ccall libhsl.mc47i_(icntl::Ptr{Cint})::Cvoid end +function mc47i_64(icntl) + @ccall libhsl_subset_64.mc47i_64_(icntl::Ptr{Int64})::Cvoid +end + function mc47a(n, ne, pe, iw, iwlen, icntl, info, rinfo) @ccall libhsl.mc47a_(n::Ref{Cint}, ne::Ref{Cint}, pe::Ptr{Cint}, iw::Ptr{Cint}, iwlen::Ref{Cint}, icntl::Ptr{Cint}, info::Ptr{Cint}, rinfo::Ptr{Float32})::Cvoid end +function mc47a_64(n, ne, pe, iw, iwlen, icntl, info, rinfo) + @ccall libhsl_subset_64.mc47a_64_(n::Ref{Int64}, ne::Ref{Int64}, pe::Ptr{Int64}, iw::Ptr{Int64}, + iwlen::Ref{Int64}, icntl::Ptr{Int64}, info::Ptr{Int64}, + rinfo::Ptr{Float32})::Cvoid +end + function mc47b(n, iwlen, pe, pfree, len, iw, nv, elen, last, degree, head, denxt, w, icntl, jnfo, rjnfo) @ccall libhsl.mc47b_(n::Ref{Cint}, iwlen::Ref{Cint}, pe::Ptr{Cint}, pfree::Ref{Cint}, @@ -31,3 +61,13 @@ function mc47b(n, iwlen, pe, pfree, len, iw, nv, elen, last, degree, head, denxt last::Ptr{Cint}, degree::Ptr{Cint}, head::Ptr{Cint}, denxt::Ptr{Cint}, w::Ptr{Cint}, icntl::Ptr{Cint}, jnfo::Ptr{Cint}, rjnfo::Ptr{Float32})::Cvoid end + +function mc47b_64(n, iwlen, pe, pfree, len, iw, nv, elen, last, degree, head, denxt, w, icntl, jnfo, + rjnfo) + @ccall libhsl_subset_64.mc47b_64_(n::Ref{Int64}, iwlen::Ref{Int64}, pe::Ptr{Int64}, + pfree::Ref{Int64}, len::Ptr{Int64}, iw::Ptr{Int64}, + nv::Ptr{Int64}, elen::Ptr{Int64}, last::Ptr{Int64}, + degree::Ptr{Int64}, head::Ptr{Int64}, denxt::Ptr{Int64}, + w::Ptr{Int64}, icntl::Ptr{Int64}, jnfo::Ptr{Int64}, + rjnfo::Ptr{Float32})::Cvoid +end diff --git a/src/Fortran/mc49.jl b/src/Fortran/mc49.jl index 834ae84..7c29297 100644 --- a/src/Fortran/mc49.jl +++ b/src/Fortran/mc49.jl @@ -5,18 +5,39 @@ function mc49ad(ind, nc, nr, nnz, irn, jcn, yesa, la, a, lip, ip, liw, iw, iflag iw::Ptr{Cint}, iflag::Ref{Cint})::Cvoid end +function mc49ad_64(ind, nc, nr, nnz, irn, jcn, yesa, la, a, lip, ip, liw, iw, iflag) + @ccall libhsl_subset_64.mc49ad_64_(ind::Ref{Int64}, nc::Ref{Int64}, nr::Ref{Int64}, + nnz::Ref{Int64}, irn::Ptr{Int64}, jcn::Ptr{Int64}, + yesa::Ref{Int64}, la::Ref{Int64}, a::Ptr{Float64}, + lip::Ref{Int64}, ip::Ptr{Int64}, liw::Ref{Int64}, + iw::Ptr{Int64}, iflag::Ref{Int64})::Cvoid +end + function mc49bd(nc, nnz, irn, jcn, yesa, la, a, ip, iw) @ccall libhsl.mc49bd_(nc::Ref{Cint}, nnz::Ref{Cint}, irn::Ptr{Cint}, jcn::Ptr{Cint}, yesa::Ref{Cint}, la::Ref{Cint}, a::Ptr{Float64}, ip::Ptr{Cint}, iw::Ptr{Cint})::Cvoid end +function mc49bd_64(nc, nnz, irn, jcn, yesa, la, a, ip, iw) + @ccall libhsl_subset_64.mc49bd_64_(nc::Ref{Int64}, nnz::Ref{Int64}, irn::Ptr{Int64}, + jcn::Ptr{Int64}, yesa::Ref{Int64}, la::Ref{Int64}, + a::Ptr{Float64}, ip::Ptr{Int64}, iw::Ptr{Int64})::Cvoid +end + function mc49cd(nc, nr, nnz, irn, jcn, yesa, la, a, ip, iw) @ccall libhsl.mc49cd_(nc::Ref{Cint}, nr::Ref{Cint}, nnz::Ref{Cint}, irn::Ptr{Cint}, jcn::Ptr{Cint}, yesa::Ref{Cint}, la::Ref{Cint}, a::Ptr{Float64}, ip::Ptr{Cint}, iw::Ptr{Cint})::Cvoid end +function mc49cd_64(nc, nr, nnz, irn, jcn, yesa, la, a, ip, iw) + @ccall libhsl_subset_64.mc49cd_64_(nc::Ref{Int64}, nr::Ref{Int64}, nnz::Ref{Int64}, + irn::Ptr{Int64}, jcn::Ptr{Int64}, yesa::Ref{Int64}, + la::Ref{Int64}, a::Ptr{Float64}, ip::Ptr{Int64}, + iw::Ptr{Int64})::Cvoid +end + function mc49ai(ind, nc, nr, nnz, irn, jcn, yesa, la, a, lip, ip, liw, iw, iflag) @ccall libhsl.mc49ai_(ind::Ref{Cint}, nc::Ref{Cint}, nr::Ref{Cint}, nnz::Ref{Cint}, irn::Ptr{Cint}, jcn::Ptr{Cint}, yesa::Ref{Cint}, la::Ref{Cint}, @@ -43,14 +64,35 @@ function mc49a(ind, nc, nr, nnz, irn, jcn, yesa, la, a, lip, ip, liw, iw, iflag) iflag::Ref{Cint})::Cvoid end +function mc49a_64(ind, nc, nr, nnz, irn, jcn, yesa, la, a, lip, ip, liw, iw, iflag) + @ccall libhsl_subset_64.mc49a_64_(ind::Ref{Int64}, nc::Ref{Int64}, nr::Ref{Int64}, + nnz::Ref{Int64}, irn::Ptr{Int64}, jcn::Ptr{Int64}, + yesa::Ref{Int64}, la::Ref{Int64}, a::Ptr{Float32}, + lip::Ref{Int64}, ip::Ptr{Int64}, liw::Ref{Int64}, + iw::Ptr{Int64}, iflag::Ref{Int64})::Cvoid +end + function mc49b(nc, nnz, irn, jcn, yesa, la, a, ip, iw) @ccall libhsl.mc49b_(nc::Ref{Cint}, nnz::Ref{Cint}, irn::Ptr{Cint}, jcn::Ptr{Cint}, yesa::Ref{Cint}, la::Ref{Cint}, a::Ptr{Float32}, ip::Ptr{Cint}, iw::Ptr{Cint})::Cvoid end +function mc49b_64(nc, nnz, irn, jcn, yesa, la, a, ip, iw) + @ccall libhsl_subset_64.mc49b_64_(nc::Ref{Int64}, nnz::Ref{Int64}, irn::Ptr{Int64}, + jcn::Ptr{Int64}, yesa::Ref{Int64}, la::Ref{Int64}, + a::Ptr{Float32}, ip::Ptr{Int64}, iw::Ptr{Int64})::Cvoid +end + function mc49c(nc, nr, nnz, irn, jcn, yesa, la, a, ip, iw) @ccall libhsl.mc49c_(nc::Ref{Cint}, nr::Ref{Cint}, nnz::Ref{Cint}, irn::Ptr{Cint}, jcn::Ptr{Cint}, yesa::Ref{Cint}, la::Ref{Cint}, a::Ptr{Float32}, ip::Ptr{Cint}, iw::Ptr{Cint})::Cvoid end + +function mc49c_64(nc, nr, nnz, irn, jcn, yesa, la, a, ip, iw) + @ccall libhsl_subset_64.mc49c_64_(nc::Ref{Int64}, nr::Ref{Int64}, nnz::Ref{Int64}, + irn::Ptr{Int64}, jcn::Ptr{Int64}, yesa::Ref{Int64}, + la::Ref{Int64}, a::Ptr{Float32}, ip::Ptr{Int64}, + iw::Ptr{Int64})::Cvoid +end diff --git a/src/Fortran/mc54.jl b/src/Fortran/mc54.jl index 9b05313..e762279 100644 --- a/src/Fortran/mc54.jl +++ b/src/Fortran/mc54.jl @@ -31,25 +31,52 @@ function mc54ad(icntl, title, key, m, n, ne, ip, ind, value, iw, info) 8::Csize_t)::Cvoid end +function mc54ad_64(icntl, title, key, m, n, ne, ip, ind, value, iw, info) + @ccall libhsl_subset_64.mc54ad_64_(icntl::Ptr{Int64}, title::Ptr{UInt8}, key::Ptr{UInt8}, + m::Ref{Int64}, n::Ref{Int64}, ne::Ref{Int64}, ip::Ptr{Int64}, + ind::Ptr{Int64}, value::Ptr{Float64}, iw::Ptr{Int64}, + info::Ptr{Int64}, 72::Csize_t, 8::Csize_t)::Cvoid +end + function mc54bd(n, ind, fmtind, lunit) @ccall libhsl.mc54bd_(n::Ref{Cint}, ind::Ptr{Cint}, fmtind::Ptr{UInt8}, lunit::Ref{Cint}, 16::Csize_t)::Cvoid end +function mc54bd_64(n, ind, fmtind, lunit) + @ccall libhsl_subset_64.mc54bd_64_(n::Ref{Int64}, ind::Ptr{Int64}, fmtind::Ptr{UInt8}, + lunit::Ref{Int64}, 16::Csize_t)::Cvoid +end + function mc54cd(n, a, fmta, lunit) @ccall libhsl.mc54cd_(n::Ref{Cint}, a::Ptr{Float64}, fmta::Ptr{UInt8}, lunit::Ref{Cint}, 20::Csize_t)::Cvoid end +function mc54cd_64(n, a, fmta, lunit) + @ccall libhsl_subset_64.mc54cd_64_(n::Ref{Int64}, a::Ptr{Float64}, fmta::Ptr{UInt8}, + lunit::Ref{Int64}, 20::Csize_t)::Cvoid +end + function mc54dd(n, nlin, fmt) @ccall libhsl.mc54dd_(n::Ref{Cint}, nlin::Ref{Cint}, fmt::Ptr{UInt8}, 16::Csize_t)::Cvoid end +function mc54dd_64(n, nlin, fmt) + @ccall libhsl_subset_64.mc54dd_64_(n::Ref{Int64}, nlin::Ref{Int64}, fmt::Ptr{UInt8}, + 16::Csize_t)::Cvoid +end + function mc54ed(dec, valfmi, valfmo, valcrd) @ccall libhsl.mc54ed_(dec::Ref{Cint}, valfmi::Ptr{UInt8}, valfmo::Ptr{UInt8}, valcrd::Ref{Cint}, 20::Csize_t, 20::Csize_t)::Cvoid end +function mc54ed_64(dec, valfmi, valfmo, valcrd) + @ccall libhsl_subset_64.mc54ed_64_(dec::Ref{Int64}, valfmi::Ptr{UInt8}, valfmo::Ptr{UInt8}, + valcrd::Ref{Int64}, 20::Csize_t, 20::Csize_t)::Cvoid +end + function mc54ai(icntl, title, key, m, n, ne, ip, ind, value, iw, info) @ccall libhsl.mc54ai_(icntl::Ptr{Cint}, title::Ptr{UInt8}, key::Ptr{UInt8}, m::Ref{Cint}, n::Ref{Cint}, ne::Ref{Cint}, ip::Ptr{Cint}, ind::Ptr{Cint}, @@ -83,25 +110,52 @@ function mc54a(icntl, title, key, m, n, ne, ip, ind, value, iw, info) 8::Csize_t)::Cvoid end +function mc54a_64(icntl, title, key, m, n, ne, ip, ind, value, iw, info) + @ccall libhsl_subset_64.mc54a_64_(icntl::Ptr{Int64}, title::Ptr{UInt8}, key::Ptr{UInt8}, + m::Ref{Int64}, n::Ref{Int64}, ne::Ref{Int64}, ip::Ptr{Int64}, + ind::Ptr{Int64}, value::Ptr{Float32}, iw::Ptr{Int64}, + info::Ptr{Int64}, 72::Csize_t, 8::Csize_t)::Cvoid +end + function mc54b(n, ind, fmtind, lunit) @ccall libhsl.mc54b_(n::Ref{Cint}, ind::Ptr{Cint}, fmtind::Ptr{UInt8}, lunit::Ref{Cint}, 16::Csize_t)::Cvoid end +function mc54b_64(n, ind, fmtind, lunit) + @ccall libhsl_subset_64.mc54b_64_(n::Ref{Int64}, ind::Ptr{Int64}, fmtind::Ptr{UInt8}, + lunit::Ref{Int64}, 16::Csize_t)::Cvoid +end + function mc54c(n, a, fmta, lunit) @ccall libhsl.mc54c_(n::Ref{Cint}, a::Ptr{Float32}, fmta::Ptr{UInt8}, lunit::Ref{Cint}, 20::Csize_t)::Cvoid end +function mc54c_64(n, a, fmta, lunit) + @ccall libhsl_subset_64.mc54c_64_(n::Ref{Int64}, a::Ptr{Float32}, fmta::Ptr{UInt8}, + lunit::Ref{Int64}, 20::Csize_t)::Cvoid +end + function mc54d(n, nlin, fmt) @ccall libhsl.mc54d_(n::Ref{Cint}, nlin::Ref{Cint}, fmt::Ptr{UInt8}, 16::Csize_t)::Cvoid end +function mc54d_64(n, nlin, fmt) + @ccall libhsl_subset_64.mc54d_64_(n::Ref{Int64}, nlin::Ref{Int64}, fmt::Ptr{UInt8}, + 16::Csize_t)::Cvoid +end + function mc54e(dec, valfmi, valfmo, valcrd) @ccall libhsl.mc54e_(dec::Ref{Cint}, valfmi::Ptr{UInt8}, valfmo::Ptr{UInt8}, valcrd::Ref{Cint}, 20::Csize_t, 20::Csize_t)::Cvoid end +function mc54e_64(dec, valfmi, valfmo, valcrd) + @ccall libhsl_subset_64.mc54e_64_(dec::Ref{Int64}, valfmi::Ptr{UInt8}, valfmo::Ptr{UInt8}, + valcrd::Ref{Int64}, 20::Csize_t, 20::Csize_t)::Cvoid +end + function mc54az(icntl, title, key, m, n, ne, ip, ind, value, iw, info) @ccall libhsl.mc54az_(icntl::Ptr{Cint}, title::Ptr{UInt8}, key::Ptr{UInt8}, m::Ref{Cint}, n::Ref{Cint}, ne::Ref{Cint}, ip::Ptr{Cint}, ind::Ptr{Cint}, diff --git a/src/Fortran/mc57.jl b/src/Fortran/mc57.jl index f48216f..42b26fd 100644 --- a/src/Fortran/mc57.jl +++ b/src/Fortran/mc57.jl @@ -5,11 +5,25 @@ function mc57ad(lcntl, nmax, nelt, eltvar, eltptr, aelt, n, lirn, irn, ip, la, a iw::Ptr{Cint}, lp::Ref{Cint}, info::Ptr{Cint})::Cvoid end +function mc57ad_64(lcntl, nmax, nelt, eltvar, eltptr, aelt, n, lirn, irn, ip, la, a, iw, lp, info) + @ccall libhsl_subset_64.mc57ad_64_(lcntl::Ptr{Int64}, nmax::Ref{Int64}, nelt::Ref{Int64}, + eltvar::Ptr{Int64}, eltptr::Ptr{Int64}, aelt::Ptr{Float64}, + n::Ref{Int64}, lirn::Ref{Int64}, irn::Ptr{Int64}, + ip::Ptr{Int64}, la::Ref{Int64}, a::Ptr{Float64}, + iw::Ptr{Int64}, lp::Ref{Int64}, info::Ptr{Int64})::Cvoid +end + function mc57bd(n, yesa, la, a, nz, irn, ip) @ccall libhsl.mc57bd_(n::Ref{Cint}, yesa::Ref{Cint}, la::Ref{Cint}, a::Ptr{Float64}, nz::Ref{Cint}, irn::Ptr{Cint}, ip::Ptr{Cint})::Cvoid end +function mc57bd_64(n, yesa, la, a, nz, irn, ip) + @ccall libhsl_subset_64.mc57bd_64_(n::Ref{Int64}, yesa::Ref{Int64}, la::Ref{Int64}, + a::Ptr{Float64}, nz::Ref{Int64}, irn::Ptr{Int64}, + ip::Ptr{Int64})::Cvoid +end + function mc57a(lcntl, nmax, nelt, eltvar, eltptr, aelt, n, lirn, irn, ip, la, a, iw, lp, info) @ccall libhsl.mc57a_(lcntl::Ptr{Cint}, nmax::Ref{Cint}, nelt::Ref{Cint}, eltvar::Ptr{Cint}, eltptr::Ptr{Cint}, aelt::Ptr{Float32}, n::Ref{Cint}, lirn::Ref{Cint}, @@ -17,7 +31,21 @@ function mc57a(lcntl, nmax, nelt, eltvar, eltptr, aelt, n, lirn, irn, ip, la, a, lp::Ref{Cint}, info::Ptr{Cint})::Cvoid end +function mc57a_64(lcntl, nmax, nelt, eltvar, eltptr, aelt, n, lirn, irn, ip, la, a, iw, lp, info) + @ccall libhsl_subset_64.mc57a_64_(lcntl::Ptr{Int64}, nmax::Ref{Int64}, nelt::Ref{Int64}, + eltvar::Ptr{Int64}, eltptr::Ptr{Int64}, aelt::Ptr{Float32}, + n::Ref{Int64}, lirn::Ref{Int64}, irn::Ptr{Int64}, + ip::Ptr{Int64}, la::Ref{Int64}, a::Ptr{Float32}, iw::Ptr{Int64}, + lp::Ref{Int64}, info::Ptr{Int64})::Cvoid +end + function mc57b(n, yesa, la, a, nz, irn, ip) @ccall libhsl.mc57b_(n::Ref{Cint}, yesa::Ref{Cint}, la::Ref{Cint}, a::Ptr{Float32}, nz::Ref{Cint}, irn::Ptr{Cint}, ip::Ptr{Cint})::Cvoid end + +function mc57b_64(n, yesa, la, a, nz, irn, ip) + @ccall libhsl_subset_64.mc57b_64_(n::Ref{Int64}, yesa::Ref{Int64}, la::Ref{Int64}, + a::Ptr{Float32}, nz::Ref{Int64}, irn::Ptr{Int64}, + ip::Ptr{Int64})::Cvoid +end diff --git a/src/Fortran/mc59.jl b/src/Fortran/mc59.jl index dc50ccb..1207b30 100644 --- a/src/Fortran/mc59.jl +++ b/src/Fortran/mc59.jl @@ -42,6 +42,14 @@ function mc59ad(icntl, nc, nr, ne, irn, ljcn, jcn, la, a, lip, ip, liw, iw, info iw::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function mc59ad_64(icntl, nc, nr, ne, irn, ljcn, jcn, la, a, lip, ip, liw, iw, info) + @ccall libhsl_subset_64.mc59ad_64_(icntl::Ptr{Int64}, nc::Ref{Int64}, nr::Ref{Int64}, + ne::Ref{Int64}, irn::Ptr{Int64}, ljcn::Ref{Int64}, + jcn::Ptr{Int64}, la::Ref{Int64}, a::Ptr{Float64}, + lip::Ref{Int64}, ip::Ptr{Int64}, liw::Ref{Int64}, + iw::Ptr{Int64}, info::Ptr{Int64})::Cvoid +end + function mc59bd(lcheck, part, nc, nr, ne, irn, jcn, la, a, ip, iw, iout, jout, kne) @ccall libhsl.mc59bd_(lcheck::Ref{Cint}, part::Ref{Cint}, nc::Ref{Cint}, nr::Ref{Cint}, ne::Ref{Cint}, irn::Ptr{Cint}, jcn::Ptr{Cint}, la::Ref{Cint}, @@ -49,22 +57,48 @@ function mc59bd(lcheck, part, nc, nr, ne, irn, jcn, la, a, ip, iw, iout, jout, k jout::Ref{Cint}, kne::Ref{Cint})::Cvoid end +function mc59bd_64(lcheck, part, nc, nr, ne, irn, jcn, la, a, ip, iw, iout, jout, kne) + @ccall libhsl_subset_64.mc59bd_64_(lcheck::Ref{Int64}, part::Ref{Int64}, nc::Ref{Int64}, + nr::Ref{Int64}, ne::Ref{Int64}, irn::Ptr{Int64}, + jcn::Ptr{Int64}, la::Ref{Int64}, a::Ptr{Float64}, + ip::Ptr{Int64}, iw::Ptr{Int64}, iout::Ref{Int64}, + jout::Ref{Int64}, kne::Ref{Int64})::Cvoid +end + function mc59cd(nc, nr, ne, irn, jcn, la, a, ip, iw) @ccall libhsl.mc59cd_(nc::Ref{Cint}, nr::Ref{Cint}, ne::Ref{Cint}, irn::Ptr{Cint}, jcn::Ptr{Cint}, la::Ref{Cint}, a::Ptr{Float64}, ip::Ptr{Cint}, iw::Ptr{Cint})::Cvoid end +function mc59cd_64(nc, nr, ne, irn, jcn, la, a, ip, iw) + @ccall libhsl_subset_64.mc59cd_64_(nc::Ref{Int64}, nr::Ref{Int64}, ne::Ref{Int64}, + irn::Ptr{Int64}, jcn::Ptr{Int64}, la::Ref{Int64}, + a::Ptr{Float64}, ip::Ptr{Int64}, iw::Ptr{Int64})::Cvoid +end + function mc59dd(nc, ne, irn, ip, la, a) @ccall libhsl.mc59dd_(nc::Ref{Cint}, ne::Ref{Cint}, irn::Ptr{Cint}, ip::Ptr{Cint}, la::Ref{Cint}, a::Ptr{Float64})::Cvoid end +function mc59dd_64(nc, ne, irn, ip, la, a) + @ccall libhsl_subset_64.mc59dd_64_(nc::Ref{Int64}, ne::Ref{Int64}, irn::Ptr{Int64}, + ip::Ptr{Int64}, la::Ref{Int64}, a::Ptr{Float64})::Cvoid +end + function mc59ed(nc, nr, ne, irn, lip, ip, la, a, iw, idup, kne, icntl6) @ccall libhsl.mc59ed_(nc::Ref{Cint}, nr::Ref{Cint}, ne::Ref{Cint}, irn::Ptr{Cint}, lip::Ref{Cint}, ip::Ptr{Cint}, la::Ref{Cint}, a::Ptr{Float64}, iw::Ptr{Cint}, idup::Ref{Cint}, kne::Ref{Cint}, icntl6::Ref{Cint})::Cvoid end +function mc59ed_64(nc, nr, ne, irn, lip, ip, la, a, iw, idup, kne, icntl6) + @ccall libhsl_subset_64.mc59ed_64_(nc::Ref{Int64}, nr::Ref{Int64}, ne::Ref{Int64}, + irn::Ptr{Int64}, lip::Ref{Int64}, ip::Ptr{Int64}, + la::Ref{Int64}, a::Ptr{Float64}, iw::Ptr{Int64}, + idup::Ref{Int64}, kne::Ref{Int64}, icntl6::Ref{Int64})::Cvoid +end + function mc59fd(nc, nr, ne, irn, lip, ip, la, a, liw, iw, idup, iout, iup, kne, icntl6, info) @ccall libhsl.mc59fd_(nc::Ref{Cint}, nr::Ref{Cint}, ne::Ref{Cint}, irn::Ptr{Cint}, lip::Ref{Cint}, ip::Ptr{Cint}, la::Ref{Cint}, a::Ptr{Float64}, liw::Ref{Cint}, @@ -72,6 +106,15 @@ function mc59fd(nc, nr, ne, irn, lip, ip, la, a, liw, iw, idup, iout, iup, kne, kne::Ref{Cint}, icntl6::Ref{Cint}, info::Ptr{Cint})::Cvoid end +function mc59fd_64(nc, nr, ne, irn, lip, ip, la, a, liw, iw, idup, iout, iup, kne, icntl6, info) + @ccall libhsl_subset_64.mc59fd_64_(nc::Ref{Int64}, nr::Ref{Int64}, ne::Ref{Int64}, + irn::Ptr{Int64}, lip::Ref{Int64}, ip::Ptr{Int64}, + la::Ref{Int64}, a::Ptr{Float64}, liw::Ref{Int64}, + iw::Ptr{Int64}, idup::Ref{Int64}, iout::Ref{Int64}, + iup::Ref{Int64}, kne::Ref{Int64}, icntl6::Ref{Int64}, + info::Ptr{Int64})::Cvoid +end + function mc59ai(icntl, nc, nr, ne, irn, ljcn, jcn, la, a, lip, ip, liw, iw, info) @ccall libhsl.mc59ai_(icntl::Ptr{Cint}, nc::Ref{Cint}, nr::Ref{Cint}, ne::Ref{Cint}, irn::Ptr{Cint}, ljcn::Ref{Cint}, jcn::Ptr{Cint}, la::Ref{Cint}, @@ -116,6 +159,14 @@ function mc59a(icntl, nc, nr, ne, irn, ljcn, jcn, la, a, lip, ip, liw, iw, info) iw::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function mc59a_64(icntl, nc, nr, ne, irn, ljcn, jcn, la, a, lip, ip, liw, iw, info) + @ccall libhsl_subset_64.mc59a_64_(icntl::Ptr{Int64}, nc::Ref{Int64}, nr::Ref{Int64}, + ne::Ref{Int64}, irn::Ptr{Int64}, ljcn::Ref{Int64}, + jcn::Ptr{Int64}, la::Ref{Int64}, a::Ptr{Float32}, + lip::Ref{Int64}, ip::Ptr{Int64}, liw::Ref{Int64}, + iw::Ptr{Int64}, info::Ptr{Int64})::Cvoid +end + function mc59b(lcheck, part, nc, nr, ne, irn, jcn, la, a, ip, iw, iout, jout, kne) @ccall libhsl.mc59b_(lcheck::Ref{Cint}, part::Ref{Cint}, nc::Ref{Cint}, nr::Ref{Cint}, ne::Ref{Cint}, irn::Ptr{Cint}, jcn::Ptr{Cint}, la::Ref{Cint}, @@ -123,22 +174,48 @@ function mc59b(lcheck, part, nc, nr, ne, irn, jcn, la, a, ip, iw, iout, jout, kn jout::Ref{Cint}, kne::Ref{Cint})::Cvoid end +function mc59b_64(lcheck, part, nc, nr, ne, irn, jcn, la, a, ip, iw, iout, jout, kne) + @ccall libhsl_subset_64.mc59b_64_(lcheck::Ref{Int64}, part::Ref{Int64}, nc::Ref{Int64}, + nr::Ref{Int64}, ne::Ref{Int64}, irn::Ptr{Int64}, + jcn::Ptr{Int64}, la::Ref{Int64}, a::Ptr{Float32}, + ip::Ptr{Int64}, iw::Ptr{Int64}, iout::Ref{Int64}, + jout::Ref{Int64}, kne::Ref{Int64})::Cvoid +end + function mc59c(nc, nr, ne, irn, jcn, la, a, ip, iw) @ccall libhsl.mc59c_(nc::Ref{Cint}, nr::Ref{Cint}, ne::Ref{Cint}, irn::Ptr{Cint}, jcn::Ptr{Cint}, la::Ref{Cint}, a::Ptr{Float32}, ip::Ptr{Cint}, iw::Ptr{Cint})::Cvoid end +function mc59c_64(nc, nr, ne, irn, jcn, la, a, ip, iw) + @ccall libhsl_subset_64.mc59c_64_(nc::Ref{Int64}, nr::Ref{Int64}, ne::Ref{Int64}, irn::Ptr{Int64}, + jcn::Ptr{Int64}, la::Ref{Int64}, a::Ptr{Float32}, + ip::Ptr{Int64}, iw::Ptr{Int64})::Cvoid +end + function mc59d(nc, ne, irn, ip, la, a) @ccall libhsl.mc59d_(nc::Ref{Cint}, ne::Ref{Cint}, irn::Ptr{Cint}, ip::Ptr{Cint}, la::Ref{Cint}, a::Ptr{Float32})::Cvoid end +function mc59d_64(nc, ne, irn, ip, la, a) + @ccall libhsl_subset_64.mc59d_64_(nc::Ref{Int64}, ne::Ref{Int64}, irn::Ptr{Int64}, ip::Ptr{Int64}, + la::Ref{Int64}, a::Ptr{Float32})::Cvoid +end + function mc59e(nc, nr, ne, irn, lip, ip, la, a, iw, idup, kne, icntl6) @ccall libhsl.mc59e_(nc::Ref{Cint}, nr::Ref{Cint}, ne::Ref{Cint}, irn::Ptr{Cint}, lip::Ref{Cint}, ip::Ptr{Cint}, la::Ref{Cint}, a::Ptr{Float32}, iw::Ptr{Cint}, idup::Ref{Cint}, kne::Ref{Cint}, icntl6::Ref{Cint})::Cvoid end +function mc59e_64(nc, nr, ne, irn, lip, ip, la, a, iw, idup, kne, icntl6) + @ccall libhsl_subset_64.mc59e_64_(nc::Ref{Int64}, nr::Ref{Int64}, ne::Ref{Int64}, irn::Ptr{Int64}, + lip::Ref{Int64}, ip::Ptr{Int64}, la::Ref{Int64}, + a::Ptr{Float32}, iw::Ptr{Int64}, idup::Ref{Int64}, + kne::Ref{Int64}, icntl6::Ref{Int64})::Cvoid +end + function mc59f(nc, nr, ne, irn, lip, ip, la, a, liw, iw, idup, iout, iup, kne, icntl6, info) @ccall libhsl.mc59f_(nc::Ref{Cint}, nr::Ref{Cint}, ne::Ref{Cint}, irn::Ptr{Cint}, lip::Ref{Cint}, ip::Ptr{Cint}, la::Ref{Cint}, a::Ptr{Float32}, liw::Ref{Cint}, iw::Ptr{Cint}, @@ -146,6 +223,14 @@ function mc59f(nc, nr, ne, irn, lip, ip, la, a, liw, iw, idup, iout, iup, kne, i icntl6::Ref{Cint}, info::Ptr{Cint})::Cvoid end +function mc59f_64(nc, nr, ne, irn, lip, ip, la, a, liw, iw, idup, iout, iup, kne, icntl6, info) + @ccall libhsl_subset_64.mc59f_64_(nc::Ref{Int64}, nr::Ref{Int64}, ne::Ref{Int64}, irn::Ptr{Int64}, + lip::Ref{Int64}, ip::Ptr{Int64}, la::Ref{Int64}, + a::Ptr{Float32}, liw::Ref{Int64}, iw::Ptr{Int64}, + idup::Ref{Int64}, iout::Ref{Int64}, iup::Ref{Int64}, + kne::Ref{Int64}, icntl6::Ref{Int64}, info::Ptr{Int64})::Cvoid +end + function mc59az(icntl, nc, nr, ne, irn, ljcn, jcn, la, a, lip, ip, liw, iw, info) @ccall libhsl.mc59az_(icntl::Ptr{Cint}, nc::Ref{Cint}, nr::Ref{Cint}, ne::Ref{Cint}, irn::Ptr{Cint}, ljcn::Ref{Cint}, jcn::Ptr{Cint}, la::Ref{Cint}, diff --git a/src/Fortran/mc60.jl b/src/Fortran/mc60.jl index 4113df9..c57b239 100644 --- a/src/Fortran/mc60.jl +++ b/src/Fortran/mc60.jl @@ -3,11 +3,23 @@ function mc60ad(n, lirn, irn, icptr, icntl, iw, info) icntl::Ptr{Cint}, iw::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function mc60ad_64(n, lirn, irn, icptr, icntl, iw, info) + @ccall libhsl_subset_64.mc60ad_64_(n::Ref{Int64}, lirn::Ref{Int64}, irn::Ptr{Int64}, + icptr::Ptr{Int64}, icntl::Ptr{Int64}, iw::Ptr{Int64}, + info::Ptr{Int64})::Cvoid +end + function mc60bd(n, lirn, irn, icptr, nsup, svar, vars, iw) @ccall libhsl.mc60bd_(n::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, nsup::Ref{Cint}, svar::Ptr{Cint}, vars::Ptr{Cint}, iw::Ptr{Cint})::Cvoid end +function mc60bd_64(n, lirn, irn, icptr, nsup, svar, vars, iw) + @ccall libhsl_subset_64.mc60bd_64_(n::Ref{Int64}, lirn::Ref{Int64}, irn::Ptr{Int64}, + icptr::Ptr{Int64}, nsup::Ref{Int64}, svar::Ptr{Int64}, + vars::Ptr{Int64}, iw::Ptr{Int64})::Cvoid +end + function mc60cd(n, nsup, lirn, irn, icptr, vars, jcntl, permsv, weight, pair, info, iw, w) @ccall libhsl.mc60cd_(n::Ref{Cint}, nsup::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, vars::Ptr{Cint}, jcntl::Ptr{Cint}, permsv::Ptr{Cint}, @@ -15,35 +27,75 @@ function mc60cd(n, nsup, lirn, irn, icptr, vars, jcntl, permsv, weight, pair, in w::Ptr{Float64})::Cvoid end +function mc60cd_64(n, nsup, lirn, irn, icptr, vars, jcntl, permsv, weight, pair, info, iw, w) + @ccall libhsl_subset_64.mc60cd_64_(n::Ref{Int64}, nsup::Ref{Int64}, lirn::Ref{Int64}, + irn::Ptr{Int64}, icptr::Ptr{Int64}, vars::Ptr{Int64}, + jcntl::Ptr{Int64}, permsv::Ptr{Int64}, weight::Ptr{Float64}, + pair::Ptr{Int64}, info::Ptr{Int64}, iw::Ptr{Int64}, + w::Ptr{Float64})::Cvoid +end + function mc60dd(n, nsup, svar, vars, permsv, perm, possv) @ccall libhsl.mc60dd_(n::Ref{Cint}, nsup::Ref{Cint}, svar::Ptr{Cint}, vars::Ptr{Cint}, permsv::Ptr{Cint}, perm::Ptr{Cint}, possv::Ptr{Cint})::Cvoid end +function mc60dd_64(n, nsup, svar, vars, permsv, perm, possv) + @ccall libhsl_subset_64.mc60dd_64_(n::Ref{Int64}, nsup::Ref{Int64}, svar::Ptr{Int64}, + vars::Ptr{Int64}, permsv::Ptr{Int64}, perm::Ptr{Int64}, + possv::Ptr{Int64})::Cvoid +end + function mc60ed(n, nsup, lirn, irn, icptr, svar, vars, permsv, perm, iw) @ccall libhsl.mc60ed_(n::Ref{Cint}, nsup::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, svar::Ptr{Cint}, vars::Ptr{Cint}, permsv::Ptr{Cint}, perm::Ptr{Cint}, iw::Ptr{Cint})::Cvoid end +function mc60ed_64(n, nsup, lirn, irn, icptr, svar, vars, permsv, perm, iw) + @ccall libhsl_subset_64.mc60ed_64_(n::Ref{Int64}, nsup::Ref{Int64}, lirn::Ref{Int64}, + irn::Ptr{Int64}, icptr::Ptr{Int64}, svar::Ptr{Int64}, + vars::Ptr{Int64}, permsv::Ptr{Int64}, perm::Ptr{Int64}, + iw::Ptr{Int64})::Cvoid +end + function mc60fd(n, nsup, lirn, irn, icptr, vars, permsv, iw, rinfo) @ccall libhsl.mc60fd_(n::Ref{Cint}, nsup::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, vars::Ptr{Cint}, permsv::Ptr{Cint}, iw::Ptr{Cint}, rinfo::Ptr{Float64})::Cvoid end +function mc60fd_64(n, nsup, lirn, irn, icptr, vars, permsv, iw, rinfo) + @ccall libhsl_subset_64.mc60fd_64_(n::Ref{Int64}, nsup::Ref{Int64}, lirn::Ref{Int64}, + irn::Ptr{Int64}, icptr::Ptr{Int64}, vars::Ptr{Int64}, + permsv::Ptr{Int64}, iw::Ptr{Int64}, rinfo::Ptr{Float64})::Cvoid +end + function mc60gd(n, nsup, lirn, irn, icptr, vars, permsv, iw, rinfo) @ccall libhsl.mc60gd_(n::Ref{Cint}, nsup::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, vars::Ptr{Cint}, permsv::Ptr{Cint}, iw::Ptr{Cint}, rinfo::Ptr{Float64})::Cvoid end +function mc60gd_64(n, nsup, lirn, irn, icptr, vars, permsv, iw, rinfo) + @ccall libhsl_subset_64.mc60gd_64_(n::Ref{Int64}, nsup::Ref{Int64}, lirn::Ref{Int64}, + irn::Ptr{Int64}, icptr::Ptr{Int64}, vars::Ptr{Int64}, + permsv::Ptr{Int64}, iw::Ptr{Int64}, rinfo::Ptr{Float64})::Cvoid +end + function mc60hd(n, nsup, lirn, irn, icptr, vars, mask, ls, xls, list, info) @ccall libhsl.mc60hd_(n::Ref{Cint}, nsup::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, vars::Ptr{Cint}, mask::Ptr{Cint}, ls::Ptr{Cint}, xls::Ptr{Cint}, list::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function mc60hd_64(n, nsup, lirn, irn, icptr, vars, mask, ls, xls, list, info) + @ccall libhsl_subset_64.mc60hd_64_(n::Ref{Int64}, nsup::Ref{Int64}, lirn::Ref{Int64}, + irn::Ptr{Int64}, icptr::Ptr{Int64}, vars::Ptr{Int64}, + mask::Ptr{Int64}, ls::Ptr{Int64}, xls::Ptr{Int64}, + list::Ptr{Int64}, info::Ptr{Int64})::Cvoid +end + function mc60jd(nsup, lirn, nodes, nstrt, lstnum, irn, icptr, vars, status, weight, nlist, queue, deg, prior) @ccall libhsl.mc60jd_(nsup::Ref{Cint}, lirn::Ref{Cint}, nodes::Ref{Cint}, nstrt::Ref{Cint}, @@ -52,6 +104,15 @@ function mc60jd(nsup, lirn, nodes, nstrt, lstnum, irn, icptr, vars, status, weig deg::Ptr{Cint}, prior::Ptr{Float64})::Cvoid end +function mc60jd_64(nsup, lirn, nodes, nstrt, lstnum, irn, icptr, vars, status, weight, nlist, queue, + deg, prior) + @ccall libhsl_subset_64.mc60jd_64_(nsup::Ref{Int64}, lirn::Ref{Int64}, nodes::Ref{Int64}, + nstrt::Ref{Int64}, lstnum::Ref{Int64}, irn::Ptr{Int64}, + icptr::Ptr{Int64}, vars::Ptr{Int64}, status::Ptr{Int64}, + weight::Ptr{Float64}, nlist::Ptr{Int64}, queue::Ptr{Int64}, + deg::Ptr{Int64}, prior::Ptr{Float64})::Cvoid +end + function mc60ld(root, maxwid, nsup, lirn, irn, icptr, vars, mask, ls, xls, nlvl, lwidth, nvars) @ccall libhsl.mc60ld_(root::Ref{Cint}, maxwid::Ref{Cint}, nsup::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, vars::Ptr{Cint}, mask::Ptr{Cint}, @@ -59,34 +120,74 @@ function mc60ld(root, maxwid, nsup, lirn, irn, icptr, vars, mask, ls, xls, nlvl, nvars::Ref{Cint})::Cvoid end +function mc60ld_64(root, maxwid, nsup, lirn, irn, icptr, vars, mask, ls, xls, nlvl, lwidth, nvars) + @ccall libhsl_subset_64.mc60ld_64_(root::Ref{Int64}, maxwid::Ref{Int64}, nsup::Ref{Int64}, + lirn::Ref{Int64}, irn::Ptr{Int64}, icptr::Ptr{Int64}, + vars::Ptr{Int64}, mask::Ptr{Int64}, ls::Ptr{Int64}, + xls::Ptr{Int64}, nlvl::Ref{Int64}, lwidth::Ref{Int64}, + nvars::Ref{Int64})::Cvoid +end + function mc60od(n, nc, lirn, irn, icptr, svar, nsup, new, vars, flag) @ccall libhsl.mc60od_(n::Ref{Cint}, nc::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, svar::Ptr{Cint}, nsup::Ref{Cint}, new::Ptr{Cint}, vars::Ptr{Cint}, flag::Ptr{Cint})::Cvoid end +function mc60od_64(n, nc, lirn, irn, icptr, svar, nsup, new, vars, flag) + @ccall libhsl_subset_64.mc60od_64_(n::Ref{Int64}, nc::Ref{Int64}, lirn::Ref{Int64}, + irn::Ptr{Int64}, icptr::Ptr{Int64}, svar::Ptr{Int64}, + nsup::Ref{Int64}, new::Ptr{Int64}, vars::Ptr{Int64}, + flag::Ptr{Int64})::Cvoid +end + function mc60pd(n, nsup, lirn, irn, icptr, svar, vars, var, flag) @ccall libhsl.mc60pd_(n::Ref{Cint}, nsup::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, svar::Ptr{Cint}, vars::Ptr{Cint}, var::Ptr{Cint}, flag::Ptr{Cint})::Cvoid end +function mc60pd_64(n, nsup, lirn, irn, icptr, svar, vars, var, flag) + @ccall libhsl_subset_64.mc60pd_64_(n::Ref{Int64}, nsup::Ref{Int64}, lirn::Ref{Int64}, + irn::Ptr{Int64}, icptr::Ptr{Int64}, svar::Ptr{Int64}, + vars::Ptr{Int64}, var::Ptr{Int64}, flag::Ptr{Int64})::Cvoid +end + function mc60qd(root, nsup, lirn, irn, icptr, vars, mask, ls, xls, nlvl, nvars, degree) @ccall libhsl.mc60qd_(root::Ref{Cint}, nsup::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, vars::Ptr{Cint}, mask::Ptr{Cint}, ls::Ptr{Cint}, xls::Ptr{Cint}, nlvl::Ref{Cint}, nvars::Ref{Cint}, degree::Ptr{Cint})::Cvoid end +function mc60qd_64(root, nsup, lirn, irn, icptr, vars, mask, ls, xls, nlvl, nvars, degree) + @ccall libhsl_subset_64.mc60qd_64_(root::Ref{Int64}, nsup::Ref{Int64}, lirn::Ref{Int64}, + irn::Ptr{Int64}, icptr::Ptr{Int64}, vars::Ptr{Int64}, + mask::Ptr{Int64}, ls::Ptr{Int64}, xls::Ptr{Int64}, + nlvl::Ref{Int64}, nvars::Ref{Int64}, degree::Ptr{Int64})::Cvoid +end + function mc60a(n, lirn, irn, icptr, icntl, iw, info) @ccall libhsl.mc60a_(n::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, icntl::Ptr{Cint}, iw::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function mc60a_64(n, lirn, irn, icptr, icntl, iw, info) + @ccall libhsl_subset_64.mc60a_64_(n::Ref{Int64}, lirn::Ref{Int64}, irn::Ptr{Int64}, + icptr::Ptr{Int64}, icntl::Ptr{Int64}, iw::Ptr{Int64}, + info::Ptr{Int64})::Cvoid +end + function mc60b(n, lirn, irn, icptr, nsup, svar, vars, iw) @ccall libhsl.mc60b_(n::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, nsup::Ref{Cint}, svar::Ptr{Cint}, vars::Ptr{Cint}, iw::Ptr{Cint})::Cvoid end +function mc60b_64(n, lirn, irn, icptr, nsup, svar, vars, iw) + @ccall libhsl_subset_64.mc60b_64_(n::Ref{Int64}, lirn::Ref{Int64}, irn::Ptr{Int64}, + icptr::Ptr{Int64}, nsup::Ref{Int64}, svar::Ptr{Int64}, + vars::Ptr{Int64}, iw::Ptr{Int64})::Cvoid +end + function mc60c(n, nsup, lirn, irn, icptr, vars, jcntl, permsv, weight, pair, info, iw, w) @ccall libhsl.mc60c_(n::Ref{Cint}, nsup::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, vars::Ptr{Cint}, jcntl::Ptr{Cint}, permsv::Ptr{Cint}, @@ -94,35 +195,75 @@ function mc60c(n, nsup, lirn, irn, icptr, vars, jcntl, permsv, weight, pair, inf w::Ptr{Float32})::Cvoid end +function mc60c_64(n, nsup, lirn, irn, icptr, vars, jcntl, permsv, weight, pair, info, iw, w) + @ccall libhsl_subset_64.mc60c_64_(n::Ref{Int64}, nsup::Ref{Int64}, lirn::Ref{Int64}, + irn::Ptr{Int64}, icptr::Ptr{Int64}, vars::Ptr{Int64}, + jcntl::Ptr{Int64}, permsv::Ptr{Int64}, weight::Ptr{Float32}, + pair::Ptr{Int64}, info::Ptr{Int64}, iw::Ptr{Int64}, + w::Ptr{Float32})::Cvoid +end + function mc60d(n, nsup, svar, vars, permsv, perm, possv) @ccall libhsl.mc60d_(n::Ref{Cint}, nsup::Ref{Cint}, svar::Ptr{Cint}, vars::Ptr{Cint}, permsv::Ptr{Cint}, perm::Ptr{Cint}, possv::Ptr{Cint})::Cvoid end +function mc60d_64(n, nsup, svar, vars, permsv, perm, possv) + @ccall libhsl_subset_64.mc60d_64_(n::Ref{Int64}, nsup::Ref{Int64}, svar::Ptr{Int64}, + vars::Ptr{Int64}, permsv::Ptr{Int64}, perm::Ptr{Int64}, + possv::Ptr{Int64})::Cvoid +end + function mc60e(n, nsup, lirn, irn, icptr, svar, vars, permsv, perm, iw) @ccall libhsl.mc60e_(n::Ref{Cint}, nsup::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, svar::Ptr{Cint}, vars::Ptr{Cint}, permsv::Ptr{Cint}, perm::Ptr{Cint}, iw::Ptr{Cint})::Cvoid end +function mc60e_64(n, nsup, lirn, irn, icptr, svar, vars, permsv, perm, iw) + @ccall libhsl_subset_64.mc60e_64_(n::Ref{Int64}, nsup::Ref{Int64}, lirn::Ref{Int64}, + irn::Ptr{Int64}, icptr::Ptr{Int64}, svar::Ptr{Int64}, + vars::Ptr{Int64}, permsv::Ptr{Int64}, perm::Ptr{Int64}, + iw::Ptr{Int64})::Cvoid +end + function mc60f(n, nsup, lirn, irn, icptr, vars, permsv, iw, rinfo) @ccall libhsl.mc60f_(n::Ref{Cint}, nsup::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, vars::Ptr{Cint}, permsv::Ptr{Cint}, iw::Ptr{Cint}, rinfo::Ptr{Float32})::Cvoid end +function mc60f_64(n, nsup, lirn, irn, icptr, vars, permsv, iw, rinfo) + @ccall libhsl_subset_64.mc60f_64_(n::Ref{Int64}, nsup::Ref{Int64}, lirn::Ref{Int64}, + irn::Ptr{Int64}, icptr::Ptr{Int64}, vars::Ptr{Int64}, + permsv::Ptr{Int64}, iw::Ptr{Int64}, rinfo::Ptr{Float32})::Cvoid +end + function mc60g(n, nsup, lirn, irn, icptr, vars, permsv, iw, rinfo) @ccall libhsl.mc60g_(n::Ref{Cint}, nsup::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, vars::Ptr{Cint}, permsv::Ptr{Cint}, iw::Ptr{Cint}, rinfo::Ptr{Float32})::Cvoid end +function mc60g_64(n, nsup, lirn, irn, icptr, vars, permsv, iw, rinfo) + @ccall libhsl_subset_64.mc60g_64_(n::Ref{Int64}, nsup::Ref{Int64}, lirn::Ref{Int64}, + irn::Ptr{Int64}, icptr::Ptr{Int64}, vars::Ptr{Int64}, + permsv::Ptr{Int64}, iw::Ptr{Int64}, rinfo::Ptr{Float32})::Cvoid +end + function mc60h(n, nsup, lirn, irn, icptr, vars, mask, ls, xls, list, info) @ccall libhsl.mc60h_(n::Ref{Cint}, nsup::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, vars::Ptr{Cint}, mask::Ptr{Cint}, ls::Ptr{Cint}, xls::Ptr{Cint}, list::Ptr{Cint}, info::Ptr{Cint})::Cvoid end +function mc60h_64(n, nsup, lirn, irn, icptr, vars, mask, ls, xls, list, info) + @ccall libhsl_subset_64.mc60h_64_(n::Ref{Int64}, nsup::Ref{Int64}, lirn::Ref{Int64}, + irn::Ptr{Int64}, icptr::Ptr{Int64}, vars::Ptr{Int64}, + mask::Ptr{Int64}, ls::Ptr{Int64}, xls::Ptr{Int64}, + list::Ptr{Int64}, info::Ptr{Int64})::Cvoid +end + function mc60j(nsup, lirn, nodes, nstrt, lstnum, irn, icptr, vars, status, weight, nlist, queue, deg, prior) @ccall libhsl.mc60j_(nsup::Ref{Cint}, lirn::Ref{Cint}, nodes::Ref{Cint}, nstrt::Ref{Cint}, @@ -131,6 +272,15 @@ function mc60j(nsup, lirn, nodes, nstrt, lstnum, irn, icptr, vars, status, weigh deg::Ptr{Cint}, prior::Ptr{Float32})::Cvoid end +function mc60j_64(nsup, lirn, nodes, nstrt, lstnum, irn, icptr, vars, status, weight, nlist, queue, + deg, prior) + @ccall libhsl_subset_64.mc60j_64_(nsup::Ref{Int64}, lirn::Ref{Int64}, nodes::Ref{Int64}, + nstrt::Ref{Int64}, lstnum::Ref{Int64}, irn::Ptr{Int64}, + icptr::Ptr{Int64}, vars::Ptr{Int64}, status::Ptr{Int64}, + weight::Ptr{Float32}, nlist::Ptr{Int64}, queue::Ptr{Int64}, + deg::Ptr{Int64}, prior::Ptr{Float32})::Cvoid +end + function mc60l(root, maxwid, nsup, lirn, irn, icptr, vars, mask, ls, xls, nlvl, lwidth, nvars) @ccall libhsl.mc60l_(root::Ref{Cint}, maxwid::Ref{Cint}, nsup::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, vars::Ptr{Cint}, mask::Ptr{Cint}, @@ -138,20 +288,48 @@ function mc60l(root, maxwid, nsup, lirn, irn, icptr, vars, mask, ls, xls, nlvl, nvars::Ref{Cint})::Cvoid end +function mc60l_64(root, maxwid, nsup, lirn, irn, icptr, vars, mask, ls, xls, nlvl, lwidth, nvars) + @ccall libhsl_subset_64.mc60l_64_(root::Ref{Int64}, maxwid::Ref{Int64}, nsup::Ref{Int64}, + lirn::Ref{Int64}, irn::Ptr{Int64}, icptr::Ptr{Int64}, + vars::Ptr{Int64}, mask::Ptr{Int64}, ls::Ptr{Int64}, + xls::Ptr{Int64}, nlvl::Ref{Int64}, lwidth::Ref{Int64}, + nvars::Ref{Int64})::Cvoid +end + function mc60o(n, nc, lirn, irn, icptr, svar, nsup, new, vars, flag) @ccall libhsl.mc60o_(n::Ref{Cint}, nc::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, svar::Ptr{Cint}, nsup::Ref{Cint}, new::Ptr{Cint}, vars::Ptr{Cint}, flag::Ptr{Cint})::Cvoid end +function mc60o_64(n, nc, lirn, irn, icptr, svar, nsup, new, vars, flag) + @ccall libhsl_subset_64.mc60o_64_(n::Ref{Int64}, nc::Ref{Int64}, lirn::Ref{Int64}, + irn::Ptr{Int64}, icptr::Ptr{Int64}, svar::Ptr{Int64}, + nsup::Ref{Int64}, new::Ptr{Int64}, vars::Ptr{Int64}, + flag::Ptr{Int64})::Cvoid +end + function mc60p(n, nsup, lirn, irn, icptr, svar, vars, var, flag) @ccall libhsl.mc60p_(n::Ref{Cint}, nsup::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, svar::Ptr{Cint}, vars::Ptr{Cint}, var::Ptr{Cint}, flag::Ptr{Cint})::Cvoid end +function mc60p_64(n, nsup, lirn, irn, icptr, svar, vars, var, flag) + @ccall libhsl_subset_64.mc60p_64_(n::Ref{Int64}, nsup::Ref{Int64}, lirn::Ref{Int64}, + irn::Ptr{Int64}, icptr::Ptr{Int64}, svar::Ptr{Int64}, + vars::Ptr{Int64}, var::Ptr{Int64}, flag::Ptr{Int64})::Cvoid +end + function mc60q(root, nsup, lirn, irn, icptr, vars, mask, ls, xls, nlvl, nvars) @ccall libhsl.mc60q_(root::Ref{Cint}, nsup::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, vars::Ptr{Cint}, mask::Ptr{Cint}, ls::Ptr{Cint}, xls::Ptr{Cint}, nlvl::Ref{Cint}, nvars::Ref{Cint})::Cvoid end + +function mc60q_64(root, nsup, lirn, irn, icptr, vars, mask, ls, xls, nlvl, nvars) + @ccall libhsl_subset_64.mc60q_64_(root::Ref{Int64}, nsup::Ref{Int64}, lirn::Ref{Int64}, + irn::Ptr{Int64}, icptr::Ptr{Int64}, vars::Ptr{Int64}, + mask::Ptr{Int64}, ls::Ptr{Int64}, xls::Ptr{Int64}, + nlvl::Ref{Int64}, nvars::Ref{Int64})::Cvoid +end diff --git a/src/Fortran/mc61.jl b/src/Fortran/mc61.jl index 609f220..4c93cfa 100644 --- a/src/Fortran/mc61.jl +++ b/src/Fortran/mc61.jl @@ -2,6 +2,10 @@ function mc61id(icntl, cntl) @ccall libhsl.mc61id_(icntl::Ptr{Cint}, cntl::Ptr{Float64})::Cvoid end +function mc61id_64(icntl, cntl) + @ccall libhsl_subset_64.mc61id_64_(icntl::Ptr{Int64}, cntl::Ptr{Float64})::Cvoid +end + function mc61ad(job, n, lirn, irn, icptr, perm, liw, iw, w, icntl, cntl, info, rinfo) @ccall libhsl.mc61ad_(job::Ref{Cint}, n::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, perm::Ptr{Cint}, liw::Ref{Cint}, iw::Ptr{Cint}, @@ -9,13 +13,33 @@ function mc61ad(job, n, lirn, irn, icptr, perm, liw, iw, w, icntl, cntl, info, r rinfo::Ptr{Float64})::Cvoid end +function mc61ad_64(job, n, lirn, irn, icptr, perm, liw, iw, w, icntl, cntl, info, rinfo) + @ccall libhsl_subset_64.mc61ad_64_(job::Ref{Int64}, n::Ref{Int64}, lirn::Ref{Int64}, + irn::Ptr{Int64}, icptr::Ptr{Int64}, perm::Ptr{Int64}, + liw::Ref{Int64}, iw::Ptr{Int64}, w::Ptr{Float64}, + icntl::Ptr{Int64}, cntl::Ptr{Float64}, info::Ptr{Int64}, + rinfo::Ptr{Float64})::Cvoid +end + function mc61i(icntl, cntl) @ccall libhsl.mc61i_(icntl::Ptr{Cint}, cntl::Ptr{Float32})::Cvoid end +function mc61i_64(icntl, cntl) + @ccall libhsl_subset_64.mc61i_64_(icntl::Ptr{Int64}, cntl::Ptr{Float32})::Cvoid +end + function mc61a(job, n, lirn, irn, icptr, perm, liw, iw, w, icntl, cntl, info, rinfo) @ccall libhsl.mc61a_(job::Ref{Cint}, n::Ref{Cint}, lirn::Ref{Cint}, irn::Ptr{Cint}, icptr::Ptr{Cint}, perm::Ptr{Cint}, liw::Ref{Cint}, iw::Ptr{Cint}, w::Ptr{Float32}, icntl::Ptr{Cint}, cntl::Ptr{Float32}, info::Ptr{Cint}, rinfo::Ptr{Float32})::Cvoid end + +function mc61a_64(job, n, lirn, irn, icptr, perm, liw, iw, w, icntl, cntl, info, rinfo) + @ccall libhsl_subset_64.mc61a_64_(job::Ref{Int64}, n::Ref{Int64}, lirn::Ref{Int64}, + irn::Ptr{Int64}, icptr::Ptr{Int64}, perm::Ptr{Int64}, + liw::Ref{Int64}, iw::Ptr{Int64}, w::Ptr{Float32}, + icntl::Ptr{Int64}, cntl::Ptr{Float32}, info::Ptr{Int64}, + rinfo::Ptr{Float32})::Cvoid +end diff --git a/src/Fortran/mc64.jl b/src/Fortran/mc64.jl index 8e69585..1485072 100644 --- a/src/Fortran/mc64.jl +++ b/src/Fortran/mc64.jl @@ -2,6 +2,10 @@ function mc64id(icntl) @ccall libhsl.mc64id_(icntl::Ptr{Cint})::Cvoid end +function mc64id_64(icntl) + @ccall libhsl_subset_64.mc64id_64_(icntl::Ptr{Int64})::Cvoid +end + function mc64ad(job, n, ne, ip, irn, a, num, cperm, liw, iw, ldw, dw, icntl, info) @ccall libhsl.mc64ad_(job::Ref{Cint}, n::Ref{Cint}, ne::Ref{Cint}, ip::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float64}, num::Ref{Cint}, cperm::Ptr{Cint}, liw::Ref{Cint}, @@ -9,32 +13,68 @@ function mc64ad(job, n, ne, ip, irn, a, num, cperm, liw, iw, ldw, dw, icntl, inf info::Ptr{Cint})::Cvoid end +function mc64ad_64(job, n, ne, ip, irn, a, num, cperm, liw, iw, ldw, dw, icntl, info) + @ccall libhsl_subset_64.mc64ad_64_(job::Ref{Int64}, n::Ref{Int64}, ne::Ref{Int64}, ip::Ptr{Int64}, + irn::Ptr{Int64}, a::Ptr{Float64}, num::Ref{Int64}, + cperm::Ptr{Int64}, liw::Ref{Int64}, iw::Ptr{Int64}, + ldw::Ref{Int64}, dw::Ptr{Float64}, icntl::Ptr{Int64}, + info::Ptr{Int64})::Cvoid +end + function mc64bd(n, ne, ip, irn, a, iperm, num, jperm, pr, q, l, d) @ccall libhsl.mc64bd_(n::Ref{Cint}, ne::Ref{Cint}, ip::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float64}, iperm::Ptr{Cint}, num::Ref{Cint}, jperm::Ptr{Cint}, pr::Ptr{Cint}, q::Ptr{Cint}, l::Ptr{Cint}, d::Ptr{Float64})::Cvoid end +function mc64bd_64(n, ne, ip, irn, a, iperm, num, jperm, pr, q, l, d) + @ccall libhsl_subset_64.mc64bd_64_(n::Ref{Int64}, ne::Ref{Int64}, ip::Ptr{Int64}, irn::Ptr{Int64}, + a::Ptr{Float64}, iperm::Ptr{Int64}, num::Ref{Int64}, + jperm::Ptr{Int64}, pr::Ptr{Int64}, q::Ptr{Int64}, + l::Ptr{Int64}, d::Ptr{Float64})::Cvoid +end + function mc64dd(i, n, q, d, l, iway) @ccall libhsl.mc64dd_(i::Ref{Cint}, n::Ref{Cint}, q::Ptr{Cint}, d::Ptr{Float64}, l::Ptr{Cint}, iway::Ref{Cint})::Cvoid end +function mc64dd_64(i, n, q, d, l, iway) + @ccall libhsl_subset_64.mc64dd_64_(i::Ref{Int64}, n::Ref{Int64}, q::Ptr{Int64}, d::Ptr{Float64}, + l::Ptr{Int64}, iway::Ref{Int64})::Cvoid +end + function mc64ed(qlen, n, q, d, l, iway) @ccall libhsl.mc64ed_(qlen::Ref{Cint}, n::Ref{Cint}, q::Ptr{Cint}, d::Ptr{Float64}, l::Ptr{Cint}, iway::Ref{Cint})::Cvoid end +function mc64ed_64(qlen, n, q, d, l, iway) + @ccall libhsl_subset_64.mc64ed_64_(qlen::Ref{Int64}, n::Ref{Int64}, q::Ptr{Int64}, + d::Ptr{Float64}, l::Ptr{Int64}, iway::Ref{Int64})::Cvoid +end + function mc64fd(pos0, qlen, n, q, d, l, iway) @ccall libhsl.mc64fd_(pos0::Ref{Cint}, qlen::Ref{Cint}, n::Ref{Cint}, q::Ptr{Cint}, d::Ptr{Float64}, l::Ptr{Cint}, iway::Ref{Cint})::Cvoid end +function mc64fd_64(pos0, qlen, n, q, d, l, iway) + @ccall libhsl_subset_64.mc64fd_64_(pos0::Ref{Int64}, qlen::Ref{Int64}, n::Ref{Int64}, + q::Ptr{Int64}, d::Ptr{Float64}, l::Ptr{Int64}, + iway::Ref{Int64})::Cvoid +end + function mc64rd(n, ne, ip, irn, a) @ccall libhsl.mc64rd_(n::Ref{Cint}, ne::Ref{Cint}, ip::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float64})::Cvoid end +function mc64rd_64(n, ne, ip, irn, a) + @ccall libhsl_subset_64.mc64rd_64_(n::Ref{Int64}, ne::Ref{Int64}, ip::Ptr{Int64}, irn::Ptr{Int64}, + a::Ptr{Float64})::Cvoid +end + function mc64sd(n, ne, ip, irn, a, iperm, numx, w, len, lenl, lenh, fc, iw, iw4) @ccall libhsl.mc64sd_(n::Ref{Cint}, ne::Ref{Cint}, ip::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float64}, iperm::Ptr{Cint}, numx::Ref{Cint}, w::Ptr{Cint}, len::Ptr{Cint}, @@ -42,11 +82,25 @@ function mc64sd(n, ne, ip, irn, a, iperm, numx, w, len, lenl, lenh, fc, iw, iw4) iw4::Ptr{Cint})::Cvoid end +function mc64sd_64(n, ne, ip, irn, a, iperm, numx, w, len, lenl, lenh, fc, iw, iw4) + @ccall libhsl_subset_64.mc64sd_64_(n::Ref{Int64}, ne::Ref{Int64}, ip::Ptr{Int64}, irn::Ptr{Int64}, + a::Ptr{Float64}, iperm::Ptr{Int64}, numx::Ref{Int64}, + w::Ptr{Int64}, len::Ptr{Int64}, lenl::Ptr{Int64}, + lenh::Ptr{Int64}, fc::Ptr{Int64}, iw::Ptr{Int64}, + iw4::Ptr{Int64})::Cvoid +end + function mc64qd(ip, lenl, lenh, w, wlen, a, nval, val) @ccall libhsl.mc64qd_(ip::Ptr{Cint}, lenl::Ptr{Cint}, lenh::Ptr{Cint}, w::Ptr{Cint}, wlen::Ref{Cint}, a::Ptr{Float64}, nval::Ref{Cint}, val::Ref{Float64})::Cvoid end +function mc64qd_64(ip, lenl, lenh, w, wlen, a, nval, val) + @ccall libhsl_subset_64.mc64qd_64_(ip::Ptr{Int64}, lenl::Ptr{Int64}, lenh::Ptr{Int64}, + w::Ptr{Int64}, wlen::Ref{Int64}, a::Ptr{Float64}, + nval::Ref{Int64}, val::Ref{Float64})::Cvoid +end + function mc64ud(id, mod, n, irn, lirn, ip, lenc, fc, iperm, num, numx, pr, arp, cv, out) @ccall libhsl.mc64ud_(id::Ref{Cint}, mod::Ref{Cint}, n::Ref{Cint}, irn::Ptr{Cint}, lirn::Ref{Cint}, ip::Ptr{Cint}, lenc::Ptr{Cint}, fc::Ptr{Cint}, @@ -54,6 +108,14 @@ function mc64ud(id, mod, n, irn, lirn, ip, lenc, fc, iperm, num, numx, pr, arp, arp::Ptr{Cint}, cv::Ptr{Cint}, out::Ptr{Cint})::Cvoid end +function mc64ud_64(id, mod, n, irn, lirn, ip, lenc, fc, iperm, num, numx, pr, arp, cv, out) + @ccall libhsl_subset_64.mc64ud_64_(id::Ref{Int64}, mod::Ref{Int64}, n::Ref{Int64}, + irn::Ptr{Int64}, lirn::Ref{Int64}, ip::Ptr{Int64}, + lenc::Ptr{Int64}, fc::Ptr{Int64}, iperm::Ptr{Int64}, + num::Ref{Int64}, numx::Ref{Int64}, pr::Ptr{Int64}, + arp::Ptr{Int64}, cv::Ptr{Int64}, out::Ptr{Int64})::Cvoid +end + function mc64wd(n, ne, ip, irn, a, iperm, num, jperm, out, pr, q, l, u, d) @ccall libhsl.mc64wd_(n::Ref{Cint}, ne::Ref{Cint}, ip::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float64}, iperm::Ptr{Cint}, num::Ref{Cint}, jperm::Ptr{Cint}, out::Ptr{Cint}, @@ -61,10 +123,22 @@ function mc64wd(n, ne, ip, irn, a, iperm, num, jperm, out, pr, q, l, u, d) d::Ptr{Float64})::Cvoid end +function mc64wd_64(n, ne, ip, irn, a, iperm, num, jperm, out, pr, q, l, u, d) + @ccall libhsl_subset_64.mc64wd_64_(n::Ref{Int64}, ne::Ref{Int64}, ip::Ptr{Int64}, irn::Ptr{Int64}, + a::Ptr{Float64}, iperm::Ptr{Int64}, num::Ref{Int64}, + jperm::Ptr{Int64}, out::Ptr{Int64}, pr::Ptr{Int64}, + q::Ptr{Int64}, l::Ptr{Int64}, u::Ptr{Float64}, + d::Ptr{Float64})::Cvoid +end + function mc64i(icntl) @ccall libhsl.mc64i_(icntl::Ptr{Cint})::Cvoid end +function mc64i_64(icntl) + @ccall libhsl_subset_64.mc64i_64_(icntl::Ptr{Int64})::Cvoid +end + function mc64a(job, n, ne, ip, irn, a, num, cperm, liw, iw, ldw, dw, icntl, info) @ccall libhsl.mc64a_(job::Ref{Cint}, n::Ref{Cint}, ne::Ref{Cint}, ip::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float32}, num::Ref{Cint}, cperm::Ptr{Cint}, liw::Ref{Cint}, @@ -72,32 +146,68 @@ function mc64a(job, n, ne, ip, irn, a, num, cperm, liw, iw, ldw, dw, icntl, info info::Ptr{Cint})::Cvoid end +function mc64a_64(job, n, ne, ip, irn, a, num, cperm, liw, iw, ldw, dw, icntl, info) + @ccall libhsl_subset_64.mc64a_64_(job::Ref{Int64}, n::Ref{Int64}, ne::Ref{Int64}, ip::Ptr{Int64}, + irn::Ptr{Int64}, a::Ptr{Float32}, num::Ref{Int64}, + cperm::Ptr{Int64}, liw::Ref{Int64}, iw::Ptr{Int64}, + ldw::Ref{Int64}, dw::Ptr{Float32}, icntl::Ptr{Int64}, + info::Ptr{Int64})::Cvoid +end + function mc64b(n, ne, ip, irn, a, iperm, num, jperm, pr, q, l, d) @ccall libhsl.mc64b_(n::Ref{Cint}, ne::Ref{Cint}, ip::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float32}, iperm::Ptr{Cint}, num::Ref{Cint}, jperm::Ptr{Cint}, pr::Ptr{Cint}, q::Ptr{Cint}, l::Ptr{Cint}, d::Ptr{Float32})::Cvoid end +function mc64b_64(n, ne, ip, irn, a, iperm, num, jperm, pr, q, l, d) + @ccall libhsl_subset_64.mc64b_64_(n::Ref{Int64}, ne::Ref{Int64}, ip::Ptr{Int64}, irn::Ptr{Int64}, + a::Ptr{Float32}, iperm::Ptr{Int64}, num::Ref{Int64}, + jperm::Ptr{Int64}, pr::Ptr{Int64}, q::Ptr{Int64}, l::Ptr{Int64}, + d::Ptr{Float32})::Cvoid +end + function mc64d(i, n, q, d, l, iway) @ccall libhsl.mc64d_(i::Ref{Cint}, n::Ref{Cint}, q::Ptr{Cint}, d::Ptr{Float32}, l::Ptr{Cint}, iway::Ref{Cint})::Cvoid end +function mc64d_64(i, n, q, d, l, iway) + @ccall libhsl_subset_64.mc64d_64_(i::Ref{Int64}, n::Ref{Int64}, q::Ptr{Int64}, d::Ptr{Float32}, + l::Ptr{Int64}, iway::Ref{Int64})::Cvoid +end + function mc64e(qlen, n, q, d, l, iway) @ccall libhsl.mc64e_(qlen::Ref{Cint}, n::Ref{Cint}, q::Ptr{Cint}, d::Ptr{Float32}, l::Ptr{Cint}, iway::Ref{Cint})::Cvoid end +function mc64e_64(qlen, n, q, d, l, iway) + @ccall libhsl_subset_64.mc64e_64_(qlen::Ref{Int64}, n::Ref{Int64}, q::Ptr{Int64}, d::Ptr{Float32}, + l::Ptr{Int64}, iway::Ref{Int64})::Cvoid +end + function mc64f(pos0, qlen, n, q, d, l, iway) @ccall libhsl.mc64f_(pos0::Ref{Cint}, qlen::Ref{Cint}, n::Ref{Cint}, q::Ptr{Cint}, d::Ptr{Float32}, l::Ptr{Cint}, iway::Ref{Cint})::Cvoid end +function mc64f_64(pos0, qlen, n, q, d, l, iway) + @ccall libhsl_subset_64.mc64f_64_(pos0::Ref{Int64}, qlen::Ref{Int64}, n::Ref{Int64}, + q::Ptr{Int64}, d::Ptr{Float32}, l::Ptr{Int64}, + iway::Ref{Int64})::Cvoid +end + function mc64r(n, ne, ip, irn, a) @ccall libhsl.mc64r_(n::Ref{Cint}, ne::Ref{Cint}, ip::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float32})::Cvoid end +function mc64r_64(n, ne, ip, irn, a) + @ccall libhsl_subset_64.mc64r_64_(n::Ref{Int64}, ne::Ref{Int64}, ip::Ptr{Int64}, irn::Ptr{Int64}, + a::Ptr{Float32})::Cvoid +end + function mc64s(n, ne, ip, irn, a, iperm, numx, w, len, lenl, lenh, fc, iw, iw4) @ccall libhsl.mc64s_(n::Ref{Cint}, ne::Ref{Cint}, ip::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float32}, iperm::Ptr{Cint}, numx::Ref{Cint}, w::Ptr{Cint}, len::Ptr{Cint}, @@ -105,11 +215,25 @@ function mc64s(n, ne, ip, irn, a, iperm, numx, w, len, lenl, lenh, fc, iw, iw4) iw4::Ptr{Cint})::Cvoid end +function mc64s_64(n, ne, ip, irn, a, iperm, numx, w, len, lenl, lenh, fc, iw, iw4) + @ccall libhsl_subset_64.mc64s_64_(n::Ref{Int64}, ne::Ref{Int64}, ip::Ptr{Int64}, irn::Ptr{Int64}, + a::Ptr{Float32}, iperm::Ptr{Int64}, numx::Ref{Int64}, + w::Ptr{Int64}, len::Ptr{Int64}, lenl::Ptr{Int64}, + lenh::Ptr{Int64}, fc::Ptr{Int64}, iw::Ptr{Int64}, + iw4::Ptr{Int64})::Cvoid +end + function mc64q(ip, lenl, lenh, w, wlen, a, nval, val) @ccall libhsl.mc64q_(ip::Ptr{Cint}, lenl::Ptr{Cint}, lenh::Ptr{Cint}, w::Ptr{Cint}, wlen::Ref{Cint}, a::Ptr{Float32}, nval::Ref{Cint}, val::Ref{Float32})::Cvoid end +function mc64q_64(ip, lenl, lenh, w, wlen, a, nval, val) + @ccall libhsl_subset_64.mc64q_64_(ip::Ptr{Int64}, lenl::Ptr{Int64}, lenh::Ptr{Int64}, + w::Ptr{Int64}, wlen::Ref{Int64}, a::Ptr{Float32}, + nval::Ref{Int64}, val::Ref{Float32})::Cvoid +end + function mc64u(id, mod, n, irn, lirn, ip, lenc, fc, iperm, num, numx, pr, arp, cv, out) @ccall libhsl.mc64u_(id::Ref{Cint}, mod::Ref{Cint}, n::Ref{Cint}, irn::Ptr{Cint}, lirn::Ref{Cint}, ip::Ptr{Cint}, lenc::Ptr{Cint}, fc::Ptr{Cint}, iperm::Ptr{Cint}, @@ -117,9 +241,25 @@ function mc64u(id, mod, n, irn, lirn, ip, lenc, fc, iperm, num, numx, pr, arp, c cv::Ptr{Cint}, out::Ptr{Cint})::Cvoid end +function mc64u_64(id, mod, n, irn, lirn, ip, lenc, fc, iperm, num, numx, pr, arp, cv, out) + @ccall libhsl_subset_64.mc64u_64_(id::Ref{Int64}, mod::Ref{Int64}, n::Ref{Int64}, irn::Ptr{Int64}, + lirn::Ref{Int64}, ip::Ptr{Int64}, lenc::Ptr{Int64}, + fc::Ptr{Int64}, iperm::Ptr{Int64}, num::Ref{Int64}, + numx::Ref{Int64}, pr::Ptr{Int64}, arp::Ptr{Int64}, + cv::Ptr{Int64}, out::Ptr{Int64})::Cvoid +end + function mc64w(n, ne, ip, irn, a, iperm, num, jperm, out, pr, q, l, u, d) @ccall libhsl.mc64w_(n::Ref{Cint}, ne::Ref{Cint}, ip::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float32}, iperm::Ptr{Cint}, num::Ref{Cint}, jperm::Ptr{Cint}, out::Ptr{Cint}, pr::Ptr{Cint}, q::Ptr{Cint}, l::Ptr{Cint}, u::Ptr{Float32}, d::Ptr{Float32})::Cvoid end + +function mc64w_64(n, ne, ip, irn, a, iperm, num, jperm, out, pr, q, l, u, d) + @ccall libhsl_subset_64.mc64w_64_(n::Ref{Int64}, ne::Ref{Int64}, ip::Ptr{Int64}, irn::Ptr{Int64}, + a::Ptr{Float32}, iperm::Ptr{Int64}, num::Ref{Int64}, + jperm::Ptr{Int64}, out::Ptr{Int64}, pr::Ptr{Int64}, + q::Ptr{Int64}, l::Ptr{Int64}, u::Ptr{Float32}, + d::Ptr{Float32})::Cvoid +end diff --git a/src/Fortran/mc71.jl b/src/Fortran/mc71.jl index acd92e3..e2eaaca 100644 --- a/src/Fortran/mc71.jl +++ b/src/Fortran/mc71.jl @@ -3,7 +3,19 @@ function mc71ad(n, kase, x, est, w, iw, keep) w::Ptr{Float64}, iw::Ptr{Cint}, keep::Ptr{Cint})::Cvoid end +function mc71ad_64(n, kase, x, est, w, iw, keep) + @ccall libhsl_subset_64.mc71ad_64_(n::Ref{Int64}, kase::Ref{Int64}, x::Ptr{Float64}, + est::Ref{Float64}, w::Ptr{Float64}, iw::Ptr{Int64}, + keep::Ptr{Int64})::Cvoid +end + function mc71a(n, kase, x, est, w, iw, keep) @ccall libhsl.mc71a_(n::Ref{Cint}, kase::Ref{Cint}, x::Ptr{Float32}, est::Ref{Float32}, w::Ptr{Float32}, iw::Ptr{Cint}, keep::Ptr{Cint})::Cvoid end + +function mc71a_64(n, kase, x, est, w, iw, keep) + @ccall libhsl_subset_64.mc71a_64_(n::Ref{Int64}, kase::Ref{Int64}, x::Ptr{Float32}, + est::Ref{Float32}, w::Ptr{Float32}, iw::Ptr{Int64}, + keep::Ptr{Int64})::Cvoid +end diff --git a/src/Fortran/mc77.jl b/src/Fortran/mc77.jl index 903fbdf..674cea7 100644 --- a/src/Fortran/mc77.jl +++ b/src/Fortran/mc77.jl @@ -117,6 +117,10 @@ function mc77id(icntl, cntl) @ccall libhsl.mc77id_(icntl::Ptr{Cint}, cntl::Ptr{Float64})::Cvoid end +function mc77id_64(icntl, cntl) + @ccall libhsl_subset_64.mc77id_64_(icntl::Ptr{Int64}, cntl::Ptr{Float64})::Cvoid +end + function mc77ad(job, m, n, nnz, jcst, irn, a, iw, liw, dw, ldw, icntl, cntl, info, rinfo) @ccall libhsl.mc77ad_(job::Ref{Cint}, m::Ref{Cint}, n::Ref{Cint}, nnz::Ref{Cint}, jcst::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float64}, iw::Ptr{Cint}, liw::Ref{Cint}, @@ -124,6 +128,14 @@ function mc77ad(job, m, n, nnz, jcst, irn, a, iw, liw, dw, ldw, icntl, cntl, inf info::Ptr{Cint}, rinfo::Ptr{Float64})::Cvoid end +function mc77ad_64(job, m, n, nnz, jcst, irn, a, iw, liw, dw, ldw, icntl, cntl, info, rinfo) + @ccall libhsl_subset_64.mc77ad_64_(job::Ref{Int64}, m::Ref{Int64}, n::Ref{Int64}, nnz::Ref{Int64}, + jcst::Ptr{Int64}, irn::Ptr{Int64}, a::Ptr{Float64}, + iw::Ptr{Int64}, liw::Ref{Int64}, dw::Ptr{Float64}, + ldw::Ref{Int64}, icntl::Ptr{Int64}, cntl::Ptr{Float64}, + info::Ptr{Int64}, rinfo::Ptr{Float64})::Cvoid +end + function mc77nd(m, n, nnz, jcst, irn, a, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, info) @ccall libhsl.mc77nd_(m::Ref{Cint}, n::Ref{Cint}, nnz::Ref{Cint}, jcst::Ptr{Cint}, irn::Ptr{Cint}, @@ -133,6 +145,16 @@ function mc77nd(m, n, nnz, jcst, irn, a, d, e, check, thresh, err, maxit, niter, info::Ref{Cint})::Cvoid end +function mc77nd_64(m, n, nnz, jcst, irn, a, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, + info) + @ccall libhsl_subset_64.mc77nd_64_(m::Ref{Int64}, n::Ref{Int64}, nnz::Ref{Int64}, + jcst::Ptr{Int64}, irn::Ptr{Int64}, a::Ptr{Float64}, + d::Ptr{Float64}, e::Ptr{Float64}, check::Ref{Int64}, + thresh::Ref{Float64}, err::Ptr{Float64}, maxit::Ref{Int64}, + niter::Ref{Int64}, iw::Ptr{Int64}, jw::Ptr{Int64}, + dw::Ptr{Float64}, ew::Ptr{Float64}, info::Ref{Int64})::Cvoid +end + function mc77od(m, n, nnz, jcst, irn, a, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, info) @ccall libhsl.mc77od_(m::Ref{Cint}, n::Ref{Cint}, nnz::Ref{Cint}, jcst::Ptr{Cint}, irn::Ptr{Cint}, @@ -142,6 +164,16 @@ function mc77od(m, n, nnz, jcst, irn, a, d, e, check, thresh, err, maxit, niter, info::Ref{Cint})::Cvoid end +function mc77od_64(m, n, nnz, jcst, irn, a, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, + info) + @ccall libhsl_subset_64.mc77od_64_(m::Ref{Int64}, n::Ref{Int64}, nnz::Ref{Int64}, + jcst::Ptr{Int64}, irn::Ptr{Int64}, a::Ptr{Float64}, + d::Ptr{Float64}, e::Ptr{Float64}, check::Ref{Int64}, + thresh::Ref{Float64}, err::Ptr{Float64}, maxit::Ref{Int64}, + niter::Ref{Int64}, iw::Ptr{Int64}, jw::Ptr{Int64}, + dw::Ptr{Float64}, ew::Ptr{Float64}, info::Ref{Int64})::Cvoid +end + function mc77pd(n, nnz, jcst, irn, a, de, check, thresh, err, maxit, niter, ijw, dew, info) @ccall libhsl.mc77pd_(n::Ref{Cint}, nnz::Ref{Cint}, jcst::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float64}, de::Ptr{Float64}, check::Ref{Cint}, thresh::Ref{Float64}, @@ -149,6 +181,14 @@ function mc77pd(n, nnz, jcst, irn, a, de, check, thresh, err, maxit, niter, ijw, dew::Ptr{Float64}, info::Ref{Cint})::Cvoid end +function mc77pd_64(n, nnz, jcst, irn, a, de, check, thresh, err, maxit, niter, ijw, dew, info) + @ccall libhsl_subset_64.mc77pd_64_(n::Ref{Int64}, nnz::Ref{Int64}, jcst::Ptr{Int64}, + irn::Ptr{Int64}, a::Ptr{Float64}, de::Ptr{Float64}, + check::Ref{Int64}, thresh::Ref{Float64}, err::Ref{Float64}, + maxit::Ref{Int64}, niter::Ref{Int64}, ijw::Ptr{Int64}, + dew::Ptr{Float64}, info::Ref{Int64})::Cvoid +end + function mc77qd(n, nnz, jcst, irn, a, de, check, thresh, err, maxit, niter, ijw, dew, info) @ccall libhsl.mc77qd_(n::Ref{Cint}, nnz::Ref{Cint}, jcst::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float64}, de::Ptr{Float64}, check::Ref{Cint}, thresh::Ref{Float64}, @@ -156,6 +196,14 @@ function mc77qd(n, nnz, jcst, irn, a, de, check, thresh, err, maxit, niter, ijw, dew::Ptr{Float64}, info::Ref{Cint})::Cvoid end +function mc77qd_64(n, nnz, jcst, irn, a, de, check, thresh, err, maxit, niter, ijw, dew, info) + @ccall libhsl_subset_64.mc77qd_64_(n::Ref{Int64}, nnz::Ref{Int64}, jcst::Ptr{Int64}, + irn::Ptr{Int64}, a::Ptr{Float64}, de::Ptr{Float64}, + check::Ref{Int64}, thresh::Ref{Float64}, err::Ref{Float64}, + maxit::Ref{Int64}, niter::Ref{Int64}, ijw::Ptr{Int64}, + dew::Ptr{Float64}, info::Ref{Int64})::Cvoid +end + function mc77bd(job, m, n, nnz, irn, jcn, a, iw, liw, dw, ldw, icntl, cntl, info, rinfo) @ccall libhsl.mc77bd_(job::Ref{Cint}, m::Ref{Cint}, n::Ref{Cint}, nnz::Ref{Cint}, irn::Ptr{Cint}, jcn::Ptr{Cint}, a::Ptr{Float64}, iw::Ptr{Cint}, liw::Ref{Cint}, @@ -163,6 +211,14 @@ function mc77bd(job, m, n, nnz, irn, jcn, a, iw, liw, dw, ldw, icntl, cntl, info info::Ptr{Cint}, rinfo::Ptr{Float64})::Cvoid end +function mc77bd_64(job, m, n, nnz, irn, jcn, a, iw, liw, dw, ldw, icntl, cntl, info, rinfo) + @ccall libhsl_subset_64.mc77bd_64_(job::Ref{Int64}, m::Ref{Int64}, n::Ref{Int64}, nnz::Ref{Int64}, + irn::Ptr{Int64}, jcn::Ptr{Int64}, a::Ptr{Float64}, + iw::Ptr{Int64}, liw::Ref{Int64}, dw::Ptr{Float64}, + ldw::Ref{Int64}, icntl::Ptr{Int64}, cntl::Ptr{Float64}, + info::Ptr{Int64}, rinfo::Ptr{Float64})::Cvoid +end + function mc77rd(m, n, nnz, jcn, irn, a, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, info) @ccall libhsl.mc77rd_(m::Ref{Cint}, n::Ref{Cint}, nnz::Ref{Cint}, jcn::Ptr{Cint}, irn::Ptr{Cint}, @@ -172,6 +228,16 @@ function mc77rd(m, n, nnz, jcn, irn, a, d, e, check, thresh, err, maxit, niter, info::Ref{Cint})::Cvoid end +function mc77rd_64(m, n, nnz, jcn, irn, a, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, + info) + @ccall libhsl_subset_64.mc77rd_64_(m::Ref{Int64}, n::Ref{Int64}, nnz::Ref{Int64}, jcn::Ptr{Int64}, + irn::Ptr{Int64}, a::Ptr{Float64}, d::Ptr{Float64}, + e::Ptr{Float64}, check::Ref{Int64}, thresh::Ref{Float64}, + err::Ptr{Float64}, maxit::Ref{Int64}, niter::Ref{Int64}, + iw::Ptr{Int64}, jw::Ptr{Int64}, dw::Ptr{Float64}, + ew::Ptr{Float64}, info::Ref{Int64})::Cvoid +end + function mc77sd(m, n, nnz, jcn, irn, a, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, info) @ccall libhsl.mc77sd_(m::Ref{Cint}, n::Ref{Cint}, nnz::Ref{Cint}, jcn::Ptr{Cint}, irn::Ptr{Cint}, @@ -181,6 +247,16 @@ function mc77sd(m, n, nnz, jcn, irn, a, d, e, check, thresh, err, maxit, niter, info::Ref{Cint})::Cvoid end +function mc77sd_64(m, n, nnz, jcn, irn, a, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, + info) + @ccall libhsl_subset_64.mc77sd_64_(m::Ref{Int64}, n::Ref{Int64}, nnz::Ref{Int64}, jcn::Ptr{Int64}, + irn::Ptr{Int64}, a::Ptr{Float64}, d::Ptr{Float64}, + e::Ptr{Float64}, check::Ref{Int64}, thresh::Ref{Float64}, + err::Ptr{Float64}, maxit::Ref{Int64}, niter::Ref{Int64}, + iw::Ptr{Int64}, jw::Ptr{Int64}, dw::Ptr{Float64}, + ew::Ptr{Float64}, info::Ref{Int64})::Cvoid +end + function mc77td(n, nnz, jcn, irn, a, de, check, thresh, err, maxit, niter, ijw, dew, info) @ccall libhsl.mc77td_(n::Ref{Cint}, nnz::Ref{Cint}, jcn::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float64}, de::Ptr{Float64}, check::Ref{Cint}, thresh::Ref{Float64}, @@ -188,6 +264,14 @@ function mc77td(n, nnz, jcn, irn, a, de, check, thresh, err, maxit, niter, ijw, dew::Ptr{Float64}, info::Ref{Cint})::Cvoid end +function mc77td_64(n, nnz, jcn, irn, a, de, check, thresh, err, maxit, niter, ijw, dew, info) + @ccall libhsl_subset_64.mc77td_64_(n::Ref{Int64}, nnz::Ref{Int64}, jcn::Ptr{Int64}, + irn::Ptr{Int64}, a::Ptr{Float64}, de::Ptr{Float64}, + check::Ref{Int64}, thresh::Ref{Float64}, err::Ref{Float64}, + maxit::Ref{Int64}, niter::Ref{Int64}, ijw::Ptr{Int64}, + dew::Ptr{Float64}, info::Ref{Int64})::Cvoid +end + function mc77ud(n, nnz, jcn, irn, a, de, check, thresh, err, maxit, niter, ijw, dew, info) @ccall libhsl.mc77ud_(n::Ref{Cint}, nnz::Ref{Cint}, jcn::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float64}, de::Ptr{Float64}, check::Ref{Cint}, thresh::Ref{Float64}, @@ -195,6 +279,14 @@ function mc77ud(n, nnz, jcn, irn, a, de, check, thresh, err, maxit, niter, ijw, dew::Ptr{Float64}, info::Ref{Cint})::Cvoid end +function mc77ud_64(n, nnz, jcn, irn, a, de, check, thresh, err, maxit, niter, ijw, dew, info) + @ccall libhsl_subset_64.mc77ud_64_(n::Ref{Int64}, nnz::Ref{Int64}, jcn::Ptr{Int64}, + irn::Ptr{Int64}, a::Ptr{Float64}, de::Ptr{Float64}, + check::Ref{Int64}, thresh::Ref{Float64}, err::Ref{Float64}, + maxit::Ref{Int64}, niter::Ref{Int64}, ijw::Ptr{Int64}, + dew::Ptr{Float64}, info::Ref{Int64})::Cvoid +end + function mc77cd(job, m, n, a, lda, iw, liw, dw, ldw, icntl, cntl, info, rinfo) @ccall libhsl.mc77cd_(job::Ref{Cint}, m::Ref{Cint}, n::Ref{Cint}, a::Ptr{Float64}, lda::Ref{Cint}, iw::Ptr{Cint}, liw::Ref{Cint}, dw::Ptr{Float64}, ldw::Ref{Cint}, @@ -202,6 +294,14 @@ function mc77cd(job, m, n, a, lda, iw, liw, dw, ldw, icntl, cntl, info, rinfo) rinfo::Ptr{Float64})::Cvoid end +function mc77cd_64(job, m, n, a, lda, iw, liw, dw, ldw, icntl, cntl, info, rinfo) + @ccall libhsl_subset_64.mc77cd_64_(job::Ref{Int64}, m::Ref{Int64}, n::Ref{Int64}, a::Ptr{Float64}, + lda::Ref{Int64}, iw::Ptr{Int64}, liw::Ref{Int64}, + dw::Ptr{Float64}, ldw::Ref{Int64}, icntl::Ptr{Int64}, + cntl::Ptr{Float64}, info::Ptr{Int64}, + rinfo::Ptr{Float64})::Cvoid +end + function mc77jd(m, n, a, lda, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, info) @ccall libhsl.mc77jd_(m::Ref{Cint}, n::Ref{Cint}, a::Ptr{Float64}, lda::Ref{Cint}, d::Ptr{Float64}, e::Ptr{Float64}, check::Ref{Cint}, thresh::Ref{Float64}, @@ -209,6 +309,14 @@ function mc77jd(m, n, a, lda, d, e, check, thresh, err, maxit, niter, iw, jw, dw jw::Ptr{Cint}, dw::Ptr{Float64}, ew::Ptr{Float64}, info::Ref{Cint})::Cvoid end +function mc77jd_64(m, n, a, lda, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, info) + @ccall libhsl_subset_64.mc77jd_64_(m::Ref{Int64}, n::Ref{Int64}, a::Ptr{Float64}, lda::Ref{Int64}, + d::Ptr{Float64}, e::Ptr{Float64}, check::Ref{Int64}, + thresh::Ref{Float64}, err::Ptr{Float64}, maxit::Ref{Int64}, + niter::Ref{Int64}, iw::Ptr{Int64}, jw::Ptr{Int64}, + dw::Ptr{Float64}, ew::Ptr{Float64}, info::Ref{Int64})::Cvoid +end + function mc77kd(m, n, a, lda, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, info) @ccall libhsl.mc77kd_(m::Ref{Cint}, n::Ref{Cint}, a::Ptr{Float64}, lda::Ref{Cint}, d::Ptr{Float64}, e::Ptr{Float64}, check::Ref{Cint}, thresh::Ref{Float64}, @@ -216,22 +324,48 @@ function mc77kd(m, n, a, lda, d, e, check, thresh, err, maxit, niter, iw, jw, dw jw::Ptr{Cint}, dw::Ptr{Float64}, ew::Ptr{Float64}, info::Ref{Cint})::Cvoid end +function mc77kd_64(m, n, a, lda, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, info) + @ccall libhsl_subset_64.mc77kd_64_(m::Ref{Int64}, n::Ref{Int64}, a::Ptr{Float64}, lda::Ref{Int64}, + d::Ptr{Float64}, e::Ptr{Float64}, check::Ref{Int64}, + thresh::Ref{Float64}, err::Ptr{Float64}, maxit::Ref{Int64}, + niter::Ref{Int64}, iw::Ptr{Int64}, jw::Ptr{Int64}, + dw::Ptr{Float64}, ew::Ptr{Float64}, info::Ref{Int64})::Cvoid +end + function mc77ld(n, a, de, check, thresh, err, maxit, niter, ijw, dew, info) @ccall libhsl.mc77ld_(n::Ref{Cint}, a::Ptr{Float64}, de::Ptr{Float64}, check::Ref{Cint}, thresh::Ref{Float64}, err::Ref{Float64}, maxit::Ref{Cint}, niter::Ref{Cint}, ijw::Ptr{Cint}, dew::Ptr{Float64}, info::Ref{Cint})::Cvoid end +function mc77ld_64(n, a, de, check, thresh, err, maxit, niter, ijw, dew, info) + @ccall libhsl_subset_64.mc77ld_64_(n::Ref{Int64}, a::Ptr{Float64}, de::Ptr{Float64}, + check::Ref{Int64}, thresh::Ref{Float64}, err::Ref{Float64}, + maxit::Ref{Int64}, niter::Ref{Int64}, ijw::Ptr{Int64}, + dew::Ptr{Float64}, info::Ref{Int64})::Cvoid +end + function mc77md(n, a, de, check, thresh, err, maxit, niter, ijw, dew, info) @ccall libhsl.mc77md_(n::Ref{Cint}, a::Ptr{Float64}, de::Ptr{Float64}, check::Ref{Cint}, thresh::Ref{Float64}, err::Ref{Float64}, maxit::Ref{Cint}, niter::Ref{Cint}, ijw::Ptr{Cint}, dew::Ptr{Float64}, info::Ref{Cint})::Cvoid end +function mc77md_64(n, a, de, check, thresh, err, maxit, niter, ijw, dew, info) + @ccall libhsl_subset_64.mc77md_64_(n::Ref{Int64}, a::Ptr{Float64}, de::Ptr{Float64}, + check::Ref{Int64}, thresh::Ref{Float64}, err::Ref{Float64}, + maxit::Ref{Int64}, niter::Ref{Int64}, ijw::Ptr{Int64}, + dew::Ptr{Float64}, info::Ref{Int64})::Cvoid +end + function mc77i(icntl, cntl) @ccall libhsl.mc77i_(icntl::Ptr{Cint}, cntl::Ptr{Float32})::Cvoid end +function mc77i_64(icntl, cntl) + @ccall libhsl_subset_64.mc77i_64_(icntl::Ptr{Int64}, cntl::Ptr{Float32})::Cvoid +end + function mc77a(job, m, n, nnz, jcst, irn, a, iw, liw, dw, ldw, icntl, cntl, info, rinfo) @ccall libhsl.mc77a_(job::Ref{Cint}, m::Ref{Cint}, n::Ref{Cint}, nnz::Ref{Cint}, jcst::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float32}, iw::Ptr{Cint}, liw::Ref{Cint}, @@ -239,6 +373,14 @@ function mc77a(job, m, n, nnz, jcst, irn, a, iw, liw, dw, ldw, icntl, cntl, info info::Ptr{Cint}, rinfo::Ptr{Float32})::Cvoid end +function mc77a_64(job, m, n, nnz, jcst, irn, a, iw, liw, dw, ldw, icntl, cntl, info, rinfo) + @ccall libhsl_subset_64.mc77a_64_(job::Ref{Int64}, m::Ref{Int64}, n::Ref{Int64}, nnz::Ref{Int64}, + jcst::Ptr{Int64}, irn::Ptr{Int64}, a::Ptr{Float32}, + iw::Ptr{Int64}, liw::Ref{Int64}, dw::Ptr{Float32}, + ldw::Ref{Int64}, icntl::Ptr{Int64}, cntl::Ptr{Float32}, + info::Ptr{Int64}, rinfo::Ptr{Float32})::Cvoid +end + function mc77n(m, n, nnz, jcst, irn, a, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, info) @ccall libhsl.mc77n_(m::Ref{Cint}, n::Ref{Cint}, nnz::Ref{Cint}, jcst::Ptr{Cint}, irn::Ptr{Cint}, @@ -248,6 +390,16 @@ function mc77n(m, n, nnz, jcst, irn, a, d, e, check, thresh, err, maxit, niter, info::Ref{Cint})::Cvoid end +function mc77n_64(m, n, nnz, jcst, irn, a, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, + info) + @ccall libhsl_subset_64.mc77n_64_(m::Ref{Int64}, n::Ref{Int64}, nnz::Ref{Int64}, jcst::Ptr{Int64}, + irn::Ptr{Int64}, a::Ptr{Float32}, d::Ptr{Float32}, + e::Ptr{Float32}, check::Ref{Int64}, thresh::Ref{Float32}, + err::Ptr{Float32}, maxit::Ref{Int64}, niter::Ref{Int64}, + iw::Ptr{Int64}, jw::Ptr{Int64}, dw::Ptr{Float32}, + ew::Ptr{Float32}, info::Ref{Int64})::Cvoid +end + function mc77o(m, n, nnz, jcst, irn, a, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, info) @ccall libhsl.mc77o_(m::Ref{Cint}, n::Ref{Cint}, nnz::Ref{Cint}, jcst::Ptr{Cint}, irn::Ptr{Cint}, @@ -257,6 +409,16 @@ function mc77o(m, n, nnz, jcst, irn, a, d, e, check, thresh, err, maxit, niter, info::Ref{Cint})::Cvoid end +function mc77o_64(m, n, nnz, jcst, irn, a, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, + info) + @ccall libhsl_subset_64.mc77o_64_(m::Ref{Int64}, n::Ref{Int64}, nnz::Ref{Int64}, jcst::Ptr{Int64}, + irn::Ptr{Int64}, a::Ptr{Float32}, d::Ptr{Float32}, + e::Ptr{Float32}, check::Ref{Int64}, thresh::Ref{Float32}, + err::Ptr{Float32}, maxit::Ref{Int64}, niter::Ref{Int64}, + iw::Ptr{Int64}, jw::Ptr{Int64}, dw::Ptr{Float32}, + ew::Ptr{Float32}, info::Ref{Int64})::Cvoid +end + function mc77p(n, nnz, jcst, irn, a, de, check, thresh, err, maxit, niter, ijw, dew, info) @ccall libhsl.mc77p_(n::Ref{Cint}, nnz::Ref{Cint}, jcst::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float32}, de::Ptr{Float32}, check::Ref{Cint}, thresh::Ref{Float32}, @@ -264,6 +426,14 @@ function mc77p(n, nnz, jcst, irn, a, de, check, thresh, err, maxit, niter, ijw, dew::Ptr{Float32}, info::Ref{Cint})::Cvoid end +function mc77p_64(n, nnz, jcst, irn, a, de, check, thresh, err, maxit, niter, ijw, dew, info) + @ccall libhsl_subset_64.mc77p_64_(n::Ref{Int64}, nnz::Ref{Int64}, jcst::Ptr{Int64}, + irn::Ptr{Int64}, a::Ptr{Float32}, de::Ptr{Float32}, + check::Ref{Int64}, thresh::Ref{Float32}, err::Ref{Float32}, + maxit::Ref{Int64}, niter::Ref{Int64}, ijw::Ptr{Int64}, + dew::Ptr{Float32}, info::Ref{Int64})::Cvoid +end + function mc77q(n, nnz, jcst, irn, a, de, check, thresh, err, maxit, niter, ijw, dew, info) @ccall libhsl.mc77q_(n::Ref{Cint}, nnz::Ref{Cint}, jcst::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float32}, de::Ptr{Float32}, check::Ref{Cint}, thresh::Ref{Float32}, @@ -271,6 +441,14 @@ function mc77q(n, nnz, jcst, irn, a, de, check, thresh, err, maxit, niter, ijw, dew::Ptr{Float32}, info::Ref{Cint})::Cvoid end +function mc77q_64(n, nnz, jcst, irn, a, de, check, thresh, err, maxit, niter, ijw, dew, info) + @ccall libhsl_subset_64.mc77q_64_(n::Ref{Int64}, nnz::Ref{Int64}, jcst::Ptr{Int64}, + irn::Ptr{Int64}, a::Ptr{Float32}, de::Ptr{Float32}, + check::Ref{Int64}, thresh::Ref{Float32}, err::Ref{Float32}, + maxit::Ref{Int64}, niter::Ref{Int64}, ijw::Ptr{Int64}, + dew::Ptr{Float32}, info::Ref{Int64})::Cvoid +end + function mc77b(job, m, n, nnz, irn, jcn, a, iw, liw, dw, ldw, icntl, cntl, info, rinfo) @ccall libhsl.mc77b_(job::Ref{Cint}, m::Ref{Cint}, n::Ref{Cint}, nnz::Ref{Cint}, irn::Ptr{Cint}, jcn::Ptr{Cint}, a::Ptr{Float32}, iw::Ptr{Cint}, liw::Ref{Cint}, @@ -278,6 +456,14 @@ function mc77b(job, m, n, nnz, irn, jcn, a, iw, liw, dw, ldw, icntl, cntl, info, info::Ptr{Cint}, rinfo::Ptr{Float32})::Cvoid end +function mc77b_64(job, m, n, nnz, irn, jcn, a, iw, liw, dw, ldw, icntl, cntl, info, rinfo) + @ccall libhsl_subset_64.mc77b_64_(job::Ref{Int64}, m::Ref{Int64}, n::Ref{Int64}, nnz::Ref{Int64}, + irn::Ptr{Int64}, jcn::Ptr{Int64}, a::Ptr{Float32}, + iw::Ptr{Int64}, liw::Ref{Int64}, dw::Ptr{Float32}, + ldw::Ref{Int64}, icntl::Ptr{Int64}, cntl::Ptr{Float32}, + info::Ptr{Int64}, rinfo::Ptr{Float32})::Cvoid +end + function mc77r(m, n, nnz, jcn, irn, a, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, info) @ccall libhsl.mc77r_(m::Ref{Cint}, n::Ref{Cint}, nnz::Ref{Cint}, jcn::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float32}, d::Ptr{Float32}, e::Ptr{Float32}, check::Ref{Cint}, @@ -286,6 +472,16 @@ function mc77r(m, n, nnz, jcn, irn, a, d, e, check, thresh, err, maxit, niter, i info::Ref{Cint})::Cvoid end +function mc77r_64(m, n, nnz, jcn, irn, a, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, + info) + @ccall libhsl_subset_64.mc77r_64_(m::Ref{Int64}, n::Ref{Int64}, nnz::Ref{Int64}, jcn::Ptr{Int64}, + irn::Ptr{Int64}, a::Ptr{Float32}, d::Ptr{Float32}, + e::Ptr{Float32}, check::Ref{Int64}, thresh::Ref{Float32}, + err::Ptr{Float32}, maxit::Ref{Int64}, niter::Ref{Int64}, + iw::Ptr{Int64}, jw::Ptr{Int64}, dw::Ptr{Float32}, + ew::Ptr{Float32}, info::Ref{Int64})::Cvoid +end + function mc77s(m, n, nnz, jcn, irn, a, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, info) @ccall libhsl.mc77s_(m::Ref{Cint}, n::Ref{Cint}, nnz::Ref{Cint}, jcn::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float32}, d::Ptr{Float32}, e::Ptr{Float32}, check::Ref{Cint}, @@ -294,6 +490,16 @@ function mc77s(m, n, nnz, jcn, irn, a, d, e, check, thresh, err, maxit, niter, i info::Ref{Cint})::Cvoid end +function mc77s_64(m, n, nnz, jcn, irn, a, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, + info) + @ccall libhsl_subset_64.mc77s_64_(m::Ref{Int64}, n::Ref{Int64}, nnz::Ref{Int64}, jcn::Ptr{Int64}, + irn::Ptr{Int64}, a::Ptr{Float32}, d::Ptr{Float32}, + e::Ptr{Float32}, check::Ref{Int64}, thresh::Ref{Float32}, + err::Ptr{Float32}, maxit::Ref{Int64}, niter::Ref{Int64}, + iw::Ptr{Int64}, jw::Ptr{Int64}, dw::Ptr{Float32}, + ew::Ptr{Float32}, info::Ref{Int64})::Cvoid +end + function mc77t(n, nnz, jcn, irn, a, de, check, thresh, err, maxit, niter, ijw, dew, info) @ccall libhsl.mc77t_(n::Ref{Cint}, nnz::Ref{Cint}, jcn::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float32}, de::Ptr{Float32}, check::Ref{Cint}, thresh::Ref{Float32}, @@ -301,6 +507,14 @@ function mc77t(n, nnz, jcn, irn, a, de, check, thresh, err, maxit, niter, ijw, d dew::Ptr{Float32}, info::Ref{Cint})::Cvoid end +function mc77t_64(n, nnz, jcn, irn, a, de, check, thresh, err, maxit, niter, ijw, dew, info) + @ccall libhsl_subset_64.mc77t_64_(n::Ref{Int64}, nnz::Ref{Int64}, jcn::Ptr{Int64}, + irn::Ptr{Int64}, a::Ptr{Float32}, de::Ptr{Float32}, + check::Ref{Int64}, thresh::Ref{Float32}, err::Ref{Float32}, + maxit::Ref{Int64}, niter::Ref{Int64}, ijw::Ptr{Int64}, + dew::Ptr{Float32}, info::Ref{Int64})::Cvoid +end + function mc77u(n, nnz, jcn, irn, a, de, check, thresh, err, maxit, niter, ijw, dew, info) @ccall libhsl.mc77u_(n::Ref{Cint}, nnz::Ref{Cint}, jcn::Ptr{Cint}, irn::Ptr{Cint}, a::Ptr{Float32}, de::Ptr{Float32}, check::Ref{Cint}, thresh::Ref{Float32}, @@ -308,6 +522,14 @@ function mc77u(n, nnz, jcn, irn, a, de, check, thresh, err, maxit, niter, ijw, d dew::Ptr{Float32}, info::Ref{Cint})::Cvoid end +function mc77u_64(n, nnz, jcn, irn, a, de, check, thresh, err, maxit, niter, ijw, dew, info) + @ccall libhsl_subset_64.mc77u_64_(n::Ref{Int64}, nnz::Ref{Int64}, jcn::Ptr{Int64}, + irn::Ptr{Int64}, a::Ptr{Float32}, de::Ptr{Float32}, + check::Ref{Int64}, thresh::Ref{Float32}, err::Ref{Float32}, + maxit::Ref{Int64}, niter::Ref{Int64}, ijw::Ptr{Int64}, + dew::Ptr{Float32}, info::Ref{Int64})::Cvoid +end + function mc77c(job, m, n, a, lda, iw, liw, dw, ldw, icntl, cntl, info, rinfo) @ccall libhsl.mc77c_(job::Ref{Cint}, m::Ref{Cint}, n::Ref{Cint}, a::Ptr{Float32}, lda::Ref{Cint}, iw::Ptr{Cint}, liw::Ref{Cint}, dw::Ptr{Float32}, ldw::Ref{Cint}, @@ -315,6 +537,14 @@ function mc77c(job, m, n, a, lda, iw, liw, dw, ldw, icntl, cntl, info, rinfo) rinfo::Ptr{Float32})::Cvoid end +function mc77c_64(job, m, n, a, lda, iw, liw, dw, ldw, icntl, cntl, info, rinfo) + @ccall libhsl_subset_64.mc77c_64_(job::Ref{Int64}, m::Ref{Int64}, n::Ref{Int64}, a::Ptr{Float32}, + lda::Ref{Int64}, iw::Ptr{Int64}, liw::Ref{Int64}, + dw::Ptr{Float32}, ldw::Ref{Int64}, icntl::Ptr{Int64}, + cntl::Ptr{Float32}, info::Ptr{Int64}, + rinfo::Ptr{Float32})::Cvoid +end + function mc77j(m, n, a, lda, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, info) @ccall libhsl.mc77j_(m::Ref{Cint}, n::Ref{Cint}, a::Ptr{Float32}, lda::Ref{Cint}, d::Ptr{Float32}, e::Ptr{Float32}, check::Ref{Cint}, thresh::Ref{Float32}, err::Ptr{Float32}, @@ -322,6 +552,14 @@ function mc77j(m, n, a, lda, d, e, check, thresh, err, maxit, niter, iw, jw, dw, dw::Ptr{Float32}, ew::Ptr{Float32}, info::Ref{Cint})::Cvoid end +function mc77j_64(m, n, a, lda, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, info) + @ccall libhsl_subset_64.mc77j_64_(m::Ref{Int64}, n::Ref{Int64}, a::Ptr{Float32}, lda::Ref{Int64}, + d::Ptr{Float32}, e::Ptr{Float32}, check::Ref{Int64}, + thresh::Ref{Float32}, err::Ptr{Float32}, maxit::Ref{Int64}, + niter::Ref{Int64}, iw::Ptr{Int64}, jw::Ptr{Int64}, + dw::Ptr{Float32}, ew::Ptr{Float32}, info::Ref{Int64})::Cvoid +end + function mc77k(m, n, a, lda, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, info) @ccall libhsl.mc77k_(m::Ref{Cint}, n::Ref{Cint}, a::Ptr{Float32}, lda::Ref{Cint}, d::Ptr{Float32}, e::Ptr{Float32}, check::Ref{Cint}, thresh::Ref{Float32}, err::Ptr{Float32}, @@ -329,18 +567,40 @@ function mc77k(m, n, a, lda, d, e, check, thresh, err, maxit, niter, iw, jw, dw, dw::Ptr{Float32}, ew::Ptr{Float32}, info::Ref{Cint})::Cvoid end +function mc77k_64(m, n, a, lda, d, e, check, thresh, err, maxit, niter, iw, jw, dw, ew, info) + @ccall libhsl_subset_64.mc77k_64_(m::Ref{Int64}, n::Ref{Int64}, a::Ptr{Float32}, lda::Ref{Int64}, + d::Ptr{Float32}, e::Ptr{Float32}, check::Ref{Int64}, + thresh::Ref{Float32}, err::Ptr{Float32}, maxit::Ref{Int64}, + niter::Ref{Int64}, iw::Ptr{Int64}, jw::Ptr{Int64}, + dw::Ptr{Float32}, ew::Ptr{Float32}, info::Ref{Int64})::Cvoid +end + function mc77l(n, a, de, check, thresh, err, maxit, niter, ijw, dew, info) @ccall libhsl.mc77l_(n::Ref{Cint}, a::Ptr{Float32}, de::Ptr{Float32}, check::Ref{Cint}, thresh::Ref{Float32}, err::Ref{Float32}, maxit::Ref{Cint}, niter::Ref{Cint}, ijw::Ptr{Cint}, dew::Ptr{Float32}, info::Ref{Cint})::Cvoid end +function mc77l_64(n, a, de, check, thresh, err, maxit, niter, ijw, dew, info) + @ccall libhsl_subset_64.mc77l_64_(n::Ref{Int64}, a::Ptr{Float32}, de::Ptr{Float32}, + check::Ref{Int64}, thresh::Ref{Float32}, err::Ref{Float32}, + maxit::Ref{Int64}, niter::Ref{Int64}, ijw::Ptr{Int64}, + dew::Ptr{Float32}, info::Ref{Int64})::Cvoid +end + function mc77m(n, a, de, check, thresh, err, maxit, niter, ijw, dew, info) @ccall libhsl.mc77m_(n::Ref{Cint}, a::Ptr{Float32}, de::Ptr{Float32}, check::Ref{Cint}, thresh::Ref{Float32}, err::Ref{Float32}, maxit::Ref{Cint}, niter::Ref{Cint}, ijw::Ptr{Cint}, dew::Ptr{Float32}, info::Ref{Cint})::Cvoid end +function mc77m_64(n, a, de, check, thresh, err, maxit, niter, ijw, dew, info) + @ccall libhsl_subset_64.mc77m_64_(n::Ref{Int64}, a::Ptr{Float32}, de::Ptr{Float32}, + check::Ref{Int64}, thresh::Ref{Float32}, err::Ref{Float32}, + maxit::Ref{Int64}, niter::Ref{Int64}, ijw::Ptr{Int64}, + dew::Ptr{Float32}, info::Ref{Int64})::Cvoid +end + function mc77iz(icntl, cntl) @ccall libhsl.mc77iz_(icntl::Ptr{Cint}, cntl::Ptr{Float64})::Cvoid end diff --git a/src/Fortran/mi21.jl b/src/Fortran/mi21.jl index 64c0221..a9e9e30 100644 --- a/src/Fortran/mi21.jl +++ b/src/Fortran/mi21.jl @@ -3,6 +3,11 @@ function mi21id(icntl, cntl, isave, rsave) rsave::Ptr{Float64})::Cvoid end +function mi21id_64(icntl, cntl, isave, rsave) + @ccall libhsl_subset_64.mi21id_64_(icntl::Ptr{Int64}, cntl::Ptr{Float64}, isave::Ptr{Int64}, + rsave::Ptr{Float64})::Cvoid +end + function mi21ad(iact, n, w, ldw, locy, locz, resid, icntl, cntl, info, isave, rsave) @ccall libhsl.mi21ad_(iact::Ref{Cint}, n::Ref{Cint}, w::Ptr{Float64}, ldw::Ref{Cint}, locy::Ref{Cint}, locz::Ref{Cint}, resid::Ref{Float64}, icntl::Ptr{Cint}, @@ -10,14 +15,34 @@ function mi21ad(iact, n, w, ldw, locy, locz, resid, icntl, cntl, info, isave, rs rsave::Ptr{Float64})::Cvoid end +function mi21ad_64(iact, n, w, ldw, locy, locz, resid, icntl, cntl, info, isave, rsave) + @ccall libhsl_subset_64.mi21ad_64_(iact::Ref{Int64}, n::Ref{Int64}, w::Ptr{Float64}, + ldw::Ref{Int64}, locy::Ref{Int64}, locz::Ref{Int64}, + resid::Ref{Float64}, icntl::Ptr{Int64}, cntl::Ptr{Float64}, + info::Ptr{Int64}, isave::Ptr{Int64}, + rsave::Ptr{Float64})::Cvoid +end + function mi21i(icntl, cntl, isave, rsave) @ccall libhsl.mi21i_(icntl::Ptr{Cint}, cntl::Ptr{Float32}, isave::Ptr{Cint}, rsave::Ptr{Float32})::Cvoid end +function mi21i_64(icntl, cntl, isave, rsave) + @ccall libhsl_subset_64.mi21i_64_(icntl::Ptr{Int64}, cntl::Ptr{Float32}, isave::Ptr{Int64}, + rsave::Ptr{Float32})::Cvoid +end + function mi21a(iact, n, w, ldw, locy, locz, resid, icntl, cntl, info, isave, rsave) @ccall libhsl.mi21a_(iact::Ref{Cint}, n::Ref{Cint}, w::Ptr{Float32}, ldw::Ref{Cint}, locy::Ref{Cint}, locz::Ref{Cint}, resid::Ref{Float32}, icntl::Ptr{Cint}, cntl::Ptr{Float32}, info::Ptr{Cint}, isave::Ptr{Cint}, rsave::Ptr{Float32})::Cvoid end + +function mi21a_64(iact, n, w, ldw, locy, locz, resid, icntl, cntl, info, isave, rsave) + @ccall libhsl_subset_64.mi21a_64_(iact::Ref{Int64}, n::Ref{Int64}, w::Ptr{Float32}, + ldw::Ref{Int64}, locy::Ref{Int64}, locz::Ref{Int64}, + resid::Ref{Float32}, icntl::Ptr{Int64}, cntl::Ptr{Float32}, + info::Ptr{Int64}, isave::Ptr{Int64}, rsave::Ptr{Float32})::Cvoid +end diff --git a/src/Fortran/mi24.jl b/src/Fortran/mi24.jl index c58ad59..cc6bf6c 100644 --- a/src/Fortran/mi24.jl +++ b/src/Fortran/mi24.jl @@ -3,6 +3,11 @@ function mi24id(icntl, cntl, isave, rsave, lsave) lsave::Ptr{Cint})::Cvoid end +function mi24id_64(icntl, cntl, isave, rsave, lsave) + @ccall libhsl_subset_64.mi24id_64_(icntl::Ptr{Int64}, cntl::Ptr{Float64}, isave::Ptr{Int64}, + rsave::Ptr{Float64}, lsave::Ptr{Int64})::Cvoid +end + function mi24ad(iact, n, m, w, ldw, locy, locz, h, ldh, resid, icntl, cntl, info, isave, rsave, lsave) @ccall libhsl.mi24ad_(iact::Ref{Cint}, n::Ref{Cint}, m::Ref{Cint}, w::Ptr{Float64}, @@ -12,11 +17,26 @@ function mi24ad(iact, n, m, w, ldw, locy, locz, h, ldh, resid, icntl, cntl, info lsave::Ptr{Cint})::Cvoid end +function mi24ad_64(iact, n, m, w, ldw, locy, locz, h, ldh, resid, icntl, cntl, info, isave, rsave, + lsave) + @ccall libhsl_subset_64.mi24ad_64_(iact::Ref{Int64}, n::Ref{Int64}, m::Ref{Int64}, + w::Ptr{Float64}, ldw::Ref{Int64}, locy::Ref{Int64}, + locz::Ref{Int64}, h::Ptr{Float64}, ldh::Ref{Int64}, + resid::Ref{Float64}, icntl::Ptr{Int64}, cntl::Ptr{Float64}, + info::Ptr{Int64}, isave::Ptr{Int64}, rsave::Ptr{Float64}, + lsave::Ptr{Int64})::Cvoid +end + function mi24i(icntl, cntl, isave, rsave, lsave) @ccall libhsl.mi24i_(icntl::Ptr{Cint}, cntl::Ptr{Float32}, isave::Ptr{Cint}, rsave::Ptr{Float32}, lsave::Ptr{Cint})::Cvoid end +function mi24i_64(icntl, cntl, isave, rsave, lsave) + @ccall libhsl_subset_64.mi24i_64_(icntl::Ptr{Int64}, cntl::Ptr{Float32}, isave::Ptr{Int64}, + rsave::Ptr{Float32}, lsave::Ptr{Int64})::Cvoid +end + function mi24a(iact, n, m, w, ldw, locy, locz, h, ldh, resid, icntl, cntl, info, isave, rsave, lsave) @ccall libhsl.mi24a_(iact::Ref{Cint}, n::Ref{Cint}, m::Ref{Cint}, w::Ptr{Float32}, ldw::Ref{Cint}, @@ -24,3 +44,13 @@ function mi24a(iact, n, m, w, ldw, locy, locz, h, ldh, resid, icntl, cntl, info, resid::Ref{Float32}, icntl::Ptr{Cint}, cntl::Ptr{Float32}, info::Ptr{Cint}, isave::Ptr{Cint}, rsave::Ptr{Float32}, lsave::Ptr{Cint})::Cvoid end + +function mi24a_64(iact, n, m, w, ldw, locy, locz, h, ldh, resid, icntl, cntl, info, isave, rsave, + lsave) + @ccall libhsl_subset_64.mi24a_64_(iact::Ref{Int64}, n::Ref{Int64}, m::Ref{Int64}, w::Ptr{Float32}, + ldw::Ref{Int64}, locy::Ref{Int64}, locz::Ref{Int64}, + h::Ptr{Float32}, ldh::Ref{Int64}, resid::Ref{Float32}, + icntl::Ptr{Int64}, cntl::Ptr{Float32}, info::Ptr{Int64}, + isave::Ptr{Int64}, rsave::Ptr{Float32}, + lsave::Ptr{Int64})::Cvoid +end diff --git a/src/Fortran/mi26.jl b/src/Fortran/mi26.jl index 82855bc..4ada9a7 100644 --- a/src/Fortran/mi26.jl +++ b/src/Fortran/mi26.jl @@ -3,6 +3,11 @@ function mi26id(icntl, cntl, isave, rsave) rsave::Ptr{Float64})::Cvoid end +function mi26id_64(icntl, cntl, isave, rsave) + @ccall libhsl_subset_64.mi26id_64_(icntl::Ptr{Int64}, cntl::Ptr{Float64}, isave::Ptr{Int64}, + rsave::Ptr{Float64})::Cvoid +end + function mi26ad(iact, n, w, ldw, locy, locz, resid, icntl, cntl, info, isave, rsave) @ccall libhsl.mi26ad_(iact::Ref{Cint}, n::Ref{Cint}, w::Ptr{Float64}, ldw::Ref{Cint}, locy::Ref{Cint}, locz::Ref{Cint}, resid::Ref{Float64}, icntl::Ptr{Cint}, @@ -10,14 +15,34 @@ function mi26ad(iact, n, w, ldw, locy, locz, resid, icntl, cntl, info, isave, rs rsave::Ptr{Float64})::Cvoid end +function mi26ad_64(iact, n, w, ldw, locy, locz, resid, icntl, cntl, info, isave, rsave) + @ccall libhsl_subset_64.mi26ad_64_(iact::Ref{Int64}, n::Ref{Int64}, w::Ptr{Float64}, + ldw::Ref{Int64}, locy::Ref{Int64}, locz::Ref{Int64}, + resid::Ref{Float64}, icntl::Ptr{Int64}, cntl::Ptr{Float64}, + info::Ptr{Int64}, isave::Ptr{Int64}, + rsave::Ptr{Float64})::Cvoid +end + function mi26i(icntl, cntl, isave, rsave) @ccall libhsl.mi26i_(icntl::Ptr{Cint}, cntl::Ptr{Float32}, isave::Ptr{Cint}, rsave::Ptr{Float32})::Cvoid end +function mi26i_64(icntl, cntl, isave, rsave) + @ccall libhsl_subset_64.mi26i_64_(icntl::Ptr{Int64}, cntl::Ptr{Float32}, isave::Ptr{Int64}, + rsave::Ptr{Float32})::Cvoid +end + function mi26a(iact, n, w, ldw, locy, locz, resid, icntl, cntl, info, isave, rsave) @ccall libhsl.mi26a_(iact::Ref{Cint}, n::Ref{Cint}, w::Ptr{Float32}, ldw::Ref{Cint}, locy::Ref{Cint}, locz::Ref{Cint}, resid::Ref{Float32}, icntl::Ptr{Cint}, cntl::Ptr{Float32}, info::Ptr{Cint}, isave::Ptr{Cint}, rsave::Ptr{Float32})::Cvoid end + +function mi26a_64(iact, n, w, ldw, locy, locz, resid, icntl, cntl, info, isave, rsave) + @ccall libhsl_subset_64.mi26a_64_(iact::Ref{Int64}, n::Ref{Int64}, w::Ptr{Float32}, + ldw::Ref{Int64}, locy::Ref{Int64}, locz::Ref{Int64}, + resid::Ref{Float32}, icntl::Ptr{Int64}, cntl::Ptr{Float32}, + info::Ptr{Int64}, isave::Ptr{Int64}, rsave::Ptr{Float32})::Cvoid +end diff --git a/src/Fortran/ym01.jl b/src/Fortran/ym01.jl index 2212a77..fab67df 100644 --- a/src/Fortran/ym01.jl +++ b/src/Fortran/ym01.jl @@ -4,16 +4,40 @@ function ym01ad(m, n, nzin, nzout, ibw, itype, nonsin, irn, a, jcolst, iw) a::Ptr{Float64}, jcolst::Ptr{Cint}, iw::Ptr{Cint})::Cvoid end +function ym01ad_64(m, n, nzin, nzout, ibw, itype, nonsin, irn, a, jcolst, iw) + @ccall libhsl_subset_64.ym01ad_64_(m::Ref{Int64}, n::Ref{Int64}, nzin::Ref{Int64}, + nzout::Ref{Int64}, ibw::Ref{Int64}, itype::Ref{Int64}, + nonsin::Ref{Int64}, irn::Ptr{Int64}, a::Ptr{Float64}, + jcolst::Ptr{Int64}, iw::Ptr{Int64})::Cvoid +end + function ym01bd(n, m, perm, invprm) @ccall libhsl.ym01bd_(n::Ref{Cint}, m::Ref{Cint}, perm::Ptr{Cint}, invprm::Ptr{Cint})::Cvoid end +function ym01bd_64(n, m, perm, invprm) + @ccall libhsl_subset_64.ym01bd_64_(n::Ref{Int64}, m::Ref{Int64}, perm::Ptr{Int64}, + invprm::Ptr{Int64})::Cvoid +end + function ym01a(m, n, nzin, nzout, ibw, itype, nonsin, irn, a, jcolst, iw) @ccall libhsl.ym01a_(m::Ref{Cint}, n::Ref{Cint}, nzin::Ref{Cint}, nzout::Ref{Cint}, ibw::Ref{Cint}, itype::Ref{Cint}, nonsin::Ref{Cint}, irn::Ptr{Cint}, a::Ptr{Float32}, jcolst::Ptr{Cint}, iw::Ptr{Cint})::Cvoid end +function ym01a_64(m, n, nzin, nzout, ibw, itype, nonsin, irn, a, jcolst, iw) + @ccall libhsl_subset_64.ym01a_64_(m::Ref{Int64}, n::Ref{Int64}, nzin::Ref{Int64}, + nzout::Ref{Int64}, ibw::Ref{Int64}, itype::Ref{Int64}, + nonsin::Ref{Int64}, irn::Ptr{Int64}, a::Ptr{Float32}, + jcolst::Ptr{Int64}, iw::Ptr{Int64})::Cvoid +end + function ym01b(n, m, perm, invprm) @ccall libhsl.ym01b_(n::Ref{Cint}, m::Ref{Cint}, perm::Ptr{Cint}, invprm::Ptr{Cint})::Cvoid end + +function ym01b_64(n, m, perm, invprm) + @ccall libhsl_subset_64.ym01b_64_(n::Ref{Int64}, m::Ref{Int64}, perm::Ptr{Int64}, + invprm::Ptr{Int64})::Cvoid +end diff --git a/src/Fortran/ym11.jl b/src/Fortran/ym11.jl index 7f5fe4a..ab2c9f7 100644 --- a/src/Fortran/ym11.jl +++ b/src/Fortran/ym11.jl @@ -17,17 +17,33 @@ function ym11id(icntl, iseed) @ccall libhsl.ym11id_(icntl::Ptr{Cint}, iseed::Ref{Cint})::Cvoid end +function ym11id_64(icntl, iseed) + @ccall libhsl_subset_64.ym11id_64_(icntl::Ptr{Int64}, iseed::Ref{Int64})::Cvoid +end + function ym11ad(m, n, nzin, nzout, irn, a, jcolst, iw, icntl, key, iseed) @ccall libhsl.ym11ad_(m::Ref{Cint}, n::Ref{Cint}, nzin::Ref{Cint}, nzout::Ref{Cint}, irn::Ptr{Cint}, a::Ptr{Float64}, jcolst::Ptr{Cint}, iw::Ptr{Cint}, icntl::Ptr{Cint}, key::Ptr{UInt8}, iseed::Ref{Cint}, 8::Csize_t)::Cvoid end +function ym11ad_64(m, n, nzin, nzout, irn, a, jcolst, iw, icntl, key, iseed) + @ccall libhsl_subset_64.ym11ad_64_(m::Ref{Int64}, n::Ref{Int64}, nzin::Ref{Int64}, + nzout::Ref{Int64}, irn::Ptr{Int64}, a::Ptr{Float64}, + jcolst::Ptr{Int64}, iw::Ptr{Int64}, icntl::Ptr{Int64}, + key::Ptr{UInt8}, iseed::Ref{Int64}, 8::Csize_t)::Cvoid +end + function ym11bd(n, m, perm, invprm, iseed) @ccall libhsl.ym11bd_(n::Ref{Cint}, m::Ref{Cint}, perm::Ptr{Cint}, invprm::Ptr{Cint}, iseed::Ref{Cint})::Cvoid end +function ym11bd_64(n, m, perm, invprm, iseed) + @ccall libhsl_subset_64.ym11bd_64_(n::Ref{Int64}, m::Ref{Int64}, perm::Ptr{Int64}, + invprm::Ptr{Int64}, iseed::Ref{Int64})::Cvoid +end + function ym11ii(icntl, iseed) @ccall libhsl.ym11ii_(icntl::Ptr{Cint}, iseed::Ref{Cint})::Cvoid end @@ -47,17 +63,33 @@ function ym11i(icntl, iseed) @ccall libhsl.ym11i_(icntl::Ptr{Cint}, iseed::Ref{Cint})::Cvoid end +function ym11i_64(icntl, iseed) + @ccall libhsl_subset_64.ym11i_64_(icntl::Ptr{Int64}, iseed::Ref{Int64})::Cvoid +end + function ym11a(m, n, nzin, nzout, irn, a, jcolst, iw, icntl, key, iseed) @ccall libhsl.ym11a_(m::Ref{Cint}, n::Ref{Cint}, nzin::Ref{Cint}, nzout::Ref{Cint}, irn::Ptr{Cint}, a::Ptr{Float32}, jcolst::Ptr{Cint}, iw::Ptr{Cint}, icntl::Ptr{Cint}, key::Ptr{UInt8}, iseed::Ref{Cint}, 8::Csize_t)::Cvoid end +function ym11a_64(m, n, nzin, nzout, irn, a, jcolst, iw, icntl, key, iseed) + @ccall libhsl_subset_64.ym11a_64_(m::Ref{Int64}, n::Ref{Int64}, nzin::Ref{Int64}, + nzout::Ref{Int64}, irn::Ptr{Int64}, a::Ptr{Float32}, + jcolst::Ptr{Int64}, iw::Ptr{Int64}, icntl::Ptr{Int64}, + key::Ptr{UInt8}, iseed::Ref{Int64}, 8::Csize_t)::Cvoid +end + function ym11b(n, m, perm, invprm, iseed) @ccall libhsl.ym11b_(n::Ref{Cint}, m::Ref{Cint}, perm::Ptr{Cint}, invprm::Ptr{Cint}, iseed::Ref{Cint})::Cvoid end +function ym11b_64(n, m, perm, invprm, iseed) + @ccall libhsl_subset_64.ym11b_64_(n::Ref{Int64}, m::Ref{Int64}, perm::Ptr{Int64}, + invprm::Ptr{Int64}, iseed::Ref{Int64})::Cvoid +end + function ym11iz(icntl, iseed) @ccall libhsl.ym11iz_(icntl::Ptr{Cint}, iseed::Ref{Cint})::Cvoid end diff --git a/src/hsl_ma97.jl b/src/hsl_ma97.jl index 0d73f41..2320c21 100644 --- a/src/hsl_ma97.jl +++ b/src/hsl_ma97.jl @@ -54,6 +54,38 @@ const jobs97 = Dict{Symbol, Int}( :DLPS => 4, # solve DL'P'S⁻¹x = b ) +""" + ma97_control_variant{T}(; kwargs...) + +## Keyword arguments: +* `print_level::Int`: integer controling the verbosit level. Accepted values are: + * <0: no printing + * 0: errors and warnings only (default) + * 1: errors, warnings and basic diagnostics + * 2: errors, warning and full diagnostics +* `unit_diagnostics::Int`: Fortran file unit for diagnostics (default: 6) +* `unit_error::Int`: Fortran file unit for errors (default: 6) +* `unit_warning::Int`: Fortran file unit for warnings (default: 6) +""" +function ma97_control_variant( + ::Type{T}; + print_level::Int = -1, + unit_diagnostics::Int = 6, + unit_error::Int = 6, + unit_warning::Int = 6) where {T} + control = ma97_control{T}() + T == Float32 && ma97_default_control_s(control) + T == Float64 && ma97_default_control_d(control) + T == ComplexF32 && ma97_default_control_c(control) + T == ComplexF64 && ma97_default_control_z(control) + control.f_arrays = 1 # Use 1-based indexing for arrays, avoiding copies. + control.print_level = print_level + control.unit_diagnostics = unit_diagnostics + control.unit_error = unit_error + control.unit_warning = unit_warning + return control +end + "Exception type raised in case of error." mutable struct Ma97Exception <: Exception msg::AbstractString @@ -109,7 +141,7 @@ for (fname, freename, elty, subty) in ((:ma97_analyse_s, :ma97_free_akeep_s, :Fl nzval::Vector{$elty}; kwargs..., ) where {Ti <: Integer} - control = ma97_control{$subty}(; kwargs...) + control = ma97_control_variant($subty; kwargs...) info = ma97_info{$subty}() M = Ma97{$elty, $subty}( [Ptr{Cvoid}(C_NULL)], @@ -173,7 +205,7 @@ for (fname, freename, elty, subty) in ((:ma97_analyse_coord_s, :ma97_free_akeep_ nzval::Vector{$elty}; kwargs..., ) where {Ti <: Integer} - control = ma97_control{$subty}(; kwargs...) + control = ma97_control_variant($subty; kwargs...) info = ma97_info{$subty}() M = Ma97{$elty, $subty}( [convert(Ptr{Cvoid}, C_NULL)], diff --git a/test/Jenkinsfile b/test/Jenkinsfile deleted file mode 100644 index 1a2469a..0000000 --- a/test/Jenkinsfile +++ /dev/null @@ -1,83 +0,0 @@ -def prNumber = BRANCH_NAME.tokenize("PR-")[0] -def runTestPath = "BenchmarkSetup/test/run_tests.sh" -def pattern = "[a-zA-Z0-9]+?.jl" -def repoName = (CHANGE_URL =~ pattern)[0] -def token = repoName.tokenize(".")[0] -pipeline { - agent any - options { - skipDefaultCheckout false - } - triggers { - GenericTrigger( - genericVariables: [ - [ - key: 'org', - value: '$.organization.login', - expressionType: 'JSONPath', //Optional, defaults to JSONPath - regexpFilter: '', //Optional, defaults to empty string - defaultValue: '' //Optional, defaults to empty string - ], - [ - key: 'pullrequest', - value: '$.pull_request.number', - expressionType: 'JSONPath', //Optional, defaults to JSONPath - regexpFilter: '', //Optional, defaults to empty string - defaultValue: '$prNumber' //Optional, defaults to empty string - ], - [ - key: 'repo', - value: '$.repository.name', - expressionType: 'JSONPath', //Optional, defaults to JSONPath - regexpFilter: '', //Optional, defaults to empty string - defaultValue: '' //Optional, defaults to empty string - ] - ], - - causeString: 'Triggered on pullrequest update/creation', - - token: "$token", - - printContributedVariables: true, - printPostContent: true, - - silentResponse: false, - - regexpFilterText: '$pullrequest', - regexpFilterExpression: prNumber - ) - } - stages { - stage('clone Setup') { - when { - expression { env.repo && env.org && env.pullrequest } - } - steps { - sh "git clone ${JENKINS_SETUP_URL} || true" - } - } - stage('run tests') { - when { - expression { env.repo && env.org && env.pullrequest } - } - steps { - script { - if (fileExists('test/run_tests.sh')) { - runTestPath = 'test/run_tests.sh'; - } - } - sh "chmod +x ${runTestPath}" - sh "mkdir -p $HOME/tests/${org}/${repo}" - sh "qsub -N ${repo}_${pullrequest}_test -V -cwd -e $HOME/tests/${org}/${repo}/${pullrequest}_${BUILD_NUMBER}_error.log ${runTestPath}" - } - } - } - post { - success { - echo "SUCCESS!" - } - cleanup { - sh 'printenv' - } - } -} diff --git a/test/run_tests.sh b/test/run_tests.sh deleted file mode 100644 index a7f7d7c..0000000 --- a/test/run_tests.sh +++ /dev/null @@ -1,13 +0,0 @@ -#!/bin/bash - -. $HOME/.bash_profile - -# clean up any potential previous build -rm -rf deps/usr -rm -f deps/build.log deps/deps.jl - -# Specify the module to test (e.g "HSL") -julia -E 'using Pkg; module_name = "HSL"; Pkg.activate("test_env"); Pkg.develop(PackageSpec(url=joinpath("."))); Pkg.build(module_name); Pkg.test(module_name)' &> "$org"_"$repo"_"$pullrequest".txt - -# Create the gist and create comment on PR: -julia test/send_gist_url.jl diff --git a/test/send_gist_url.jl b/test/send_gist_url.jl deleted file mode 100644 index f08f36f..0000000 --- a/test/send_gist_url.jl +++ /dev/null @@ -1,76 +0,0 @@ -using Pkg -Pkg.activate(joinpath("test_env")) -Pkg.add("GitHub") -Pkg.instantiate() - -using GitHub - -ORG, REPO, PR = ENV["org"], ENV["repo"], ENV["pullrequest"] -TEST_RESULTS_FILE = "$(ORG)_$(REPO)_$(PR).txt" -LOG_FILE = joinpath("deps", "build.log") - -# Need to add GITHUB_AUTH to your .bashrc -myauth = GitHub.authenticate(ENV["GITHUB_AUTH"]) - -function create_gist(authentication) - file_content = read(TEST_RESULTS_FILE, String) - log_content = read(LOG_FILE, String) - - file_dict = Dict( - TEST_RESULTS_FILE => Dict("content" => file_content), - "build.log" => Dict("content" => log_content), - ) - gist = Dict{String, Any}("description" => "Test results", "public" => true, "files" => file_dict) - - posted_gist = GitHub.create_gist(params = gist, auth = authentication) - - return posted_gist -end - -function post_gist_url_to_pr(comment::String; kwargs...) - api = GitHub.DEFAULT_API - repo = get_repo(api, ORG, REPO; kwargs...) - pull_request = get_pull_request(api, ORG, repo, parse(Int, PR); kwargs...) - GitHub.create_comment(api, repo, pull_request, comment; kwargs...) -end - -function get_repo(api::GitHub.GitHubWebAPI, org::String, repo_name::String; kwargs...) - my_params = Dict(:visibility => "all") - # return GitHub.repo(api, repo; params = my_params, kwargs...) - return Repo(GitHub.gh_get_json(api, "/repos/$(org)/$(repo_name)"; params = my_params, kwargs...)) -end - -function get_pull_request( - api::GitHub.GitHubWebAPI, - org::String, - repo::Repo, - pullrequest_id; - kwargs..., -) - my_params = Dict(:sort => "popularity", :direction => "desc") - pull_request = PullRequest( - GitHub.gh_get_json( - api, - "/repos/$(org)/$(repo.name)/pulls/$(pullrequest_id)"; - params = my_params, - kwargs..., - ), - ) - - return pull_request -end - -function get_comment_from_test_results() - open(TEST_RESULTS_FILE, "r") do file - text_to_match = r"tests passed" - for line in readlines(file) - if occursin(text_to_match, line) - return "$(strip(line)): " - end - end - return "Tests failed: " - end -end - -comment = get_comment_from_test_results() -post_gist_url_to_pr("$comment $(create_gist(myauth).html_url)"; auth = myauth)