filename
stringlengths 3
67
| data
stringlengths 0
58.3M
| license
stringlengths 0
19.5k
|
|---|---|---|
t-zeta_nzeros_gram.c |
#include "acb_dirichlet.h"
int main()
{
slong iter;
flint_rand_t state;
flint_printf("zeta_nzeros_gram....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 130 + 20 * arb_test_multiplier(); iter++)
{
arb_t t, x;
fmpz_t N, n;
slong prec1, prec2;
arb_init(t);
arb_init(x);
fmpz_init(n);
fmpz_init(N);
if (iter < 130)
{
fmpz_set_si(n, iter - 1);
}
else
{
fmpz_randtest_unsigned(n, state, 20);
fmpz_add_ui(n, n, 129);
}
prec1 = 2 + n_randtest(state) % 100;
prec2 = 2 + n_randtest(state) % 100;
acb_dirichlet_zeta_nzeros_gram(N, n);
acb_dirichlet_gram_point(t, n, NULL, NULL, prec1);
acb_dirichlet_zeta_nzeros(x, t, prec2);
if (!arb_contains_fmpz(x, N))
{
flint_printf("FAIL: containment\n\n");
flint_printf("n = "); fmpz_print(n);
flint_printf(" prec1 = %wd prec2 = %wd\n\n", prec1, prec2);
flint_printf("N = "); fmpz_print(N); flint_printf("\n\n");
flint_printf("t = "); arb_printn(t, 100, 0); flint_printf("\n\n");
flint_printf("x = "); arb_printn(x, 100, 0); flint_printf("\n\n");
flint_abort();
}
arb_clear(t);
arb_clear(x);
fmpz_clear(n);
fmpz_clear(N);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
| /*
Copyright (C) 2019 D.H.J. Polymath
This file is part of Arb.
Arb is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License (LGPL) as published
by the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version. See <http://www.gnu.org/licenses/>.
*/ |
tests.ml |
module Test (R : Mirage_random.S) = struct
let rec gen_ip () =
let buf = R.generate 4 in
let ip = Ipaddr.V4.of_octets_exn (Cstruct.to_string buf) in
if ip = Ipaddr.V4.any || ip = Ipaddr.V4.broadcast then
gen_ip ()
else
buf, ip
let rec gen_mac () =
let buf = R.generate 6 in
let mac = Macaddr.of_octets_exn (Cstruct.to_string buf) in
if mac = Macaddr.broadcast then
gen_mac ()
else
buf, mac
let hdr =
let buf = Cstruct.create 6 in
Cstruct.BE.set_uint16 buf 0 1 ;
Cstruct.BE.set_uint16 buf 2 0x0800 ;
Cstruct.set_uint8 buf 4 6 ;
Cstruct.set_uint8 buf 5 4 ;
buf
let gen_int () =
let buf = R.generate 1 in
(buf, Cstruct.get_uint8 buf 0)
let gen_op () =
let _, op = gen_int () in
let buf = Cstruct.create 2 in
let op = 1 + op mod 2 in
Cstruct.BE.set_uint16 buf 0 op ;
(if op = 1 then Arp_packet.Request else Arp_packet.Reply), buf
let gen_arp () =
let sm, source_mac = gen_mac ()
and si, source_ip = gen_ip ()
and tm, target_mac = gen_mac ()
and ti, target_ip = gen_ip ()
and op, opb = gen_op ()
in
{ Arp_packet.operation = op ; source_mac ; source_ip ; target_mac ; target_ip },
Cstruct.concat [ hdr ; opb ; sm ; si ; tm ; ti ]
let p =
let module M = struct
type t = Arp_packet.t
let pp = Arp_packet.pp
let equal s t =
let open Arp_packet in
s.operation = t.operation &&
Macaddr.compare s.source_mac t.source_mac = 0 &&
Macaddr.compare s.target_mac t.target_mac = 0 &&
Ipaddr.V4.compare s.source_ip t.source_ip = 0 &&
Ipaddr.V4.compare s.target_ip t.target_ip = 0
end in
(module M : Alcotest.TESTABLE with type t = M.t)
module Coding = struct
let gen_op_arp () =
let rec gen_op () =
let buf = R.generate 2 in
match Cstruct.BE.get_uint16 buf 0 with
| 1 | 2 -> gen_op ()
| x -> (x, buf)
in
let data = R.generate 20
and o, opb = gen_op ()
in
o, Cstruct.concat [ hdr ; opb ; data ]
let rec gen_unhandled_arp () =
let open R in
(* some consistency -- hlen and plen *)
let htype = generate 2
and ptype = generate 2
in
(* if we don't have at least length m, we'll end up in Too_short *)
let rec i_min m () =
let buf, len = gen_int () in
if len < m then i_min m ()
else buf, len
in
let hl, hlen = i_min 6 ()
and pl, plen = i_min 4 ()
in
let my_hdr = Cstruct.concat [ htype ; ptype ; hl ; pl ] in
if Cstruct.equal my_hdr hdr then
gen_unhandled_arp ()
else
let rec gen_op () =
let buf = R.generate 2 in
match Cstruct.BE.get_uint16 buf 0 with
| 1 | 2 -> gen_op ()
| _ -> buf
in
let op = gen_op ()
and sha = generate hlen
and tha = generate hlen
and spa = generate plen
and tpa = generate plen
in
Cstruct.concat [ my_hdr ; op ; sha ; spa ; tha ; tpa ]
let gen_short_arp () =
let _, l = gen_int () in
R.generate (l mod 28)
let e =
let module M = struct
type t = Arp_packet.error
let pp = Arp_packet.pp_error
let equal a b =
let open Arp_packet in
match a, b with
| Too_short, Too_short -> true
| Unusable, Unusable -> true
| Unknown_operation x, Unknown_operation y -> x = y
| _ -> false
end in
(module M : Alcotest.TESTABLE with type t = M.t)
let repeat f n () =
for _i = 0 to n do
f ()
done
let check_r s res buf =
Alcotest.(check (result p e) s res (Arp_packet.decode buf))
let dec_valid_arp () =
let pkt, buf = gen_arp () in
check_r "decoding valid ARP frames" (Ok pkt) buf
let dec_unhandled_arp () =
let buf = gen_unhandled_arp () in
check_r "invalid header is error" (Error Arp_packet.Unusable) buf
let dec_short_arp () =
let buf = gen_short_arp () in
check_r "short is error" (Error Arp_packet.Too_short) buf
let dec_op_arp () =
let o, buf = gen_op_arp () in
check_r "invalid op is error" (Error (Arp_packet.Unknown_operation o)) buf
let dec_enc () =
let pkt, buf = gen_arp () in
let cbuf = Arp_packet.encode pkt in
Alcotest.(check bool "encoding produces same buffer" true (Cstruct.equal buf cbuf)) ;
match Arp_packet.decode buf with
| Error _ -> Alcotest.fail "decoding failed, should not happen"
| Ok pack ->
Alcotest.(check p "decoding worked" pkt pack) ;
let cbuf = Arp_packet.encode pack in
Alcotest.(check bool "encoding produces same buffer" true (Cstruct.equal buf cbuf))
let enc_into () =
let pkt, buf = gen_arp () in
let cbuf = Cstruct.create 28 in
Arp_packet.encode_into pkt cbuf ;
Alcotest.(check bool "encode_into works" true (Cstruct.equal cbuf buf))
let enc_fail () =
for i = 0 to 27 do
let buf = Cstruct.create i
and pkg, _ = gen_arp ()
in
Alcotest.check_raises "buffer is too small" (Invalid_argument "too small")
(fun () ->
try Arp_packet.encode_into pkg buf with Invalid_argument _ -> invalid_arg "too small")
done
let coder_tsts = [
"valid arp decoding", `Quick, (repeat dec_valid_arp 1000) ;
"unhandled arp decoding", `Quick, (repeat dec_unhandled_arp 1000) ;
"short arp decoding", `Quick, (repeat dec_short_arp 1000) ;
"invalid operation decoding", `Quick, (repeat dec_op_arp 1000) ;
"decoding is inverse of encoding", `Quick, (repeat dec_enc 1000) ;
"encode_into works", `Quick, (repeat enc_into 1000) ;
"encode_into fails with small bufs", `Quick, enc_fail ;
]
end
module Handling = struct
let garp_of ip mac =
let mac0 = Macaddr.of_octets_exn (Cstruct.to_string (Cstruct.create 6)) in
{ Arp_packet.operation = Arp_packet.Request ;
source_ip = ip ; target_ip = ip ;
source_mac = mac ; target_mac = mac0 }
let gen_ip () = snd (gen_ip ())
and gen_mac () = snd (gen_mac ())
let m =
let module M = struct
type t = Macaddr.t
let pp = Macaddr.pp
let equal a b = Macaddr.compare a b = 0
end in
(module M : Alcotest.TESTABLE with type t = M.t)
let i =
let module M = struct
type t = Ipaddr.V4.t
let pp = Ipaddr.V4.pp
let equal a b = Ipaddr.V4.compare a b = 0
end in
(module M : Alcotest.TESTABLE with type t = M.t)
let create_raises () =
let mac = gen_mac () in
Alcotest.check_raises "timeout <= 0" (Invalid_argument "timeout must be strictly positive")
(fun () -> ignore(Arp_handler.create ~timeout:0 mac)) ;
Alcotest.check_raises "retries < 0" (Invalid_argument "retries must be positive")
(fun () -> ignore(Arp_handler.create ~retries:(-1) mac))
let basic_good () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, garp = Arp_handler.create ~ipaddr mac in
let garp = match garp with
| None -> Alcotest.fail "expected some garp"
| Some garp -> garp
in
Alcotest.(check bool "create has good GARP" true
(Cstruct.equal (Arp_packet.encode (garp_of ipaddr mac))
(Arp_packet.encode (fst garp)))) ;
Alcotest.(check (list i) "ip is sensible" [ipaddr] (Arp_handler.ips t)) ;
Alcotest.(check (option m) "own entry is in cache"
(Some mac) (Arp_handler.in_cache t ipaddr)) ;
Alcotest.(check (option m) "any is not in cache" None
(Arp_handler.in_cache t Ipaddr.V4.any)) ;
Alcotest.(check (option m) "broadcast is not in cache" None
(Arp_handler.in_cache t Ipaddr.V4.broadcast))
let remove_good () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~ipaddr mac in
Alcotest.(check (list i) "ip is sensible" [ipaddr] (Arp_handler.ips t)) ;
Alcotest.(check (option m) "own entry is in cache"
(Some mac) (Arp_handler.in_cache t ipaddr)) ;
let t = Arp_handler.remove t ipaddr in
Alcotest.(check (option m) "own entry is no longer in cache" None
(Arp_handler.in_cache t ipaddr))
let remove_no () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~ipaddr mac in
Alcotest.(check (list i) "ip is sensible" [ipaddr] (Arp_handler.ips t)) ;
Alcotest.(check (option m) "own entry is in cache"
(Some mac) (Arp_handler.in_cache t ipaddr)) ;
let t = Arp_handler.remove t Ipaddr.V4.any in
Alcotest.(check (option m) "own entry is still in cache" (Some mac)
(Arp_handler.in_cache t ipaddr))
let alias_good () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~ipaddr mac in
Alcotest.(check (list i) "ip is sensible" [ipaddr] (Arp_handler.ips t)) ;
Alcotest.(check (option m) "own entry is in cache"
(Some mac) (Arp_handler.in_cache t ipaddr)) ;
let t, _, _ = Arp_handler.alias t ipaddr in
Alcotest.(check (option m) "own entry is still in cache" (Some mac)
(Arp_handler.in_cache t ipaddr)) ;
let ip' = gen_ip () in
let t, _, _ = Arp_handler.alias t ip' in
Alcotest.(check (option m) "own entry is still in cache" (Some mac)
(Arp_handler.in_cache t ipaddr)) ;
Alcotest.(check (option m) "aliased entry is in cache" (Some mac)
(Arp_handler.in_cache t ip'))
let alias_remove_inverse () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~ipaddr mac in
let ip' = gen_ip () in
let t, _, _ = Arp_handler.alias t ip' in
Alcotest.(check (option m) "own entry is in cache" (Some mac)
(Arp_handler.in_cache t ipaddr)) ;
Alcotest.(check (option m) "aliased entry is in cache" (Some mac)
(Arp_handler.in_cache t ip')) ;
let t = Arp_handler.remove t ip' in
Alcotest.(check (option m) "aliased entry is no longer in cache" None
(Arp_handler.in_cache t ip'))
let static_good () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~ipaddr mac in
let ip' = gen_ip () in
let mac' = gen_mac () in
let t, _ = Arp_handler.static t ip' mac' in
Alcotest.(check (option m) "own entry is in cache" (Some mac)
(Arp_handler.in_cache t ipaddr)) ;
Alcotest.(check (option m) "static entry is in cache" (Some mac')
(Arp_handler.in_cache t ip')) ;
let t = Arp_handler.remove t ip' in
Alcotest.(check (option m) "static entry is no longer in cache" None
(Arp_handler.in_cache t ip'))
let static_alias_good () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~ipaddr mac in
let ip' = gen_ip () in
let mac' = gen_mac () in
let t, _ = Arp_handler.static t ip' mac' in
Alcotest.(check (option m) "own entry is in cache" (Some mac)
(Arp_handler.in_cache t ipaddr)) ;
Alcotest.(check (option m) "static entry is in cache" (Some mac')
(Arp_handler.in_cache t ip')) ;
let t, _, _ = Arp_handler.alias t ip' in
Alcotest.(check (option m) "alias entry overwrote static one" (Some mac)
(Arp_handler.in_cache t ip')) ;
let t, _ = Arp_handler.static t ip' mac' in
Alcotest.(check (option m) "static entry overwrite aliased one" (Some mac')
(Arp_handler.in_cache t ip')) ;
let t = Arp_handler.remove t ip' in
Alcotest.(check (option m) "static entry is no longer in cache" None
(Arp_handler.in_cache t ip'))
let more_good () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~ipaddr mac in
let rec more_entries acc t = function
| 0 -> acc, t
| n ->
let ip' = gen_ip () in
if List.mem ip' (List.map fst acc) then
more_entries acc t n
else
let t, e =
if n mod 2 = 0 then
let mac' = gen_mac () in
let t, _ = Arp_handler.static t ip' mac' in
(t, (ip', mac'))
else
let t, _, _ = Arp_handler.alias t ip' in
(t, (ip', mac))
in
more_entries (e::acc) t (pred n)
in
let acc, t = more_entries [(ipaddr,mac)] t 100 in
List.iter (fun (ip, mac) ->
Alcotest.(check (option m) "entry is in cache" (Some mac)
(Arp_handler.in_cache t ip)))
acc ;
List.iter (fun (ip, _) ->
let t = Arp_handler.remove t ip in
Alcotest.(check (option m) "entry is no longer in cache" None
(Arp_handler.in_cache t ip)))
acc ;
let t = List.fold_left (fun t (ip, _) -> Arp_handler.remove t ip) t acc in
Alcotest.(check (option m) "own entry is no longer in cache" None
(Arp_handler.in_cache t ipaddr))
let packet =
let module M = struct
type t = Arp_packet.t
let pp = Arp_packet.pp
let equal = Arp_packet.equal
end in
(module M : Alcotest.TESTABLE with type t = M.t)
let out =
let module M = struct
type t = Arp_packet.t * Macaddr.t
let pp ppf (cs, mac) =
Format.fprintf ppf "out: %a to %a" Arp_packet.pp cs Macaddr.pp mac
let equal (acs, amac) (bcs, bmac) =
Arp_packet.equal acs bcs && Macaddr.compare amac bmac = 0
end in
(module M : Alcotest.TESTABLE with type t = M.t)
let qres =
let module M = struct
type t = int list Arp_handler.qres
let pp ppf = function
| Arp_handler.Mac mac -> Format.fprintf ppf "ok %a" Macaddr.pp mac
| Arp_handler.RequestWait ((cs, mac), xs) ->
Format.fprintf ppf "requestwait %a to %a, wait %s"
Arp_packet.pp cs Macaddr.pp mac
(String.concat ", " (List.map string_of_int xs))
| Arp_handler.Wait xs ->
Format.fprintf ppf "wait %s"
(String.concat ", " (List.map string_of_int xs))
let equal a b = match a, b with
| Arp_handler.Mac a, Arp_handler.Mac b -> Macaddr.compare a b = 0
| Arp_handler.RequestWait ((csa, maca), xsa),
Arp_handler.RequestWait ((csb, macb), xsb) ->
Arp_packet.equal csa csb && Macaddr.compare maca macb = 0 &&
List.length xsa = List.length xsb &&
List.for_all (fun x -> List.mem x xsb) xsa
| Arp_handler.Wait xsa, Arp_handler.Wait xsb ->
List.length xsa = List.length xsb &&
List.for_all (fun x -> List.mem x xsb) xsa
| _ -> false
end in
(module M : Alcotest.TESTABLE with type t = M.t)
let merge v = function
| None -> [v]
| Some xs -> v::xs
let handle_good () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~ipaddr mac in
let _t, res = Arp_handler.query t ipaddr (merge 1) in
Alcotest.check qres "own IP can be queried" (Arp_handler.Mac mac) res
let query source_mac source_ip target_ip =
{ Arp_packet.operation = Arp_packet.Request ;
source_mac ; source_ip ;
target_mac = Macaddr.broadcast ; target_ip },
Macaddr.broadcast
let handle_gen_request () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~retries:1 ~ipaddr mac in
let other = gen_ip () in
let _, res = Arp_handler.query t other (merge 1) in
let out = query mac ipaddr other in
Alcotest.check qres "res is requestwait" (Arp_handler.RequestWait (out, [1])) res
let handle_gen_request_twice () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~ipaddr ~retries:1 mac in
let other = gen_ip () in
let t, res = Arp_handler.query t other (merge 1) in
let out = query mac ipaddr other in
Alcotest.check qres "res is requestwait" (Arp_handler.RequestWait (out, [1])) res ;
let _, res = Arp_handler.query t other (merge 2) in
Alcotest.check qres "res is wait" (Arp_handler.Wait [2;1]) res
let alias_wakes () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~ipaddr mac in
let other = gen_ip () in
let t, res = Arp_handler.query t other (merge 1) in
let out = query mac ipaddr other in
Alcotest.check qres "res is requestwait!" (Arp_handler.RequestWait (out, [1])) res ;
Alcotest.(check (option m) "query is not cache" None (Arp_handler.in_cache t other)) ;
let _, _, a = Arp_handler.alias t other in
Alcotest.(check (option (list int)) "alias wakes up" (Some [1]) a)
let static_wakes () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~ipaddr mac in
let other = gen_ip () in
let t, res = Arp_handler.query t other (merge 1) in
let out = query mac ipaddr other in
Alcotest.check qres "res is requestwait" (Arp_handler.RequestWait (out, [1])) res ;
let _, a = Arp_handler.static t other mac in
Alcotest.(check (option (list int)) "alias wakes up" (Some [1]) a)
let handle_timeout () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~retries:1 ~ipaddr mac in
let other = gen_ip () in
let t, _ = Arp_handler.query t other (merge 1) in
let t, _, a = Arp_handler.tick t in
Alcotest.(check (list (list int)) "tick didn't timeout" [] a) ;
let _, _, a = Arp_handler.tick t in
Alcotest.(check (list (list int)) "tick timed out" [[1]] a)
let req_before_timeout () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~timeout:1 ~ipaddr mac in
let other = gen_ip () in
let t, _ = Arp_handler.query t other (merge 1) in
let omac = gen_mac () in
let pkt =
Arp_packet.encode { Arp_packet.operation = Arp_packet.Reply ;
source_ip = other ; source_mac = omac ;
target_ip = ipaddr ; target_mac = mac }
in
let t, outp, wake = Arp_handler.input t pkt in
Alcotest.(check (option out) "out is none" None outp) ;
Alcotest.(check (option (pair m (list int))) "wake is correct"
(Some (omac, [1])) wake) ;
let _, outp, rs = Arp_handler.tick t in
Alcotest.(check bool "timeouts are empty" true (rs = [])) ;
Alcotest.(check (list out) "arp request is sent" [query mac ipaddr other] outp)
let multiple_reqs () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~retries:1 ~ipaddr mac in
let other = gen_ip () in
let t, res = Arp_handler.query t other (merge 1) in
let q = query mac ipaddr other in
Alcotest.check qres "query generates ARP request" (Arp_handler.RequestWait (q, [1])) res ;
let t, outs, touts = Arp_handler.tick t in
Alcotest.(check (list out) "tick generates second ARP request" [q] outs) ;
Alcotest.(check (list (list int)) "tick generated no timeout yet" [] touts) ;
let _, outs, touts = Arp_handler.tick t in
Alcotest.(check (list out) "tick generated no other request" [] outs) ;
Alcotest.(check (list (list int)) "tick generated a timeout" [[1]] touts)
let multiple_reqs_2 () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~retries:4 ~ipaddr mac in
let other = gen_ip () in
let t, res = Arp_handler.query t other (merge 1) in
let q = query mac ipaddr other in
Alcotest.check qres "query generates ARP request" (Arp_handler.RequestWait (q, [1])) res ;
let t, outs, touts = Arp_handler.tick t in
Alcotest.(check (list out) "tick generates second ARP request" [q] outs) ;
Alcotest.(check (list (list int)) "tick generated no timeout yet" [] touts) ;
let t, outs, touts = Arp_handler.tick t in
Alcotest.(check (list out) "tick generates third ARP request" [q] outs) ;
Alcotest.(check (list (list int)) "tick generated no timeout yet" [] touts) ;
let t, outs, touts = Arp_handler.tick t in
Alcotest.(check (list out) "tick generates fourth ARP request" [q] outs) ;
Alcotest.(check (list (list int)) "tick generated no timeout yet" [] touts) ;
let t, outs, touts = Arp_handler.tick t in
Alcotest.(check (list out) "tick generates fifth ARP request" [q] outs) ;
Alcotest.(check (list (list int)) "tick generated no timeout yet" [] touts) ;
let _, outs, touts = Arp_handler.tick t in
Alcotest.(check (list out) "tick generated no other request" [] outs) ;
Alcotest.(check (list (list int)) "tick generated a timeout" [[1]] touts)
let handle_reply () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~timeout:1 ~ipaddr mac in
let other = gen_ip () in
let omac = gen_mac () in
let pkt =
Arp_packet.encode { Arp_packet.operation = Arp_packet.Reply ;
source_ip = other ; source_mac = omac ;
target_ip = ipaddr ; target_mac = mac }
in
let t, outp, w = Arp_handler.input t pkt in
Alcotest.(check (option out) "nothing to be sent" None outp) ;
Alcotest.(check (option (pair m (list int))) "noone wakes up" None w) ;
Alcotest.(check (option m) "received entry is not in cache" None
(Arp_handler.in_cache t other))
let handle_garp () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~timeout:1 ~ipaddr mac in
let other = gen_ip () in
let omac = gen_mac () in
let pkt = Arp_packet.encode (garp_of other omac) in
let t, outp, w = Arp_handler.input t pkt in
Alcotest.(check (option out) "nothing out" None outp) ;
Alcotest.(check (option (pair m (list int))) "nothin woken up" None w) ;
Alcotest.(check (option m) "received garp entry is not in cache" None
(Arp_handler.in_cache t other))
let answer_req_broadcast () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~timeout:1 ~ipaddr mac in
let other = gen_ip () in
let omac = gen_mac () in
let pkt, _ = query omac other ipaddr in
let _, outp, w = Arp_handler.input t (Arp_packet.encode pkt) in
Alcotest.(check (option (pair m (list int))) "nothin woken up" None w) ;
Alcotest.(check (option out) "request to us provokes a reply"
(Some ({ Arp_packet.operation = Arp_packet.Reply ;
source_mac = mac ; source_ip = ipaddr ;
target_mac = omac ; target_ip = other },
omac)) outp)
let answer_req_unicast () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~timeout:1 ~ipaddr mac in
let other = gen_ip () in
let omac = gen_mac () in
let pkt =
Arp_packet.encode { Arp_packet.operation = Arp_packet.Request ;
source_ip = other ; source_mac = omac ;
target_ip = ipaddr ; target_mac = mac }
in
let _, outp, w = Arp_handler.input t pkt in
Alcotest.(check (option (pair m (list int))) "nothin woken up" None w) ;
Alcotest.(check (option out) "request to us provokes a reply"
(Some ({ Arp_packet.operation = Arp_packet.Reply ;
source_mac = mac ; source_ip = ipaddr ;
target_mac = omac ; target_ip = other },
omac)) outp)
let not_answer_req () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~timeout:1 ~ipaddr mac in
let other = gen_ip () in
let third = gen_ip () in
let omac = gen_mac () in
let pkt, _ = query omac other third in
let _, outp, w = Arp_handler.input t (Arp_packet.encode pkt) in
Alcotest.(check (option out) "nothing out" None outp) ;
Alcotest.(check (option (pair m (list int))) "nothin woken up" None w)
let ignoring_random () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~timeout:1 ~ipaddr mac in
let pkt = R.generate 24 in
let _, outp, w = Arp_handler.input t pkt in
Alcotest.(check (option out) "nothing out" None outp) ;
Alcotest.(check (option (pair m (list int))) "nothin woken up" None w)
let reply_does_not_override () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~timeout:1 ~ipaddr mac in
let omac = gen_mac () in
let pkt =
Arp_packet.encode { Arp_packet.operation = Arp_packet.Reply ;
source_ip = ipaddr ; source_mac = omac ;
target_ip = ipaddr ; target_mac = mac }
in
let t, outp, w = Arp_handler.input t pkt in
Alcotest.(check (option out) "nothing out" None outp) ;
Alcotest.(check (option (pair m (list int))) "nothin woken up" None w) ;
Alcotest.(check (option m) "our entry is still in cache" (Some mac)
(Arp_handler.in_cache t ipaddr))
let reply_query () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~timeout:1 ~ipaddr mac in
let other = gen_ip () in
let omac = gen_mac () in
let pkt =
Arp_packet.encode { Arp_packet.operation = Arp_packet.Reply ;
source_ip = other ; source_mac = omac ;
target_ip = ipaddr ; target_mac = mac }
in
let q = query mac ipaddr other in
let t, r = Arp_handler.query t other (merge 1) in
Alcotest.check qres "r is request wait" (Arp_handler.RequestWait (q, [1])) r ;
let t, outp, w = Arp_handler.input t pkt in
Alcotest.(check (option out) "nothing out" None outp) ;
Alcotest.(check (option (pair m (list int))) "something woken up" (Some (omac, [1])) w) ;
let _t, res = Arp_handler.query t other (merge 2) in
Alcotest.check qres "dynamic entry can be queried" (Arp_handler.Mac omac) res
let reply_in_cache () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~timeout:1 ~ipaddr mac in
let other = gen_ip () in
let omac = gen_mac () in
let pkt =
Arp_packet.encode { Arp_packet.operation = Arp_packet.Reply ;
source_ip = other ; source_mac = omac ;
target_ip = ipaddr ; target_mac = mac }
in
let q = query mac ipaddr other in
let t, r = Arp_handler.query t other (merge 1) in
Alcotest.check qres "r is request wait" (Arp_handler.RequestWait (q, [1])) r ;
let t, outp, w = Arp_handler.input t pkt in
Alcotest.(check (option out) "nothing out" None outp) ;
Alcotest.(check (option (pair m (list int))) "something woken up" (Some (omac, [1])) w) ;
Alcotest.(check (option m) "entry in cache" (Some omac) (Arp_handler.in_cache t other)) ;
Alcotest.(check (list i) "ips do not include dynamic entries" [ipaddr] (Arp_handler.ips t))
let reply_overriden () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~timeout:1 ~ipaddr mac in
let other = gen_ip () in
let omac = gen_mac () in
let pkt =
Arp_packet.encode { Arp_packet.operation = Arp_packet.Reply ;
source_ip = other ; source_mac = omac ;
target_ip = ipaddr ; target_mac = mac }
in
let q = query mac ipaddr other in
let t, r = Arp_handler.query t other (merge 1) in
Alcotest.check qres "r is request wait" (Arp_handler.RequestWait (q, [1])) r ;
let t, outp, w = Arp_handler.input t pkt in
Alcotest.(check (option out) "nothing out" None outp) ;
Alcotest.(check (option (pair m (list int))) "something woken up" (Some (omac, [1])) w) ;
Alcotest.(check (option m) "entry in cache" (Some omac) (Arp_handler.in_cache t other)) ;
let t, outp, w = Arp_handler.input t pkt in
Alcotest.(check (option out) "nothing out" None outp) ;
Alcotest.(check (option (pair m (list int))) "nothing woken up" None w) ;
Alcotest.(check (option m) "entry in cache" (Some omac) (Arp_handler.in_cache t other))
let reply_overriden_other () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~timeout:1 ~ipaddr mac in
let other = gen_ip () in
let omac = gen_mac () in
let pkt =
Arp_packet.encode { Arp_packet.operation = Arp_packet.Reply ;
source_ip = other ; source_mac = omac ;
target_ip = ipaddr ; target_mac = mac }
in
let q = query mac ipaddr other in
let t, r = Arp_handler.query t other (merge 1) in
Alcotest.check qres "r is request wait" (Arp_handler.RequestWait (q, [1])) r ;
let t, outp, w = Arp_handler.input t pkt in
Alcotest.(check (option out) "nothing out" None outp) ;
Alcotest.(check (option (pair m (list int))) "something woken up" (Some (omac, [1])) w) ;
Alcotest.(check (option m) "entry in cache" (Some omac) (Arp_handler.in_cache t other)) ;
let omac = gen_mac () in
let pkt =
Arp_packet.encode { Arp_packet.operation = Arp_packet.Reply ;
source_ip = other ; source_mac = omac ;
target_ip = ipaddr ; target_mac = mac }
in
let t, outp, w = Arp_handler.input t pkt in
Alcotest.(check (option out) "nothing out" None outp) ;
Alcotest.(check (option (pair m (list int))) "nothing woken up" None w) ;
Alcotest.(check (option m) "overriden entry in cache" (Some omac)
(Arp_handler.in_cache t other))
let reply_times_out () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~timeout:1 ~ipaddr mac in
let other = gen_ip () in
let omac = gen_mac () in
let pkt =
Arp_packet.encode { Arp_packet.operation = Arp_packet.Reply ;
source_ip = other ; source_mac = omac ;
target_ip = ipaddr ; target_mac = mac }
in
let q = query mac ipaddr other in
let t, r = Arp_handler.query t other (merge 1) in
Alcotest.check qres "r is request wait" (Arp_handler.RequestWait (q, [1])) r ;
let t, outp, w = Arp_handler.input t pkt in
Alcotest.(check (option out) "nothing out" None outp) ;
Alcotest.(check (option (pair m (list int))) "something woken up" (Some (omac, [1])) w) ;
Alcotest.(check (option m) "entry in cache" (Some omac) (Arp_handler.in_cache t other)) ;
let t, outp, timeout = Arp_handler.tick t in
Alcotest.(check (list out) "request sent" [q] outp) ;
Alcotest.(check (list (list int)) "nothing timed out" [] timeout) ;
let t, outp, timeout = Arp_handler.tick t in
Alcotest.(check (list out) "nada sent" [] outp) ;
Alcotest.(check (list (list int)) "nothing timed out" [] timeout) ;
Alcotest.(check (option m) "entry no longer in cache" None
(Arp_handler.in_cache t other))
let dyn_not_advertised () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~timeout:1 ~ipaddr mac in
let other = gen_ip () in
let omac = gen_mac () in
let pkt =
Arp_packet.encode { Arp_packet.operation = Arp_packet.Reply ;
source_ip = other ; source_mac = omac ;
target_ip = ipaddr ; target_mac = mac }
in
let q = query mac ipaddr other in
let t, r = Arp_handler.query t other (merge 1) in
Alcotest.check qres "r is request wait" (Arp_handler.RequestWait (q, [1])) r ;
let t, outp, w = Arp_handler.input t pkt in
Alcotest.(check (option out) "nothing out" None outp) ;
Alcotest.(check (option (pair m (list int))) "something woken up" (Some (omac, [1])) w) ;
let third = gen_ip ()
and third_mac = gen_mac ()
in
let q, _ = query third_mac third other in
let _, outp, w = Arp_handler.input t (Arp_packet.encode q) in
Alcotest.(check (option out) "request a dynamic entry is not answered" None outp) ;
Alcotest.(check (option (pair m (list int))) "nothing woken up" None w)
let handle_reply_wakesup () =
let mac = gen_mac ()
and ipaddr = gen_ip ()
in
let t, _garp = Arp_handler.create ~timeout:1 ~ipaddr mac in
let other = gen_ip () in
let omac = gen_mac () in
let pkt =
Arp_packet.encode { Arp_packet.operation = Arp_packet.Reply ;
source_ip = other ; source_mac = omac ;
target_ip = ipaddr ; target_mac = mac }
in
let q = query mac ipaddr other in
let t, r = Arp_handler.query t other (merge 1) in
Alcotest.check qres "r is request wait" (Arp_handler.RequestWait (q, [1])) r ;
let t, r = Arp_handler.query t other (merge 2) in
Alcotest.check qres "r is wait" (Arp_handler.Wait [2;1]) r ;
let _, outp, w = Arp_handler.input t pkt in
Alcotest.(check (option out) "nothing out" None outp) ;
Alcotest.(check (option (pair m (list int))) "something woken up" (Some (omac, [2;1])) w)
let handl_tsts = [
"create raises", `Quick, create_raises ;
"basic tests", `Quick, basic_good ;
"remove test", `Quick, remove_good ;
"remove no test", `Quick, remove_no ;
"alias test", `Quick, alias_good ;
"alias remove test", `Quick, alias_remove_inverse ;
"static test", `Quick, static_good ;
"static alias test", `Quick, static_alias_good ;
"more tests", `Quick, more_good ;
"handle good", `Quick, handle_good ;
"handle generates req", `Quick, handle_gen_request ;
"handle generates req, next doesn't", `Quick, handle_gen_request_twice ;
"alias wakes", `Quick, alias_wakes ;
"static wakes", `Quick, static_wakes ;
"handle timeout", `Quick, handle_timeout ;
"request send before timeout", `Quick, req_before_timeout ;
"multiple requests are send", `Quick, multiple_reqs ;
"multiple requests are send 2", `Quick, multiple_reqs_2 ;
"handle reply", `Quick, handle_reply ;
"handle garp", `Quick, handle_garp ;
"answers broadcast request", `Quick, answer_req_broadcast ;
"answers unicast request", `Quick, answer_req_unicast ;
"not answering random request", `Quick, not_answer_req ;
"ignoring random", `Quick, ignoring_random ;
"reply does not harm static entries", `Quick, reply_does_not_override ;
"reply is in cache", `Quick, reply_in_cache ;
"dynamic entry can be queried", `Quick, reply_query ;
"reply times out", `Quick, reply_times_out ;
"dynamic entry overriden by same", `Quick, reply_overriden ;
"dynamic entry overriden by other", `Quick, reply_overriden_other ;
"dynamic entry is not advertised", `Quick, dyn_not_advertised ;
"reply wakes tasks", `Quick, handle_reply_wakesup ;
]
end
let tests = [
"Coder", Coding.coder_tsts ;
"Handler", Handling.handl_tsts ;
]
end
module T = Test(Mirage_random_test)
let () =
Mirage_random_test.initialize () ;
Alcotest.run "ARP tests" T.tests
| |
sc_rollup_commitment_storage.ml | open Sc_rollup_errors
module Store = Storage.Sc_rollup
module Commitment = Sc_rollup_commitment_repr
module Commitment_hash = Commitment.Hash
let get_commitment_unsafe ctxt rollup commitment =
let open Lwt_tzresult_syntax in
let* ctxt, res = Store.Commitments.find (ctxt, rollup) commitment in
match res with
| None -> fail (Sc_rollup_unknown_commitment commitment)
| Some commitment -> return (commitment, ctxt)
let last_cemented_commitment ctxt rollup =
let open Lwt_tzresult_syntax in
let* ctxt, res = Store.Last_cemented_commitment.find ctxt rollup in
match res with
| None -> fail (Sc_rollup_does_not_exist rollup)
| Some lcc -> return (lcc, ctxt)
let get_commitment ctxt rollup commitment =
let open Lwt_tzresult_syntax in
(* Assert that a last cemented commitment exists. *)
let* _lcc, ctxt = last_cemented_commitment ctxt rollup in
get_commitment_unsafe ctxt rollup commitment
let last_cemented_commitment_hash_with_level ctxt rollup =
let open Lwt_tzresult_syntax in
let* commitment_hash, ctxt = last_cemented_commitment ctxt rollup in
if Commitment_hash.(commitment_hash = zero) then
let+ initial_level = Storage.Sc_rollup.Initial_level.get ctxt rollup in
(commitment_hash, initial_level, ctxt)
else
let+ {inbox_level; _}, ctxt =
get_commitment_unsafe ctxt rollup commitment_hash
in
(commitment_hash, inbox_level, ctxt)
let set_commitment_added ctxt rollup node new_value =
let open Lwt_tzresult_syntax in
let* ctxt, res = Store.Commitment_added.find (ctxt, rollup) node in
match res with
| Some old_value ->
(* No need to re-add the read value *)
return (0, old_value, ctxt)
| None ->
let* ctxt, size_diff, _was_bound =
Store.Commitment_added.add (ctxt, rollup) node new_value
in
return (size_diff, new_value, ctxt)
let get_predecessor_unsafe ctxt rollup node =
let open Lwt_tzresult_syntax in
let* commitment, ctxt = get_commitment_unsafe ctxt rollup node in
return (commitment.predecessor, ctxt)
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2022 Nomadic Labs <contact@nomadic-labs.com> *)
(* Copyright (c) 2022 TriliTech <contact@trili.tech> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
logging.mli | val debug : ('a, Format.formatter, unit, unit) format4 -> 'a
val log_info : ('a, Format.formatter, unit, unit) format4 -> 'a
val log_notice : ('a, Format.formatter, unit, unit) format4 -> 'a
val warn : ('a, Format.formatter, unit, unit) format4 -> 'a
val log_error : ('a, Format.formatter, unit, unit) format4 -> 'a
val fatal_error : ('a, Format.formatter, unit, unit) format4 -> 'a
val lwt_debug : ('a, Format.formatter, unit, unit Lwt.t) format4 -> 'a
val lwt_log_info : ('a, Format.formatter, unit, unit Lwt.t) format4 -> 'a
val lwt_log_notice : ('a, Format.formatter, unit, unit Lwt.t) format4 -> 'a
val lwt_warn : ('a, Format.formatter, unit, unit Lwt.t) format4 -> 'a
val lwt_log_error : ('a, Format.formatter, unit, unit Lwt.t) format4 -> 'a
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
parse_php.mli | (* This is the main function. raise Parse_error when not Flag.error_recovery.*)
val parse :
?pp:string option ->
Common.filename ->
(Cst_php.program, Parser_php.token) Parsing_result.t
val parse_program : ?pp:string option -> Common.filename -> Cst_php.program
(* for sgrep/spatch patterns *)
val any_of_string : string -> Cst_php.any
val xdebug_expr_of_string : string -> Cst_php.expr
val expr_of_string : string -> Cst_php.expr
val program_of_string : string -> Cst_php.program
val tokens_of_string : string -> Parser_php.token list
val tmp_php_file_from_string : ?header:string -> string -> Common.filename
val tokens :
?init_state:Lexer_php.state_mode -> Common.filename -> Parser_php.token list
| (* This is the main function. raise Parse_error when not Flag.error_recovery.*)
val parse : |
raw_stubs.c |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <krb5/krb5.h>
#include <netinet/in.h>
#include <errno.h>
#include <caml/mlvalues.h>
#include <caml/memory.h>
#include <caml/alloc.h>
#include <caml/custom.h>
#include <caml/bigarray.h>
#include <caml/fail.h>
#include <caml/threads.h>
#include "ocaml_utils.h"
/* Well, this is nasty. This function is minimally documented (see
https://k5wiki.kerberos.org/wiki/Projects/Services4User#API), but doesn't appear in the
header file. However, we know it exists with this signature from that doc, so if we
declare it here all is well. There's a test that makes use of this inside a Kerberos
sandbox so we should notice if something changes.
We could alternatively use this via GSSAPI, which has an actual public way to use it.
But that involves a ton of extra indirection, and generally feels a bit silly given
that we don't want any of the GSSAPI stuff around it. */
krb5_error_code KRB5_CALLCONV
krb5_get_credentials_for_user(krb5_context context, krb5_flags options,
krb5_ccache ccache, krb5_creds *in_creds,
krb5_data *subject_cert,
krb5_creds **out_creds);
/* Documentation for the krb5 API is available here: http://web.mit.edu/kerberos
The below bindings were originally based off:
http://web.mit.edu/kerberos/krb5-1.14/doc/index.html
The documentation is sometimes pretty lacking; nothing beats looking at the source
code.
*/
/*
*
* Utility functions
*
*/
/* taken from the OCaml source. Internally, OCamls [type inet_addr] is just a pointer
to Linux' [inet_addr_t] = [uint32_t]. So all this does is cast out the type */
#define GET_INET_ADDR(v) ((struct in_addr *) (v))
#define Val_ec(x) caml_copy_int32((x))
/* Outputs a ('a, krb5_error_code) Core.Result.t */
static CAMLprim value
wrap_result(value v_data, krb5_error_code const error)
{
CAMLparam1(v_data);
tag_t tag = 0;
CAMLlocal2(o_result, o_res_val);
if(error == 0)
{
tag = 0;
o_res_val = v_data;
}
else
{
tag = 1;
o_res_val = Val_ec(error);
}
o_result = caml_alloc_small(1, tag);
Field(o_result, 0) = o_res_val;
CAMLreturn(o_result);
}
/*
* No fancy type handling for now.
*/
static struct custom_operations krb_default_ops = {
"com.janestreet.caml.krb",
custom_finalize_default,
custom_compare_default,
custom_hash_default,
custom_serialize_default,
custom_deserialize_default,
custom_compare_default,
#ifdef custom_fixed_length_default
custom_fixed_length_default,
#endif
};
/* Use a token for the context so we don't forget to sequence calls that use the
krb5_context type */
#define SECRET_TOKEN 42
/*
* global singleton krb5_context
*/
krb5_context the_context_INTERNAL = NULL;
value ocaml_context_token = Val_int(SECRET_TOKEN);
CAMLprim value
caml_krb5_init_context_global() {
CAMLparam0();
krb5_error_code retval;
if(the_context_INTERNAL) {
CAMLreturn(wrap_result(ocaml_context_token, 0));
}
caml_release_runtime_system();
retval = krb5_init_context(&the_context_INTERNAL);
caml_acquire_runtime_system();
/* This is not actually needed because [ocaml_context_token] is an int, but it
is included for overall c stub style (and adherence with ocaml documentation). */
caml_register_generational_global_root(&ocaml_context_token);
CAMLreturn(wrap_result(ocaml_context_token, retval));
}
static krb5_context the_context(value v_context_token) {
CAMLparam1(v_context_token);
assert(Int_val(v_context_token) == SECRET_TOKEN);
CAMLreturnT(krb5_context, the_context_INTERNAL);
}
/*
* Hopefully most of the dirty work of creating wrappers is handled here.
* field val contains the krb5_ type val.
*/
#define create_wrap(name) \
CAMLprim value create_ ## name() { \
CAMLparam0(); \
CAMLlocal1(x); \
x = caml_alloc_custom(&krb_default_ops, \
sizeof(struct wrap_ ## name), 0, 1); \
memset(((struct wrap_ ## name *)Data_custom_val(x)), \
0, sizeof(struct wrap_ ## name)); \
CAMLreturn(x); \
}
#define make_wrap(name) \
struct wrap_ ## name { \
name val; \
}; \
create_wrap(name)
#define make_ptr_wrap(name) \
struct wrap_ ## name { \
name *val; \
}; \
create_wrap(name)
/*
*
* Access stuff in the wrappers
*
*/
#define get_custom(name, v) ((struct wrap_ ## name *)Data_custom_val(v))
#define get_val(name, v) (get_custom(name, v)->val)
#define set_val(name, v, new_val) (get_custom(name, (v)))->val = (new_val)
/*
* Create Kerberos type wrappers. We end up with structs and
* functions called create_krb5_<the-type>(void). Semi-colons here
* makes strict compiler flags unhappy. We explicitly don't add finalizers
* here because we must be careful to sequence all calls that use the
* global [krb5_context].
*/
make_wrap(krb5_context)
make_wrap(krb5_principal)
make_wrap(krb5_ccache)
make_wrap(krb5_auth_context)
make_wrap(krb5_keytab)
make_wrap(krb5_kt_cursor)
make_wrap(krb5_cc_cursor)
make_wrap(krb5_creds)
make_wrap(krb5_data)
make_wrap(krb5_enc_data)
make_ptr_wrap(krb5_error)
make_ptr_wrap(krb5_ticket)
make_ptr_wrap(krb5_keytab_entry)
make_ptr_wrap(krb5_keyblock)
make_ptr_wrap(krb5_get_init_creds_opt)
/*
*
* Utility functions
*
*/
/* Copy an ocaml string to a c string. The length of the c string will be the
length of the ocaml string up to the first null byte. */
static char * str_dup(value v_str)
{
CAMLparam1(v_str);
CAMLreturnT(char*, strndup(String_val(v_str), caml_string_length(v_str)));
}
/* Copy the entire contents of an ocaml string (which may include null bytes) to
a char buffer. */
static char * data_dup(value v_str)
{
CAMLparam1(v_str);
char *data = (char*)malloc(caml_string_length(v_str));
memcpy(data, String_val(v_str), caml_string_length(v_str));
CAMLreturnT(char*, data);
}
/*
*
* Kerberos-ish primitives
*
*/
CAMLprim value
caml_krb5_auth_con_init(value v_context_token)
{
CAMLparam1(v_context_token);
CAMLlocal1(o_auth_context);
krb5_context context = the_context(v_context_token);
krb5_error_code retval;
krb5_auth_context auth_context = NULL;
caml_release_runtime_system();
retval = krb5_auth_con_init(context, &auth_context);
caml_acquire_runtime_system();
o_auth_context = create_krb5_auth_context();
set_val(krb5_auth_context, o_auth_context, auth_context);
CAMLreturn(wrap_result(o_auth_context, retval));
}
CAMLprim value
caml_krb5_auth_con_free(value v_context_token, value v_auth_context)
{
CAMLparam2(v_context_token, v_auth_context);
krb5_context context = the_context(v_context_token);
krb5_auth_context auth_context = get_val(krb5_auth_context, v_auth_context);
krb5_auth_con_free(context, auth_context);
CAMLreturn(Val_unit);
}
CAMLprim value
caml_krb5_free_cred_contents(value v_context_token, value v_creds)
{
CAMLparam2(v_context_token, v_creds);
krb5_context context = the_context(v_context_token);
krb5_creds temp_creds = get_val(krb5_creds, v_creds);
krb5_free_cred_contents(context, &temp_creds);
CAMLreturn(Val_unit);
}
CAMLprim value
caml_krb5_default_realm(value v_context_token)
{
CAMLparam1(v_context_token);
CAMLlocal1(o_realm_out);
krb5_context context = the_context(v_context_token);
char* realm_out = NULL;
krb5_error_code retval;
caml_release_runtime_system();
retval = krb5_get_default_realm(context, &realm_out);
caml_acquire_runtime_system();
if (retval)
CAMLreturn(wrap_result(Val_unit, retval));
else
{
o_realm_out = caml_copy_string(realm_out);
krb5_free_default_realm(context, realm_out);
CAMLreturn(wrap_result(o_realm_out, retval));
}
}
CAMLprim value
caml_krb5_parse_name(value v_context_token, value v_name)
{
CAMLparam2(v_context_token, v_name);
CAMLlocal1(o_princ);
krb5_context context = the_context(v_context_token);
krb5_error_code retval;
krb5_principal princ = NULL;
const char *name = String_val(v_name);
retval = krb5_parse_name(context, name, &princ);
if(retval)
CAMLreturn(wrap_result(Val_unit, retval));
else
{
o_princ = create_krb5_principal();
set_val(krb5_principal, o_princ, princ);
CAMLreturn(wrap_result(o_princ, retval));
}
}
CAMLprim value
caml_krb5_unparse_name(value v_context_token, value v_principal)
{
CAMLparam2(v_context_token, v_principal);
CAMLlocal1(s);
krb5_context context = the_context(v_context_token);
krb5_error_code retval;
char *string = NULL;
krb5_principal principal = get_val(krb5_principal, v_principal);
retval = krb5_unparse_name(context, principal, &string);
if(retval)
CAMLreturn(wrap_result(Val_unit, retval));
else
{
s = caml_copy_string(string);
krb5_free_unparsed_name(context, string);
CAMLreturn(wrap_result(s, retval));
}
}
CAMLprim value
caml_krb5_sname_to_principal(value v_context_token, value v_hostname, value v_sname, value v_type) {
CAMLparam4(v_context_token, v_hostname, v_sname, v_type);
CAMLlocal1(o_princ);
krb5_context context = the_context(v_context_token);
krb5_error_code retval;
const char *hostname = str_dup(v_hostname);
const char *sname = str_dup(v_sname);
krb5_int32 type = Bool_val(v_type) ? KRB5_NT_SRV_HST : KRB5_NT_UNKNOWN;
krb5_principal princ = NULL;
caml_release_runtime_system();
retval = krb5_sname_to_principal(context, hostname, sname, type, &princ);
caml_acquire_runtime_system();
if(retval)
CAMLreturn(wrap_result(Val_unit, retval));
else
{
o_princ = create_krb5_principal();
set_val(krb5_principal, o_princ, princ);
CAMLreturn(wrap_result(o_princ, retval));
}
}
CAMLprim value
caml_krb5_kt_close(value v_context_token, value v_keytab)
{
CAMLparam2(v_context_token, v_keytab);
krb5_context context = the_context(v_context_token);
krb5_keytab keytab = get_val(krb5_keytab, v_keytab);
caml_release_runtime_system();
krb5_kt_close(context, keytab);
caml_acquire_runtime_system();
CAMLreturn(Val_unit);
}
CAMLprim value
caml_krb5_kt_resolve(value v_context_token, value v_keytab_name)
{
CAMLparam2(v_context_token, v_keytab_name);
CAMLlocal1(o_keytab);
krb5_context context = the_context(v_context_token);
krb5_error_code retval;
krb5_keytab keytab = NULL;
char *keytab_name = str_dup(v_keytab_name);
caml_release_runtime_system();
retval = krb5_kt_resolve(context, keytab_name, &keytab);
caml_acquire_runtime_system();
free(keytab_name);
o_keytab = create_krb5_keytab();
set_val(krb5_keytab, o_keytab, keytab);
CAMLreturn(wrap_result(o_keytab, retval));
}
CAMLprim value
caml_krb5_free_principal(value v_context_token, value v_principal)
{
CAMLparam2(v_context_token, v_principal);
krb5_context context = the_context(v_context_token);
krb5_principal principal = get_val(krb5_principal, v_principal);
krb5_free_principal(context, principal);
CAMLreturn(Val_unit);
}
/* Outputs a (bigsubstring, krb5_error_code) Core.Result.t */
static CAMLprim value handle_outbuffer(krb5_data *data, krb5_error_code const error)
{
CAMLparam0();
CAMLlocal2(result, res_val);
if(error == 0)
{
long length = data->length;
result = caml_alloc(1, 0);
/* The flag [CAML_BA_MANAGED] is important here. This tells the
OCaml runtime that it "owns" the memory at [data->data] and
tells the built-in finalizer for [Bigarray.t] to free that
memory upon collection.
Note: this means we needn't call [krb5_free_data_contents] for freeing
[struct krb5_data *data]. [krb5_free_data_contents] just calls
[free(data->data)]. The finalizer takes care of this. */
res_val = caml_ba_alloc(
CAML_BA_CHAR | CAML_BA_C_LAYOUT | CAML_BA_MANAGED,
1, data->data, &length);
}
else
{
result = caml_alloc(1, 1);
res_val = Val_ec(error);
}
Store_field(result, 0, res_val);
CAMLreturn(result);
}
/* because Bigstrings/Bigarray's/Bigsubstrings are allocated with malloc,
* I don't have to worry about them being moved by the OCaml garbage
* collector when I release the runtime system */
static krb5_data data_of_bigsubstring(value v_bigsubstring)
{
CAMLparam1(v_bigsubstring);
CAMLlocal1(v_input_data);
krb5_data ret;
int in_pos, in_len;
v_input_data = Field(v_bigsubstring, 0);
in_pos = Int_val(Field(v_bigsubstring, 1));
in_len = Int_val(Field(v_bigsubstring, 2));
ret.data = (char*)Caml_ba_data_val(v_input_data) + in_pos;
ret.length = in_len;
/* This is poorly commented, but I believe this field is only used in
debugging as a tag indicating what type of struct this is (it always shows up
as the first field, so you can find it without knowing what it is). The point
is, it shouldn't matter what we put here since we aren't using krb5 debugging
tools. */
ret.magic = 0;
CAMLreturnT(krb5_data, ret);
}
static krb5_data data_of_bigstring(value v_bigstring)
{
CAMLparam1(v_bigstring);
CAMLlocal1(v_input_data);
krb5_data ret;
ret.data = (char*)Caml_ba_data_val(v_bigstring);
ret.length = Caml_ba_array_val(v_bigstring)->dim[0];
ret.magic = 0;
CAMLreturnT(krb5_data, ret);
}
CAMLprim value
caml_krb5_mk_req_native(value v_context_token, value v_auth_context,
value v_req_flags, value v_servicename, value v_hostname,
value v_ccache)
{
CAMLparam5(v_context_token, v_auth_context, v_req_flags, v_servicename, v_hostname);
CAMLxparam1(v_ccache);
krb5_context context = the_context(v_context_token);
krb5_error_code err;
krb5_data outbuf;
krb5_flags flags = 0;
krb5_auth_context auth_context = get_val(krb5_auth_context, v_auth_context);
krb5_ccache ccache = get_val(krb5_ccache, v_ccache);
char *hostname = str_dup(v_hostname);
char *service = str_dup(v_servicename);
while(v_req_flags != Val_int(0))
{
switch(Int_val(Field(v_req_flags, 0)))
{
case 0: flags |= AP_OPTS_USE_SESSION_KEY; break;
case 1: flags |= AP_OPTS_MUTUAL_REQUIRED; break;
default: caml_invalid_argument(
"caml_krb5_mk_req_native: invalid krb5_mk_req_flag");
};
v_req_flags = Field(v_req_flags, 1);
}
caml_release_runtime_system();
err = krb5_mk_req(
context,
&auth_context,
flags,
service,
hostname,
NULL,
ccache,
&outbuf);
caml_acquire_runtime_system();
free(hostname);
free(service);
CAMLreturn(handle_outbuffer(&outbuf, err));
}
CAMLprim value
caml_krb5_mk_req_bytecode(value *a, int const argn)
{
(void)argn;
return caml_krb5_mk_req_native(a[0], a[1], a[2], a[3], a[4], a[5]);
}
CAMLprim value
caml_krb5_rd_req(value v_context_token, value v_auth_context,
value v_input, value v_principal, value v_keytab_opt)
{
CAMLparam5(v_context_token, v_auth_context, v_input, v_principal, v_keytab_opt);
CAMLlocal2(o_princ, v_keytab);
krb5_context context = the_context(v_context_token);
krb5_auth_context auth_context = get_val(krb5_auth_context, v_auth_context);
krb5_principal principal = get_val(krb5_principal, v_principal);
krb5_keytab keytab;
krb5_principal out_principal;
krb5_error_code err;
krb5_data inputbuf = data_of_bigstring(v_input);
krb5_ticket *ticket = NULL;
if(Is_block(v_keytab_opt)) {
v_keytab = Field(v_keytab_opt, 0);
keytab = get_val(krb5_keytab, v_keytab);
} else {
keytab = NULL;
}
caml_release_runtime_system();
err = krb5_rd_req(
context,
&auth_context,
&inputbuf,
principal,
keytab,
NULL,
&ticket);
caml_acquire_runtime_system();
if(err) {
CAMLreturn(wrap_result(Val_unit, err));
}
err = krb5_copy_principal(context,
ticket->enc_part2->client,
&out_principal);
if(err) {
CAMLreturn(wrap_result(Val_unit, err));
}
o_princ = create_krb5_principal();
set_val(krb5_principal, o_princ, out_principal);
krb5_free_ticket(context, ticket);
CAMLreturn(wrap_result(o_princ, err));
}
CAMLprim value
caml_krb5_mk_rep(value v_context_token, value v_auth_context)
{
CAMLparam2(v_context_token, v_auth_context);
krb5_context context = the_context(v_context_token);
krb5_auth_context auth_context = get_val(krb5_auth_context, v_auth_context);
krb5_data outbuf;
krb5_error_code err;
caml_release_runtime_system();
err = krb5_mk_rep(context, auth_context, &outbuf);
caml_acquire_runtime_system();
CAMLreturn(handle_outbuffer(&outbuf, err));
}
CAMLprim value
caml_krb5_rd_rep(value v_context_token, value v_auth_context, value v_input)
{
CAMLparam3(v_context_token, v_auth_context, v_input);
krb5_context context = the_context(v_context_token);
krb5_auth_context auth_context = get_val(krb5_auth_context, v_auth_context);
krb5_data inputbuf = data_of_bigstring(v_input);
krb5_error_code err;
krb5_ap_rep_enc_part *repl;
caml_release_runtime_system();
err = krb5_rd_rep(context, auth_context, &inputbuf, &repl);
caml_acquire_runtime_system();
krb5_free_ap_rep_enc_part(context, repl);
CAMLreturn(wrap_result(Val_unit, err));
}
CAMLprim value
caml_krb5_auth_con_setflags(value v_context_token, value v_auth_context, value v_flags)
{
CAMLparam3(v_context_token, v_auth_context, v_flags);
krb5_context context = the_context(v_context_token);
krb5_int32 flags = 0;
krb5_auth_context auth_context = get_val(krb5_auth_context, v_auth_context);
while(v_flags != Val_int(0))
{
switch(Int_val(Field(v_flags, 0)))
{
case 0: flags |= KRB5_AUTH_CONTEXT_DO_TIME; break;
case 1: flags |= KRB5_AUTH_CONTEXT_RET_TIME; break;
case 2: flags |= KRB5_AUTH_CONTEXT_DO_SEQUENCE; break;
case 3: flags |= KRB5_AUTH_CONTEXT_RET_SEQUENCE; break;
default: caml_invalid_argument("caml_krb5_mk_con_setflags: invalid krb5_auth_context_flag");
}
v_flags = Field(v_flags, 1);
}
krb5_auth_con_setflags(context, auth_context, flags);
CAMLreturn(Val_unit);
}
CAMLprim value
caml_krb5_auth_con_setaddrs_compat(value v_context_token, value v_auth_context,
value v_local_port, value v_remote_port)
{
CAMLparam4(v_context_token, v_auth_context, v_local_port, v_remote_port);
krb5_auth_context auth_context = get_val(krb5_auth_context, v_auth_context);
krb5_address local_addr;
krb5_address remote_addr;
krb5_error_code err;
/* unsigned short is the type of sockaddr_in.sin_port */
unsigned short local_port = htons(Int_val(v_local_port));
unsigned short remote_port = htons(Int_val(v_remote_port));
local_addr.addrtype = ADDRTYPE_IPPORT;
local_addr.length = sizeof(local_port);
local_addr.contents = (krb5_octet*)&local_port;
remote_addr.addrtype = ADDRTYPE_IPPORT;
remote_addr.length = sizeof(remote_port);
remote_addr.contents = (krb5_octet*)&remote_port;
err = krb5_auth_con_setaddrs(
the_context(v_context_token), auth_context,
&local_addr, &remote_addr);
CAMLreturn(wrap_result(Val_unit, err));
}
/* [caml_krb5_auth_con_setaddrs] sets IPv4 local&remote addrs&ports in krb auth_context.
* It is compatible with what [krb5_auth_con_genaddrs] [0,1] does, but takes addrs as
* arguments, instead of fetching them from the socket file descriptor.
*
* [0] (with all KRB5_AUTH_CONTEXT_GENERATE_{LOCAL,REMOTE}{,_FULL}_ADDR)
* [1] https://github.com/krb5/krb5/blob/master/src/lib/krb5/os/genaddrs.c#L65
* */
CAMLprim value
caml_krb5_auth_con_setaddrs(value v_context_token, value v_auth_context,
value v_local_port, value v_remote_port,
value v_local_addr, value v_remote_addr)
{
CAMLparam5(v_context_token, v_auth_context, v_local_port, v_remote_port, v_local_addr);
CAMLxparam1(v_remote_addr);
krb5_auth_context auth_context = get_val(krb5_auth_context, v_auth_context);
struct in_addr local_addr;
struct in_addr remote_addr;
krb5_address krb_local_addr;
krb5_address krb_remote_addr;
krb5_address krb_local_port;
krb5_address krb_remote_port;
krb5_error_code err;
/* unsigned short is the type of sockaddr_in.sin_port */
unsigned short local_port = htons(Int_val(v_local_port));
unsigned short remote_port = htons(Int_val(v_remote_port));
/* convert back int32 from [core_unix_inet4_addr_to_int32_exn] */
local_addr.s_addr = ntohl(Int32_val(v_local_addr));
remote_addr.s_addr = ntohl(Int32_val(v_remote_addr));
krb_local_port.addrtype = ADDRTYPE_IPPORT;
krb_local_port.length = sizeof(local_port);
krb_local_port.contents = (krb5_octet*)&local_port;
krb_remote_port.addrtype = ADDRTYPE_IPPORT;
krb_remote_port.length = sizeof(remote_port);
krb_remote_port.contents = (krb5_octet*)&remote_port;
krb_local_addr.addrtype = ADDRTYPE_INET;
krb_local_addr.length = sizeof(local_addr);
krb_local_addr.contents = (krb5_octet*)&local_addr;
krb_remote_addr.addrtype = ADDRTYPE_INET;
krb_remote_addr.length = sizeof(remote_addr);
krb_remote_addr.contents = (krb5_octet*)&remote_addr;
err = krb5_auth_con_setaddrs(
the_context(v_context_token), auth_context,
&krb_local_addr, &krb_remote_addr);
if(err != 0) {
CAMLreturn(wrap_result(Val_unit, err));
}
err = krb5_auth_con_setports(
the_context(v_context_token), auth_context,
&krb_local_port, &krb_remote_port);
CAMLreturn(wrap_result(Val_unit, err));
}
CAMLprim value caml_krb5_auth_con_setaddrs_bytecode(value * argv, int argn) {
assert(argn == 6);
return caml_krb5_auth_con_setaddrs(
argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
}
typedef krb5_error_code
(*priv_msg_func)(
krb5_context,
krb5_auth_context,
krb5_data const*,
krb5_data*,
krb5_replay_data*);
static CAMLprim value
krb5_msg_func(value v_context_token, value v_auth_context, value v_in, priv_msg_func msg_func)
{
CAMLparam3(v_context_token, v_auth_context, v_in);
krb5_context context = the_context(v_context_token);
krb5_auth_context auth_context = get_val(krb5_auth_context, v_auth_context);
krb5_error_code err;
krb5_data inputbuf, outbuf;
inputbuf = data_of_bigsubstring(v_in);
caml_release_runtime_system();
err = msg_func(
context,
auth_context,
&inputbuf,
&outbuf, NULL);
caml_acquire_runtime_system();
CAMLreturn(handle_outbuffer(&outbuf, err));
}
CAMLprim value
caml_krb5_mk_priv(value v_context_token, value v_auth_context, value v_in)
{ return krb5_msg_func(v_context_token, v_auth_context, v_in, krb5_mk_priv); }
CAMLprim value
caml_krb5_rd_priv(value v_context_token, value v_auth_context, value v_in)
{ return krb5_msg_func(v_context_token, v_auth_context, v_in, krb5_rd_priv); }
CAMLprim value
caml_krb5_c_decrypt_native(value v_context_token, value v_keyblock,
value v_usage, value v_enc_type, value v_kvno, value v_in)
{
CAMLparam5(v_context_token, v_keyblock, v_usage, v_enc_type, v_kvno);
CAMLxparam1(v_in);
krb5_error_code err;
krb5_context context = the_context(v_context_token);
krb5_keyblock* keyblock;
krb5_keyusage usage;
krb5_enc_data enc_part;
krb5_data outbuf;
keyblock = get_val(krb5_keyblock, v_keyblock);
usage = Int_val(v_usage);
enc_part.enctype = Int_val(v_enc_type);
enc_part.kvno = Int_val(v_kvno);
enc_part.ciphertext = data_of_bigsubstring(v_in);
outbuf.length = enc_part.ciphertext.length;
caml_release_runtime_system();
if ((outbuf.data = malloc(outbuf.length))) {
err = krb5_c_decrypt(
context,
keyblock,
usage,
NULL, /* cipher_state */
&enc_part,
&outbuf);
} else {
err = ENOMEM;
}
caml_acquire_runtime_system();
CAMLreturn(handle_outbuffer(&outbuf, err));
}
CAMLprim value
caml_krb5_c_decrypt_bytecode(value *a, int const argn)
{
(void)argn;
assert(argn == 6);
return caml_krb5_c_decrypt_native(a[0], a[1], a[2], a[3], a[4], a[5]);
}
CAMLprim value
caml_krb5_mk_safe(value v_context_token, value v_auth_context, value v_in)
{ return krb5_msg_func(v_context_token, v_auth_context, v_in, krb5_mk_safe); }
CAMLprim value
caml_krb5_rd_safe(value v_context_token, value v_auth_context, value v_in)
{ return krb5_msg_func(v_context_token, v_auth_context, v_in, krb5_rd_safe); }
CAMLprim value
caml_krb5_get_error_message(value v_context_token_opt, value v_error_code)
{
CAMLparam2(v_context_token_opt, v_error_code);
CAMLlocal1(o_error_message);
const char *error_message = NULL;
krb5_error_code error_code = Int32_val(v_error_code);
krb5_context context = NULL;
if(Is_block(v_context_token_opt)) {
context = the_context(Field(v_context_token_opt, 0));
}
caml_release_runtime_system();
error_message = krb5_get_error_message(context, error_code);
caml_acquire_runtime_system();
o_error_message = caml_copy_string(error_message);
krb5_free_error_message(context, error_message);
CAMLreturn(o_error_message);
}
CAMLprim value
caml_krb5_get_init_creds_opt_alloc(value v_context_token,
value v_tkt_life,
value v_renew_life,
value v_forwardable,
value v_proxiable)
{
CAMLparam5(v_context_token, v_tkt_life, v_renew_life, v_forwardable, v_proxiable);
CAMLlocal1(o_opts);
krb5_context context = the_context(v_context_token);
int tkt_life = Int_val(v_tkt_life);
int renew_life = Int_val(v_renew_life);
int forwardable = Bool_val(v_forwardable);
int proxiable = Bool_val(v_proxiable);
krb5_get_init_creds_opt *opts;
krb5_error_code retval;
retval = krb5_get_init_creds_opt_alloc(context, &opts);
if (!retval) {
krb5_get_init_creds_opt_set_tkt_life (opts, (krb5_deltat)tkt_life);
krb5_get_init_creds_opt_set_renew_life(opts, (krb5_deltat)renew_life);
krb5_get_init_creds_opt_set_forwardable (opts, forwardable);
krb5_get_init_creds_opt_set_proxiable (opts, proxiable);
o_opts = create_krb5_get_init_creds_opt();
set_val(krb5_get_init_creds_opt, o_opts, opts);
}
CAMLreturn(wrap_result(o_opts, retval));
}
CAMLprim value
caml_krb5_get_init_creds_opt_free(value v_context_token, value v_opts)
{
CAMLparam2(v_context_token, v_opts);
krb5_context context = the_context(v_context_token);
krb5_get_init_creds_opt *opts = get_val(krb5_get_init_creds_opt, v_opts);
krb5_get_init_creds_opt_free(context, opts);
CAMLreturn(Val_unit);
}
CAMLprim value
caml_krb5_get_init_creds_password(value v_context_token, value v_tkt_service_opt,
value v_options, value v_client, value v_password)
{
CAMLparam5(v_context_token, v_tkt_service_opt, v_options, v_client, v_password);
CAMLlocal1(o_creds);
krb5_context context = the_context(v_context_token);
krb5_error_code err;
krb5_creds creds;
krb5_get_init_creds_opt *opt = get_val(krb5_get_init_creds_opt, v_options);
krb5_principal client = get_val(krb5_principal, v_client);
char *password = str_dup(v_password);
char *tkt_service = NULL; /* Ticket granting service */
if(Is_block(v_tkt_service_opt)) {
tkt_service = str_dup(Field(v_tkt_service_opt, 0));
}
caml_release_runtime_system();
err = krb5_get_init_creds_password(context,
&creds,
client,
password,
NULL, /* Don't need prompter */
NULL, /* Don't need prompter data */
0, /* Ticket becomes valid now */
tkt_service,
opt);
caml_acquire_runtime_system();
free(password);
free(tkt_service);
o_creds = create_krb5_creds();
set_val(krb5_creds, o_creds, creds);
CAMLreturn(wrap_result(o_creds, err));
}
CAMLprim value
caml_krb5_get_init_creds_keytab(value v_context_token, value v_tkt_service_opt,
value v_options, value v_client, value v_keytab)
{
CAMLparam5(v_context_token, v_tkt_service_opt, v_options, v_client, v_keytab);
CAMLlocal1(o_creds);
krb5_context context = the_context(v_context_token);
krb5_error_code err;
krb5_creds creds;
krb5_get_init_creds_opt *opt = get_val(krb5_get_init_creds_opt, v_options);
krb5_principal client = get_val(krb5_principal, v_client);
krb5_keytab keytab = get_val(krb5_keytab, v_keytab);
char *tkt_service = NULL; /* Ticket granting service */
if(Is_block(v_tkt_service_opt)) {
tkt_service = str_dup(Field(v_tkt_service_opt, 0));
}
caml_release_runtime_system();
err = krb5_get_init_creds_keytab(context,
&creds,
client,
keytab,
0, /* Ticket becomes valid now */
tkt_service,
opt);
caml_acquire_runtime_system();
free(tkt_service);
o_creds = create_krb5_creds();
set_val(krb5_creds, o_creds, creds);
CAMLreturn(wrap_result(o_creds, err));
}
CAMLprim value
caml_krb5_get_renewed_creds(value v_context_token, value v_client, value v_ccache,
value v_tkt_service)
{
CAMLparam4(v_context_token, v_client, v_ccache, v_tkt_service);
CAMLlocal1(o_creds);
krb5_context context = the_context(v_context_token);
krb5_error_code err;
krb5_creds creds;
krb5_principal client = get_val(krb5_principal, v_client);
krb5_ccache ccache = get_val(krb5_ccache, v_ccache);
char *tkt_service = str_dup(v_tkt_service);
caml_release_runtime_system();
err = krb5_get_renewed_creds(context,
&creds,
client,
ccache,
tkt_service);
caml_acquire_runtime_system();
free(tkt_service);
o_creds = create_krb5_creds();
set_val(krb5_creds, o_creds, creds);
CAMLreturn(wrap_result(o_creds, err));
}
/* credential cache management stubs */
CAMLprim value
caml_krb5_cc_default(value v_context_token) {
CAMLparam1(v_context_token);
CAMLlocal1(o_ccache);
krb5_context context = the_context(v_context_token);
krb5_error_code retval;
krb5_ccache ccache = NULL;
caml_release_runtime_system();
retval = krb5_cc_default(context, &ccache);
caml_acquire_runtime_system();
o_ccache = create_krb5_ccache();
set_val(krb5_ccache, o_ccache, ccache);
CAMLreturn(wrap_result(o_ccache, retval));
}
CAMLprim value
caml_krb5_cc_initialize(value v_context_token, value v_ccache, value v_principal)
{
CAMLparam3(v_context_token, v_ccache, v_principal);
krb5_context context = the_context(v_context_token);
krb5_error_code retval;
krb5_ccache ccache = get_val(krb5_ccache, v_ccache);
krb5_principal principal = get_val(krb5_principal, v_principal);
caml_release_runtime_system();
retval = krb5_cc_initialize(context, ccache, principal);
caml_acquire_runtime_system();
CAMLreturn(wrap_result(Val_unit, retval));
}
CAMLprim value
caml_krb5_cc_get_principal(value v_context_token, value v_ccache) {
CAMLparam2(v_context_token, v_ccache);
CAMLlocal1(o_princ);
krb5_context context = the_context(v_context_token);
krb5_error_code retval;
krb5_principal princ = NULL;
krb5_ccache ccache = get_val(krb5_ccache, v_ccache);
caml_release_runtime_system();
retval = krb5_cc_get_principal(context, ccache, &princ);
caml_acquire_runtime_system();
o_princ = create_krb5_principal();
set_val(krb5_principal, o_princ, princ);
CAMLreturn(wrap_result(o_princ, retval));
}
CAMLprim value
caml_krb5_cc_cache_match(value v_context_token, value v_principal)
{
CAMLparam2(v_context_token, v_principal);
CAMLlocal1(o_ccache);
krb5_context context = the_context(v_context_token);
krb5_ccache ccache;
krb5_error_code retval;
krb5_principal principal = get_val(krb5_principal, v_principal);
caml_release_runtime_system();
retval = krb5_cc_cache_match(context, principal, &ccache);
caml_acquire_runtime_system();
o_ccache = create_krb5_ccache();
set_val(krb5_ccache, o_ccache, ccache);
CAMLreturn(wrap_result(o_ccache, retval));
}
CAMLprim value
caml_krb5_cc_resolve(value v_context_token, value v_path)
{
CAMLparam2(v_context_token, v_path);
CAMLlocal1(o_ccache);
krb5_context context = the_context(v_context_token);
krb5_ccache ccache;
krb5_error_code retval;
char *path = str_dup(v_path);
caml_release_runtime_system();
retval = krb5_cc_resolve(context, path, &ccache);
caml_acquire_runtime_system();
free(path);
o_ccache = create_krb5_ccache();
set_val(krb5_ccache, o_ccache, ccache);
CAMLreturn(wrap_result(o_ccache, retval));
}
CAMLprim value
caml_krb5_cc_get_type(value v_context_token, value v_ccache)
{
CAMLparam2(v_context_token, v_ccache);
CAMLlocal1(o_type);
krb5_context context = the_context(v_context_token);
krb5_ccache ccache = get_val(krb5_ccache, v_ccache);
const char* type;
int len;
type = krb5_cc_get_type(context, ccache);
len = strlen(type);
o_type = caml_alloc_initialized_string(len, type);
CAMLreturn(o_type);
}
CAMLprim value
caml_krb5_cc_new_unique(value v_context_token, value v_type)
{
CAMLparam2(v_context_token, v_type);
CAMLlocal1(o_ccache);
krb5_context context = the_context(v_context_token);
krb5_error_code retval;
krb5_ccache ccache;
char *type = str_dup(v_type);
caml_release_runtime_system();
/* the docs say the hint argument is unused. */
retval = krb5_cc_new_unique(context, type, NULL, &ccache);
caml_acquire_runtime_system();
free(type);
o_ccache = create_krb5_ccache();
set_val(krb5_ccache, o_ccache, ccache);
CAMLreturn(wrap_result(o_ccache, retval));
}
CAMLprim value
caml_krb5_cc_close(value v_context_token, value v_ccache)
{
CAMLparam2(v_context_token, v_ccache);
krb5_context context = the_context(v_context_token);
krb5_ccache ccache = get_val(krb5_ccache, v_ccache);
caml_release_runtime_system();
/* This function can return an error, but we call it as a finalizer. Since the intent is
to close and discard the credentials cache, there is nothing useful we could do in
the error case, so we ignore it.
*/
krb5_cc_close(context, ccache);
caml_acquire_runtime_system();
CAMLreturn(Val_unit);
}
CAMLprim value
caml_krb5_cc_get_full_name(value v_context_token, value v_ccache)
{
CAMLparam2(v_context_token, v_ccache);
CAMLlocal1(o_fullname_out);
krb5_context context = the_context(v_context_token);
char *fullname_out = NULL;
krb5_error_code retval;
krb5_ccache ccache = get_val(krb5_ccache, v_ccache);
caml_release_runtime_system();
retval = krb5_cc_get_full_name(context, ccache, &fullname_out);
caml_acquire_runtime_system();
/* wrap_result will ignore o_fullname_out if retval != 0 so its ok
for o_fullname_out to be uninitialized. */
if (retval == 0) {
o_fullname_out = caml_copy_string(fullname_out);
krb5_free_string(context, fullname_out);
}
CAMLreturn(wrap_result(o_fullname_out, retval));
}
CAMLprim value
caml_krb5_cc_store_cred(value v_context_token, value v_cache, value v_creds)
{
CAMLparam3(v_context_token, v_cache, v_creds);
krb5_context context = the_context(v_context_token);
krb5_error_code retval;
krb5_ccache cache = get_val(krb5_ccache, v_cache);
krb5_creds creds = get_val(krb5_creds, v_creds);
caml_release_runtime_system();
retval = krb5_cc_store_cred(context, cache, &creds);
caml_acquire_runtime_system();
CAMLreturn(wrap_result(Val_unit, retval));
}
CAMLprim value
caml_krb5_cc_start_seq_get(value v_context_token, value v_cache)
{
CAMLparam2(v_context_token, v_cache);
CAMLlocal1(o_cursor);
krb5_context context = the_context(v_context_token);
krb5_ccache cache;
krb5_cc_cursor cursor;
krb5_error_code retval;
cache = get_val(krb5_ccache, v_cache);
caml_release_runtime_system();
retval = krb5_cc_start_seq_get(context, cache, &cursor);
caml_acquire_runtime_system();
o_cursor = create_krb5_cc_cursor();
set_val(krb5_cc_cursor, o_cursor, cursor);
CAMLreturn(wrap_result(o_cursor, retval));
}
CAMLprim value
caml_krb5_cc_next_cred(value v_context_token, value v_cache, value v_cursor)
{
CAMLparam3(v_context_token, v_cache, v_cursor);
CAMLlocal3(o_creds, o_tuple, o_option);
krb5_context context = the_context(v_context_token);
krb5_ccache cache;
krb5_cc_cursor cursor;
krb5_creds creds;
krb5_error_code retval;
cache = get_val(krb5_ccache, v_cache);
cursor = get_val(krb5_cc_cursor, v_cursor);
caml_release_runtime_system();
retval = krb5_cc_next_cred(context, cache, &cursor, &creds);
caml_acquire_runtime_system();
if (retval == KRB5_CC_END) {
CAMLreturn(wrap_result(Val_none, 0));
}
else if (retval) {
CAMLreturn(wrap_result(Val_unit, retval));
}
else {
/* Some credential cache implementations (e.g. FILE) mutate the contents of the cursor
while others (e.g. MEMORY) mutate the supplied cursor pointer. We make sure to
update [v_cursor] in case the pointer was changed. */
set_val(krb5_cc_cursor, v_cursor, cursor);
o_creds = create_krb5_creds();
set_val(krb5_creds, o_creds, creds);
o_option = caml_alloc_some(o_creds);
CAMLreturn(wrap_result(o_option, retval));
}
}
CAMLprim value
caml_krb5_cc_end_seq_get(value v_context_token, value v_cache, value v_cursor)
{
CAMLparam3(v_context_token, v_cache, v_cursor);
krb5_context context = the_context(v_context_token);
krb5_ccache cache;
krb5_cc_cursor cursor;
krb5_error_code retval;
cache = get_val(krb5_ccache, v_cache);
cursor = get_val(krb5_cc_cursor, v_cursor);
caml_release_runtime_system();
retval = krb5_cc_end_seq_get(context, cache, &cursor);
caml_acquire_runtime_system();
CAMLreturn(wrap_result(Val_unit, retval));
}
CAMLprim value
caml_krb5_string_to_enctype(value v_string)
{
CAMLparam1(v_string);
krb5_error_code retval;
krb5_enctype enctype;
char *enctypestr = str_dup(v_string);
caml_release_runtime_system();
retval = krb5_string_to_enctype(enctypestr, &enctype);
caml_acquire_runtime_system();
free(enctypestr);
CAMLreturn(wrap_result(Val_int(enctype), retval));
}
CAMLprim value
caml_krb5_principal2salt(value v_context_token, value v_principal)
{
CAMLparam2(v_context_token, v_principal);
CAMLlocal1(o_salt);
krb5_context context = the_context(v_context_token);
krb5_error_code retval;
krb5_principal principal;
krb5_data salt;
principal = get_val(krb5_principal, v_principal);
caml_release_runtime_system();
retval = krb5_principal2salt(context, principal, &salt);
caml_acquire_runtime_system();
o_salt = create_krb5_data();
set_val(krb5_data, o_salt, salt);
CAMLreturn(wrap_result(o_salt, retval));
}
CAMLprim value
caml_krb5_is_config_principal(value v_context_token, value v_principal)
{
CAMLparam2(v_context_token, v_principal);
krb5_context context = the_context(v_context_token);
krb5_principal principal;
krb5_boolean is_config_principal;
principal = get_val(krb5_principal, v_principal);
caml_release_runtime_system();
is_config_principal = krb5_is_config_principal(context, principal);
caml_acquire_runtime_system();
if (is_config_principal == TRUE) {
CAMLreturn(Val_true);
} else {
CAMLreturn(Val_false);
}
}
CAMLprim value
caml_krb5_free_data_contents(value v_context_token, value v_data)
{
CAMLparam2(v_context_token, v_data);
krb5_context context = the_context(v_context_token);
krb5_data data = get_val(krb5_data, v_data);
krb5_free_data_contents(context, &data);
CAMLreturn(Val_unit);
}
CAMLprim value
caml_krb5_create_keyblock_from_key_data(value v_context_token, value v_enctype, value v_keydata) {
CAMLparam3(v_context_token, v_enctype, v_keydata);
CAMLlocal1(o_keyblock);
krb5_context context = the_context(v_context_token);
krb5_enctype enctype = (krb5_enctype)Int_val(v_enctype);
krb5_data in_data;
krb5_error_code retval;
krb5_keyblock *keyblock = NULL;
in_data = data_of_bigstring(v_keydata);
retval = krb5_init_keyblock(context, enctype, in_data.length, &keyblock);
if (retval) {
CAMLreturn(wrap_result(Val_unit, retval));
}
memcpy(keyblock->contents, in_data.data, in_data.length);
o_keyblock = create_krb5_keyblock();
set_val(krb5_keyblock, o_keyblock, keyblock);
CAMLreturn(wrap_result(o_keyblock, retval));
}
CAMLprim value
caml_krb5_c_string_to_key(value v_context_token, value v_enctype, value v_string, value v_salt)
{
CAMLparam4(v_context_token, v_enctype, v_string, v_salt);
CAMLlocal1(o_keyblock);
krb5_context context = the_context(v_context_token);
krb5_enctype enctype = (krb5_enctype)Int_val(v_enctype);
krb5_data in_salt = get_val(krb5_data, v_salt);
krb5_error_code retval;
krb5_keyblock *keyblock = NULL;
krb5_data in_string;
in_string.length = caml_string_length(v_string);
in_string.data = data_dup(v_string);
retval = krb5_init_keyblock(context, enctype, 0, &keyblock);
if(retval) {
krb5_free_data_contents(context, &in_string);
CAMLreturn(wrap_result(Val_unit, retval));
}
caml_release_runtime_system();
retval = krb5_c_string_to_key(context, enctype, &in_string, &in_salt, keyblock);
caml_acquire_runtime_system();
krb5_free_data_contents(context, &in_string);
if(retval) {
krb5_free_keyblock(context, keyblock);
CAMLreturn(wrap_result(Val_unit, retval));
} else {
o_keyblock = create_krb5_keyblock();
set_val(krb5_keyblock, o_keyblock, keyblock);
CAMLreturn(wrap_result(o_keyblock, retval));
}
}
CAMLprim value
caml_krb5_kt_add_entry(value v_context_token, value v_keytab, value v_keytab_entry)
{
CAMLparam3(v_context_token, v_keytab, v_keytab_entry);
krb5_context context = the_context(v_context_token);
krb5_keytab keytab;
krb5_error_code retval;
krb5_keytab_entry *keytab_entry;
keytab = get_val(krb5_keytab, v_keytab);
keytab_entry = get_val(krb5_keytab_entry, v_keytab_entry);
caml_release_runtime_system();
retval = krb5_kt_add_entry(context, keytab, keytab_entry);
caml_acquire_runtime_system();
CAMLreturn(wrap_result(Val_unit, retval));
}
CAMLprim value
caml_krb5_kt_remove_entry(value v_context_token, value v_keytab, value v_keytab_entry)
{
CAMLparam3(v_context_token, v_keytab, v_keytab_entry);
krb5_context context = the_context(v_context_token);
krb5_keytab keytab;
krb5_error_code retval;
krb5_keytab_entry *keytab_entry;
keytab = get_val(krb5_keytab, v_keytab);
keytab_entry = get_val(krb5_keytab_entry, v_keytab_entry);
caml_release_runtime_system();
retval = krb5_kt_remove_entry(context, keytab, keytab_entry);
caml_acquire_runtime_system();
CAMLreturn(wrap_result(Val_unit, retval));
}
CAMLprim value
caml_krb5_kt_start_seq_get(value v_context_token, value v_keytab)
{
CAMLparam2(v_context_token, v_keytab);
CAMLlocal1(o_cursor);
krb5_context context = the_context(v_context_token);
krb5_keytab keytab;
krb5_kt_cursor cursor;
krb5_error_code retval;
keytab = get_val(krb5_keytab, v_keytab);
caml_release_runtime_system();
retval = krb5_kt_start_seq_get(context, keytab, &cursor);
caml_acquire_runtime_system();
o_cursor = create_krb5_kt_cursor();
set_val(krb5_kt_cursor, o_cursor, cursor);
CAMLreturn(wrap_result(o_cursor, retval));
}
CAMLprim value
caml_krb5_kt_next_entry(value v_context_token, value v_keytab, value v_cursor)
{
CAMLparam3(v_context_token, v_keytab, v_cursor);
CAMLlocal3(o_entry, o_tuple, o_option);
krb5_context context = the_context(v_context_token);
krb5_keytab keytab;
krb5_kt_cursor cursor;
krb5_keytab_entry *entry;
krb5_error_code retval;
keytab = get_val(krb5_keytab, v_keytab);
cursor = get_val(krb5_kt_cursor, v_cursor);
entry = malloc(sizeof(*entry));
memset(entry, 0, sizeof(*entry));
caml_release_runtime_system();
retval = krb5_kt_next_entry(context, keytab, entry, &cursor);
caml_acquire_runtime_system();
if (retval == KRB5_KT_END) {
free(entry);
CAMLreturn(wrap_result(Val_none, 0));
}
else if (retval) {
free(entry);
CAMLreturn(wrap_result(Val_unit, retval));
}
else {
/* See comment on [caml_krb5_cc_next_cred]. */
set_val(krb5_kt_cursor, v_cursor, cursor);
o_entry = create_krb5_keytab_entry();
set_val(krb5_keytab_entry, o_entry, entry);
o_option = caml_alloc_some(o_entry);
CAMLreturn(wrap_result(o_option, retval));
}
}
CAMLprim value
caml_krb5_kt_end_seq_get(value v_context_token, value v_keytab, value v_cursor)
{
CAMLparam3(v_context_token, v_keytab, v_cursor);
krb5_context context = the_context(v_context_token);
krb5_keytab keytab;
krb5_kt_cursor cursor;
krb5_error_code retval;
keytab = get_val(krb5_keytab, v_keytab);
cursor = get_val(krb5_kt_cursor, v_cursor);
caml_release_runtime_system();
retval = krb5_kt_end_seq_get(context, keytab, &cursor);
caml_acquire_runtime_system();
CAMLreturn(wrap_result(Val_unit, retval));
}
CAMLprim value
caml_krb5_create_keytab_entry(value v_context_token, value v_principal,
value v_kvno, value v_keyblock)
{
CAMLparam4(v_context_token, v_principal, v_kvno, v_keyblock);
CAMLlocal1(o_keytab_entry);
krb5_context context = the_context(v_context_token);
krb5_principal principal;
krb5_principal principal_copy;
krb5_error_code retval_principal = 0;
krb5_timestamp timestamp;
krb5_kvno kvno;
krb5_keyblock *keyblock;
krb5_keyblock *keyblock_copy = NULL;
krb5_error_code retval_keyblock = 0;
krb5_keytab_entry *keytab_entry;
krb5_error_code retval = 0;
principal = get_val(krb5_principal, v_principal);
kvno = (krb5_kvno) (Int_val(v_kvno));
keyblock = get_val(krb5_keyblock, v_keyblock);
retval = krb5_timeofday(context, ×tamp);
if (retval) {
CAMLreturn(wrap_result(Val_unit, retval));
}
/* We must copy the keyblock and the principal because
[krb5_free_keytab_entry_contents] frees both of these. */
retval_keyblock = krb5_copy_keyblock(context, keyblock, &keyblock_copy);
retval_principal = krb5_copy_principal(context, principal, &principal_copy);
if(retval_keyblock || retval_principal) {
krb5_free_keyblock(context, keyblock_copy);
krb5_free_principal(context, principal_copy);
retval = (retval_keyblock != 0) ? retval_keyblock : retval_principal;
CAMLreturn(wrap_result(Val_unit, retval));
}
else {
keytab_entry = (krb5_keytab_entry *) malloc(sizeof(krb5_keytab_entry));
memset(keytab_entry, 0, sizeof(*keytab_entry));
keytab_entry->principal = principal_copy;
keytab_entry->timestamp = timestamp;
keytab_entry->vno = kvno;
/* This creates a shallow copy of [keyblock_copy], thus we need to free the struct
itself, but not the contained data. */
keytab_entry->key = *keyblock_copy;
free(keyblock_copy);
o_keytab_entry = create_krb5_keytab_entry();
set_val(krb5_keytab_entry, o_keytab_entry, keytab_entry);
CAMLreturn(wrap_result(o_keytab_entry, retval));
}
}
CAMLprim value
caml_krb5_keytab_entry_get_kvno(value v_entry)
{
CAMLparam1(v_entry);
krb5_keytab_entry *entry;
krb5_kvno kvno;
entry = get_val(krb5_keytab_entry, v_entry);
kvno = entry->vno;
CAMLreturn(Val_int (kvno));
}
CAMLprim value
caml_krb5_keytab_entry_get_principal(value v_context_token, value v_entry)
{
CAMLparam1(v_entry);
CAMLlocal1(o_principal);
krb5_context context = the_context(v_context_token);
krb5_error_code retval;
krb5_keytab_entry *entry;
krb5_principal principal;
entry = get_val(krb5_keytab_entry, v_entry);
retval = krb5_copy_principal(context, entry->principal, &principal);
o_principal = create_krb5_principal();
set_val(krb5_principal, o_principal, principal);
CAMLreturn(wrap_result(o_principal, retval));
}
CAMLprim value
caml_krb5_keytab_entry_get_keyblock(value v_context_token, value v_entry)
{
CAMLparam1(v_entry);
CAMLlocal1(o_keyblock);
krb5_context context = the_context(v_context_token);
krb5_error_code retval;
krb5_keytab_entry *entry;
krb5_keyblock *keyblock;
entry = get_val(krb5_keytab_entry, v_entry);
retval = krb5_copy_keyblock(context, &(entry->key), &keyblock);
o_keyblock = create_krb5_keyblock();
set_val(krb5_keyblock, o_keyblock, keyblock);
CAMLreturn(wrap_result(o_keyblock, retval));
}
CAMLprim value
caml_krb5_keyblock_get_enctype (value v_keyblock)
{
CAMLparam1(v_keyblock);
krb5_keyblock *keyblock;
krb5_enctype enctype;
keyblock = get_val(krb5_keyblock, v_keyblock);
enctype = keyblock->enctype;
CAMLreturn(Val_int(enctype));
}
CAMLprim value
caml_krb5_keyblock_get_key (value v_keyblock)
{
CAMLparam1(v_keyblock);
CAMLlocal1(o_key);
krb5_keyblock *keyblock;
keyblock = get_val(krb5_keyblock, v_keyblock);
o_key = caml_alloc_initialized_string(keyblock->length, (char *) keyblock->contents);
CAMLreturn(o_key);
}
CAMLprim value
caml_krb5_free_keyblock(value v_context_token, value v_keyblock)
{
CAMLparam2(v_context_token, v_keyblock);
krb5_context context = the_context(v_context_token);
krb5_keyblock *keyblock = get_val(krb5_keyblock, v_keyblock);
krb5_free_keyblock(context, keyblock);
CAMLreturn(Val_unit);
}
CAMLprim value
caml_krb5_free_keytab_entry(value v_context_token, value v_keytab_entry)
{
CAMLparam2(v_context_token, v_keytab_entry);
krb5_context context = the_context(v_context_token);
krb5_keytab_entry *entry = get_val(krb5_keytab_entry, v_keytab_entry);
/* The krb5 doc claims this can return an error, but the code always returns 0 in the
version we are using (1.10.3) (and the latest krb5 release 1.14.2). We call this from
a finalizer, so we couldn't do any meaningful error handling anyway. */
krb5_free_keytab_entry_contents(context, entry);
free(entry);
CAMLreturn(Val_unit);
}
CAMLprim value
caml_krb5_princ_realm(value v_principal) {
CAMLparam1(v_principal);
CAMLlocal1(s);
krb5_principal principal = get_val(krb5_principal, v_principal);
krb5_data *realm = &(principal->realm);
s = caml_alloc_initialized_string(realm->length, realm->data);
CAMLreturn(s);
}
CAMLprim value
caml_krb5_creds_client(value v_context_token, value v_creds) {
CAMLparam2(v_context_token, v_creds);
CAMLlocal1(o_client);
krb5_context context = the_context(v_context_token);
krb5_error_code retval;
krb5_principal principal = get_val(krb5_creds, v_creds).client;
krb5_principal principal_copy = NULL;
retval = krb5_copy_principal(context, principal, &principal_copy);
if(retval) {
CAMLreturn(wrap_result(Val_unit, retval));
}
o_client = create_krb5_principal();
set_val(krb5_principal, o_client, principal_copy);
CAMLreturn(wrap_result(o_client, retval));
}
CAMLprim value
caml_krb5_creds_server(value v_context_token, value v_creds) {
CAMLparam2(v_context_token, v_creds);
CAMLlocal1(o_server);
krb5_context context = the_context(v_context_token);
krb5_error_code retval;
krb5_principal principal = get_val(krb5_creds, v_creds).server;
krb5_principal principal_copy = NULL;
retval = krb5_copy_principal(context, principal, &principal_copy);
if(retval) {
CAMLreturn(wrap_result(Val_unit, retval));
}
o_server = create_krb5_principal();
set_val(krb5_principal, o_server, principal_copy);
CAMLreturn(wrap_result(o_server, retval));
}
CAMLprim value
caml_krb5_creds_is_skey(value v_creds) {
CAMLparam1(v_creds);
CAMLlocal1(o_is_skey);
krb5_boolean is_skey = get_val(krb5_creds, v_creds).is_skey;
o_is_skey = Val_bool(is_skey);
CAMLreturn(o_is_skey);
}
CAMLprim value
caml_krb5_creds_ticket_data(value v_context_token, value v_creds) {
CAMLparam2(v_context_token, v_creds);
CAMLlocal1(o_data);
krb5_context context = the_context(v_context_token);
krb5_error_code retval;
krb5_creds creds = get_val(krb5_creds, v_creds);
krb5_data data = creds.ticket;
krb5_data* data_copy = NULL;
retval = krb5_copy_data(context, &data, &data_copy);
if (retval) {
CAMLreturn(wrap_result(Val_unit, retval));
}
o_data = create_krb5_data();
set_val(krb5_data, o_data, *data_copy);
/* krb5_copy_data allocates a new krb5_data structure (data_copy)
which must be freed after its contents are copied into the
gc-tracked structure (o_data) */
free(data_copy);
CAMLreturn(wrap_result(o_data, retval));
}
CAMLprim value
caml_krb5_creds_ticket_string(value v_creds) {
CAMLparam1(v_creds);
CAMLlocal1(o_ticket);
krb5_data ticket = get_val(krb5_creds, v_creds).ticket;
o_ticket = caml_alloc_initialized_string(ticket.length, ticket.data);
CAMLreturn(o_ticket);
}
CAMLprim value
caml_krb5_creds_second_ticket(value v_creds) {
CAMLparam1(v_creds);
CAMLlocal1(o_second_ticket);
krb5_data second_ticket = get_val(krb5_creds, v_creds).second_ticket;
o_second_ticket = caml_alloc_initialized_string(second_ticket.length, second_ticket.data);
CAMLreturn(o_second_ticket);
}
CAMLprim value
caml_krb5_creds_starttime(value v_creds) {
CAMLparam1(v_creds);
krb5_ticket_times times = get_val(krb5_creds, v_creds).times;
CAMLreturn(Val_int(times.starttime));
}
CAMLprim value
caml_krb5_creds_endtime(value v_creds) {
CAMLparam1(v_creds);
krb5_ticket_times times = get_val(krb5_creds, v_creds).times;
CAMLreturn(Val_int(times.endtime));
}
CAMLprim value
caml_krb5_creds_renew_till(value v_creds) {
CAMLparam1(v_creds);
krb5_ticket_times times = get_val(krb5_creds, v_creds).times;
CAMLreturn(Val_int(times.renew_till));
}
CAMLprim value
caml_krb5_creds_forwardable(value v_creds) {
CAMLparam1(v_creds);
krb5_flags flags = get_val(krb5_creds, v_creds).ticket_flags;
CAMLreturn(Val_bool(flags & TKT_FLG_FORWARDABLE));
}
CAMLprim value
caml_krb5_creds_proxiable(value v_creds) {
CAMLparam1(v_creds);
krb5_flags flags = get_val(krb5_creds, v_creds).ticket_flags;
CAMLreturn(Val_bool(flags & TKT_FLG_PROXIABLE));
}
CAMLprim value
caml_krb5_creds_keyblock(value v_context_token, value v_creds) {
CAMLparam2(v_context_token, v_creds);
CAMLlocal1(o_keyblock);
krb5_context context = the_context(v_context_token);
krb5_keyblock keyblock = get_val(krb5_creds, v_creds).keyblock;
krb5_keyblock *keyblock_copy = NULL;
krb5_error_code retval;
retval = krb5_copy_keyblock(context,
&keyblock,
&keyblock_copy);
if(retval) {
CAMLreturn(wrap_result(Val_unit, retval));
} else {
o_keyblock = create_krb5_keyblock();
set_val(krb5_keyblock, o_keyblock, keyblock_copy);
CAMLreturn(wrap_result(o_keyblock, retval));
}
}
CAMLprim value
caml_krb5_auth_con_setuseruserkey(value v_context_token, value v_auth_context,
value v_keyblock) {
CAMLparam3(v_context_token, v_auth_context, v_keyblock);
krb5_context context = the_context(v_context_token);
krb5_error_code retval;
retval = krb5_auth_con_setuseruserkey(context,
get_val(krb5_auth_context, v_auth_context),
get_val(krb5_keyblock, v_keyblock));
CAMLreturn(wrap_result(Val_unit, retval));
}
CAMLprim value
caml_krb5_creds_create(value v_context_token, value v_client,
value v_server, value v_ticket_opt, value v_second_ticket_opt) {
CAMLparam5(v_context_token, v_client, v_server, v_ticket_opt, v_second_ticket_opt);
CAMLlocal3(o_creds, v_ticket, v_second_ticket);
krb5_creds creds;
krb5_error_code retval;
krb5_context context = the_context(v_context_token);
krb5_principal client_princ = get_val(krb5_principal, v_client);
krb5_principal server_princ = get_val(krb5_principal, v_server);
memset(&creds, 0, sizeof(creds));
if(Is_block(v_ticket_opt)) {
v_ticket = Field(v_ticket_opt, 0);
creds.ticket.length = caml_string_length(v_ticket);
creds.ticket.data = malloc(creds.ticket.length);
memcpy(creds.ticket.data, String_val(v_ticket), creds.ticket.length);
}
if(Is_block(v_second_ticket_opt)) {
v_second_ticket = Field(v_second_ticket_opt, 0);
creds.second_ticket.length = caml_string_length(v_second_ticket);
creds.second_ticket.data = malloc(creds.second_ticket.length);
memcpy(creds.second_ticket.data, String_val(v_second_ticket), creds.second_ticket.length);
}
retval = krb5_copy_principal(context, client_princ, &(creds.client));
if(retval) {
free(creds.ticket.data);
free(creds.second_ticket.data);
CAMLreturn(wrap_result(Val_unit, retval));
}
retval = krb5_copy_principal(context, server_princ, &(creds.server));
if(retval) {
free(creds.ticket.data);
free(creds.second_ticket.data);
krb5_free_principal(context, creds.client);
CAMLreturn(wrap_result(Val_unit, retval));
}
o_creds = create_krb5_creds();
set_val(krb5_creds, o_creds, creds);
CAMLreturn(wrap_result(o_creds, retval));
}
krb5_flags parse_get_credentials_flags(value v_options) {
CAMLparam1(v_options);
krb5_flags options = 0;
while(v_options != Val_int(0)) {
switch(Int_val(Field(v_options, 0))) {
case 0: options |= KRB5_GC_CACHED; break;
case 1: options |= KRB5_GC_USER_USER; break;
case 2: options |= KRB5_GC_NO_STORE; break;
default:
caml_invalid_argument("parse_get_credentials_flags: invalid krb5_flags");
}
v_options = Field(v_options, 1);
}
CAMLreturnT(krb5_flags, options);
}
CAMLprim value
caml_krb5_get_credentials(value v_context_token, value v_options,
value v_ccache, value v_in_creds) {
CAMLparam4(v_context_token, v_options, v_ccache, v_in_creds);
CAMLlocal1(o_out_creds);
krb5_context context = the_context(v_context_token);
krb5_flags options = parse_get_credentials_flags(v_options);
krb5_creds in_creds = get_val(krb5_creds, v_in_creds);
krb5_creds *out_creds;
krb5_error_code retval;
krb5_ccache ccache = get_val(krb5_ccache, v_ccache);
caml_release_runtime_system();
retval = krb5_get_credentials(context,
options,
ccache,
&in_creds,
&out_creds);
caml_acquire_runtime_system();
if(retval) {
CAMLreturn(wrap_result(Val_unit, retval));
} else {
o_out_creds = create_krb5_creds();
set_val(krb5_creds, o_out_creds, *out_creds);
/* We make a copy of the top-level struct, so we need to free it. We can't use
krb5_free_creds, since that would also free the contained malloc'ed data regions */
free(out_creds);
CAMLreturn(wrap_result(o_out_creds, retval));
}
}
CAMLprim value
caml_krb5_get_credentials_for_user(value v_context_token, value v_options,
value v_ccache, value v_in_creds) {
CAMLparam4(v_context_token, v_options, v_ccache, v_in_creds);
CAMLlocal1(o_out_creds);
krb5_context context = the_context(v_context_token);
krb5_flags options = parse_get_credentials_flags(v_options);
krb5_creds in_creds = get_val(krb5_creds, v_in_creds);
krb5_creds *out_creds;
krb5_error_code retval;
krb5_ccache ccache = get_val(krb5_ccache, v_ccache);
caml_release_runtime_system();
retval = krb5_get_credentials_for_user(context,
options,
ccache,
&in_creds,
NULL,
&out_creds);
caml_acquire_runtime_system();
if(retval) {
CAMLreturn(wrap_result(Val_unit, retval));
} else {
o_out_creds = create_krb5_creds();
set_val(krb5_creds, o_out_creds, *out_creds);
/* We make a copy of the top-level struct, so we need to free it. We can't use
krb5_free_creds, since that would also free the contained malloc'ed data regions */
free(out_creds);
CAMLreturn(wrap_result(o_out_creds, retval));
}
}
CAMLprim value
caml_krb5_mk_req_extended(value v_context_token, value v_auth_context,
value v_req_flags, value v_creds) {
CAMLparam4(v_context_token, v_auth_context, v_req_flags, v_creds);
krb5_context context = the_context(v_context_token);
krb5_error_code retval;
krb5_data outbuf;
krb5_flags flags = 0;
krb5_auth_context auth_context = get_val(krb5_auth_context, v_auth_context);
krb5_creds creds = get_val(krb5_creds, v_creds);
while(v_req_flags != Val_int(0)) {
switch(Int_val(Field(v_req_flags, 0))) {
case 0: flags |= AP_OPTS_USE_SESSION_KEY; break;
case 1: flags |= AP_OPTS_MUTUAL_REQUIRED; break;
default: caml_invalid_argument("my_krb5_mk_req_extended: invalid krb5_mk_req_flag");
}
v_req_flags = Field(v_req_flags, 1);
}
retval = krb5_mk_req_extended(context,
&auth_context,
flags,
NULL,
&creds,
&outbuf);
CAMLreturn(handle_outbuffer(&outbuf, retval));
}
CAMLprim value
caml_krb5_fwd_tgt_cred(value v_context_token, value v_auth_context, value v_client,
value v_ccache, value v_forwardable) {
CAMLparam5(v_context_token, v_auth_context, v_client, v_ccache, v_forwardable);
krb5_context context = the_context(v_context_token);
krb5_auth_context auth_context = get_val(krb5_auth_context, v_auth_context);
krb5_principal client = get_val(krb5_principal, v_client);
krb5_ccache ccache = get_val(krb5_ccache, v_ccache);
krb5_boolean forwardable = Bool_val(v_forwardable);
krb5_error_code retval;
krb5_data outbuf;
/* [krb5_fwd_tgt_creds] is a thin wrapper around [krb5_make_1cred]. The former does some
nice things with regard to addresses in tickets, but we don't currently have
addresses in tickets, so we pass NULL for rhost and server. It still uses the
existing tgt to get a new tgt, which is the proper way to forward credentials. */
caml_release_runtime_system();
retval = krb5_fwd_tgt_creds(context,
auth_context,
NULL, /* rhost */
client,
NULL, /* server */
ccache,
forwardable,
&outbuf);
caml_acquire_runtime_system();
CAMLreturn(handle_outbuffer(&outbuf, retval));
}
/* call krb5_rd_cred and store each resulting [Credentials.t] in the given cred cache */
CAMLprim value
caml_krb5_cc_store_krb_cred(value v_context_token,
value v_auth_context,
value v_ccache,
value v_cred_data
) {
CAMLparam4(v_context_token, v_auth_context, v_ccache, v_cred_data);
krb5_context context = the_context(v_context_token);
krb5_auth_context auth_context = get_val(krb5_auth_context, v_auth_context);
krb5_ccache ccache = get_val(krb5_ccache, v_ccache);
krb5_data cred_data = data_of_bigstring(v_cred_data);
krb5_creds **ppcreds;
krb5_creds **i;
krb5_error_code retval;
caml_release_runtime_system();
retval = krb5_rd_cred(context,
auth_context,
&cred_data,
&ppcreds,
NULL);
if(retval) {
caml_acquire_runtime_system();
CAMLreturn(wrap_result(Val_unit, retval));
}
for (i = ppcreds; *i; i++) {
retval = krb5_cc_store_cred (context, ccache, *i);
if(retval) {
krb5_free_tgt_creds(context, ppcreds);
caml_acquire_runtime_system();
CAMLreturn(wrap_result(Val_unit, retval));
}
}
krb5_free_tgt_creds(context, ppcreds);
caml_acquire_runtime_system();
CAMLreturn(wrap_result(Val_unit, 0));
}
CAMLprim value
caml_krb5_decode_ticket(value v_data) {
CAMLparam1(v_data);
CAMLlocal1(o_ticket);
krb5_ticket* ticket = NULL;
krb5_error_code retval;
krb5_data ticket_data = get_val(krb5_data, v_data);
retval = krb5_decode_ticket(&ticket_data, &ticket);
if (retval) {
CAMLreturn(wrap_result(Val_unit, retval));
}
o_ticket = create_krb5_ticket();
set_val(krb5_ticket, o_ticket, ticket);
CAMLreturn(wrap_result(o_ticket, retval));
}
CAMLprim value
caml_krb5_free_ticket(value v_context_token, value v_ticket) {
CAMLparam2(v_context_token, v_ticket);
krb5_context context = the_context(v_context_token);
krb5_ticket* ticket = get_val(krb5_ticket, v_ticket);
krb5_free_ticket(context, ticket);
CAMLreturn(Val_unit);
}
CAMLprim value
caml_krb5_ticket_kvno(value v_ticket) {
CAMLparam1(v_ticket);
krb5_ticket* ticket = get_val(krb5_ticket, v_ticket);
krb5_enc_data enc_part = ticket->enc_part;
krb5_kvno kvno = enc_part.kvno;
CAMLreturn(Val_int(kvno));
}
CAMLprim value
caml_krb5_ticket_enctype(value v_ticket) {
CAMLparam1(v_ticket);
krb5_ticket* ticket = get_val(krb5_ticket, v_ticket);
krb5_enc_data enc_part = ticket->enc_part;
krb5_enctype enc_type = enc_part.enctype;
CAMLreturn(Val_int(enc_type));
}
| |
number_of_partitions_vec.c |
#include "arith.h"
void
arith_number_of_partitions_vec(fmpz * res, slong len)
{
fmpz * tmp;
slong k, n;
if (len < 1)
return;
tmp = _fmpz_vec_init(len);
tmp[0] = WORD(1);
for (n = k = 1; n + 4*k + 2 < len; k += 2)
{
tmp[n] = WORD(-1);
tmp[n + k] = WORD(-1);
tmp[n + 3*k + 1] = WORD(1);
tmp[n + 4*k + 2] = WORD(1);
n += 6*k + 5;
}
if (n < len) tmp[n] = WORD(-1);
if (n + k < len) tmp[n + k] = WORD(-1);
if (n + 3*k + 1 < len) tmp[n + 3*k + 1] = WORD(1);
_fmpz_poly_inv_series(res, tmp, len, len);
_fmpz_vec_clear(tmp, len);
}
| /*
Copyright (C) 2011 Fredrik Johansson
This file is part of FLINT.
FLINT is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License (LGPL) as published
by the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version. See <https://www.gnu.org/licenses/>.
*/ |
test_eof.ml |
open Sexplib.Std
let with_temp_file sexp_of_t ~contents ~f =
let fname, oc = Filename.open_temp_file "test" ".sexp" in
let result =
match
output_string oc contents;
close_out oc;
f fname
with
| x -> `Ok x
| exception e -> `Error e
in
Sys.remove fname;
Printf.printf !"%{sexp:[ `Ok of t | `Error of exn ]}" result
;;
let%expect_test "file ending with an atom" =
with_temp_file [%sexp_of: int] ~contents:"5" ~f:(fun fname ->
Sexplib.Sexp.load_sexp_conv_exn fname [%of_sexp: int]);
[%expect {|
(Ok 5)
|}]
;;
let%expect_test "file ending with an atom" =
with_temp_file [%sexp_of: Sexplib.Sexp.t list] ~contents:"5" ~f:(fun fname ->
let ic = open_in fname in
match Sexplib.Sexp.input_sexps ic with
| x ->
close_in ic;
x
| exception e ->
close_in ic;
raise e);
[%expect {|
(Ok (5))
|}]
;;
| |
test_intf.mli |
type a = [%import: Stuff.a]
| |
lp.mli | (** top module of package {!module:Lp} *)
module Var = Var
module Term = Term
module Poly = Poly
module Cnstr = Cnstr
module Objective = Objective
module Problem = Problem
(** Module for the optimization problem class. *)
module Pclass = Problem.Pclass
(** Map with Poly.t key. It can be used to pack optimization result. *)
module PMap : Map.S with type key = Poly.t
(* polynomial builders and operators *)
val c : float -> Poly.t
(** Make monomial of a constant value. *)
val var : ?integer:bool -> ?lb:float -> ?ub:float -> string -> Poly.t
(** Make monomial of a variable.
You can optionally set its bounds ([lb] and [ub]) and whether it is an [integer].
By default, it becomes continuous and non-negative ([integer] = false, [lb] = Float.zero, and [ub] = Float.infinity).
*)
val binary : string -> Poly.t
(** Make monomial of a binary variable. *)
val range :
?integer:bool
-> ?lb:float
-> ?ub:float
-> ?start:int
-> int
-> string
-> Poly.t array
(** Make an array of monomials of a variable with uniform bounds. *)
val range2 :
?integer:bool
-> ?lb:float
-> ?ub:float
-> ?start0:int
-> ?start1:int
-> int
-> int
-> string
-> Poly.t array array
(** Make 2D array of monomials of a variable with uniform bounds. *)
val range3 :
?integer:bool
-> ?lb:float
-> ?ub:float
-> ?start0:int
-> ?start1:int
-> ?start2:int
-> int
-> int
-> int
-> string
-> Poly.t array array array
(** Make 3D array of monomials of a variable with uniform bounds. *)
val rangeb : ?start:int -> int -> string -> Poly.t array
(** Make an array of monomials of a binary variable. *)
val range2b :
?start0:int -> ?start1:int -> int -> int -> string -> Poly.t array array
(** Make 2D array of monomials of a binary variable. *)
val range3b :
?start0:int
-> ?start1:int
-> ?start2:int
-> int
-> int
-> int
-> string
-> Poly.t array array array
(** Make 3D array of monomials of a binary variable. *)
val rangev :
?integer:bool
-> ?lb:float array
-> ?ub:float array
-> ?start:int
-> int
-> string
-> Poly.t array
(** Make an array of monomials of a variable with different bounds. *)
val range2v :
?integer:bool
-> ?lb:float array array
-> ?ub:float array array
-> ?start0:int
-> ?start1:int
-> int
-> int
-> string
-> Poly.t array array
(** Make 2D array of monomials of a variable with different bounds. *)
val range3v :
?integer:bool
-> ?lb:float array array array
-> ?ub:float array array array
-> ?start0:int
-> ?start1:int
-> ?start2:int
-> int
-> int
-> int
-> string
-> Poly.t array array array
(** Make 3D array of monomials of a variable with different bounds. *)
val concat : Poly.t array -> Poly.t
(** Concatenate an array of polynomials into single polynomial. *)
val of_float_array : float array -> Poly.t
(** Convert a float array into a polynomial. *)
val zero : Poly.t
(** The monomial of constant zero. *)
val one : Poly.t
(** The monomial of constant one. *)
val ( ~-- ) : Poly.t -> Poly.t
(** Negate the polynomial (negate all terms in the polynomial). *)
val ( ++ ) : Poly.t -> Poly.t -> Poly.t
(** Add (concatenate) two polynomials. *)
val ( -- ) : Poly.t -> Poly.t -> Poly.t
(** Subtract two polynomials (concatenate left with negated right). *)
val expand : Poly.t -> Poly.t -> Poly.t
(** Multiply two polynomials. Specifically, performs polynomial expansion. *)
val ( *~ ) : Poly.t -> Poly.t -> Poly.t
(** Infix equivalent of {!val:expand}. *)
val dot : Poly.t -> Poly.t -> Poly.t
(** Regard two polynomials as {i vectors} and take dot product.
@raise Failure if the lengths of two polynomials are different.
*)
val ( *@ ) : Poly.t -> Poly.t -> Poly.t
(** Infix equivalent of {!val:dot}. *)
val div : Poly.t -> Poly.t -> Poly.t
(** Divide polynomial by a {b univariate} polynomial.
Be careful as this function raises exception in some cases.
@raise Failure
if failed to divide (with zero remainder) or denominator is multivariate polynomial.
@raise Division_by_zero
if denominator is zero.
*)
val ( /~ ) : Poly.t -> Poly.t -> Poly.t
(** Infix equivalent of {!val:div}. *)
val eq : ?eps:float -> ?name:string -> Poly.t -> Poly.t -> Cnstr.t
(** Build an equality constraint. Optional [name] can be given.
Polynomials are simplified ({!val:Poly.simplify}) on build.
[eps] specifies the threshold of near-zero, defaulting to 10. *. epsilon_float.
*)
val ( =~ ) : Poly.t -> Poly.t -> Cnstr.t
(** Build an unnamed equality constraint. Polynomials are simplified on build. *)
val lt : ?eps:float -> ?name:string -> Poly.t -> Poly.t -> Cnstr.t
(** Build an inequality constraint. Optional [name] can be given.
Polynomials are simplified ({!val:Poly.simplify}) on build.
[eps] specifies the threshold of near-zero, defaulting to 10. *. epsilon_float.
*)
val ( <~ ) : Poly.t -> Poly.t -> Cnstr.t
(** Build an unnamed inequality constraint. Polynomials are simplified on build. *)
val gt : ?eps:float -> ?name:string -> Poly.t -> Poly.t -> Cnstr.t
(** Build an inequality constraint. Optional [name] can be given.
Polynomials are simplified ({!val:Poly.simplify}) on build.
[eps] specifies the threshold of near-zero, defaulting to 10. *. epsilon_float.
*)
val ( >~ ) : Poly.t -> Poly.t -> Cnstr.t
(** Build an unnamed inequality constraint. Polynomials are simplified on build. *)
val maximize : ?eps:float -> Poly.t -> Objective.t
(** Build an objective to maximize a polynomial.
The polynomial is simplified ({!val:Poly.simplify}) on build.
[eps] specifies the threshold of near-zero, defaulting to 10. *. epsilon_float.
*)
val minimize : ?eps:float -> Poly.t -> Objective.t
(** Build an objective to minimize a polynomial.
The polynomial is simplified ({!val:Poly.simplify}) on build.
[eps] specifies the threshold of near-zero, defaulting to 10. *. epsilon_float.
*)
val make : ?name:string -> Objective.t -> Cnstr.t list -> Problem.t
(** Make problem from an {!type:Objective.t} and a constraint ({!type:Cnstr.t}) list.
String [name] can be given optionally.
*)
(* model validation and manipulation *)
val validate : Problem.t -> bool
(** Validate the problem. [true] ([false]) means the problem is valid (invalid). *)
val classify : Problem.t -> Pclass.t
(** Classify the problem into {!type:Pclass.t}. *)
val vname_list : Problem.t -> string list
(** Make (unique and sorted) list of the variables in a problem. *)
(* IO *)
val to_string : ?short:bool -> Problem.t -> string
(** Express the problem in LP file format string. *)
val of_string : string -> Problem.t
(** Parse an LP file format string to build the problem. *)
val write : ?short:bool -> string -> Problem.t -> unit
(** write [fname] [problem] writes out [problem] to an LP file [fname]. *)
val read : string -> Problem.t
(** Parse an LP file to build the problem. *)
| (** top module of package {!module:Lp} *)
|
client_proto_context.mli | open Protocol
open Alpha_context
val list_contract_labels :
#Protocol_client_context.full ->
chain:Shell_services.chain ->
block:Shell_services.block ->
(string * string * string) list tzresult Lwt.t
val get_storage :
#Protocol_client_context.rpc_context ->
chain:Shell_services.chain ->
block:Shell_services.block ->
Contract.t ->
Script.expr option tzresult Lwt.t
val get_contract_big_map_value :
#Protocol_client_context.rpc_context ->
chain:Shell_services.chain ->
block:Shell_services.block ->
Contract.t ->
Script.expr * Script.expr ->
Script.expr option tzresult Lwt.t
val get_big_map_value :
#Protocol_client_context.rpc_context ->
chain:Shell_services.chain ->
block:Shell_services.block ->
Z.t ->
Script_expr_hash.t ->
Script.expr tzresult Lwt.t
val get_script :
#Protocol_client_context.rpc_context ->
chain:Shell_services.chain ->
block:Shell_services.block ->
Contract.t ->
Script.t option tzresult Lwt.t
val get_balance :
#Protocol_client_context.rpc_context ->
chain:Shell_services.chain ->
block:Shell_services.block ->
Contract.t ->
Tez.t tzresult Lwt.t
val set_delegate :
#Protocol_client_context.full ->
chain:Shell_services.chain ->
block:Shell_services.block ->
?confirmations:int ->
?dry_run:bool ->
?verbose_signing:bool ->
?fee:Tez.tez ->
public_key_hash ->
src_pk:public_key ->
manager_sk:Client_keys.sk_uri ->
fee_parameter:Injection.fee_parameter ->
public_key_hash option ->
Kind.delegation Kind.manager Injection.result tzresult Lwt.t
val register_as_delegate :
#Protocol_client_context.full ->
chain:Shell_services.chain ->
block:Shell_services.block ->
?confirmations:int ->
?dry_run:bool ->
?verbose_signing:bool ->
?fee:Tez.tez ->
manager_sk:Client_keys.sk_uri ->
fee_parameter:Injection.fee_parameter ->
public_key ->
Kind.delegation Kind.manager Injection.result tzresult Lwt.t
val save_contract :
force:bool ->
#Protocol_client_context.full ->
string ->
Contract.t ->
unit tzresult Lwt.t
val originate_contract :
#Protocol_client_context.full ->
chain:Shell_services.chain ->
block:Shell_services.block ->
?confirmations:int ->
?dry_run:bool ->
?verbose_signing:bool ->
?branch:int ->
?fee:Tez.t ->
?gas_limit:Gas.Arith.integral ->
?storage_limit:Z.t ->
delegate:public_key_hash option ->
initial_storage:string ->
balance:Tez.t ->
source:public_key_hash ->
src_pk:public_key ->
src_sk:Client_keys.sk_uri ->
code:Script.expr ->
fee_parameter:Injection.fee_parameter ->
unit ->
(Kind.origination Kind.manager Injection.result * Contract.t) tzresult Lwt.t
val transfer :
#Protocol_client_context.full ->
chain:Shell_services.chain ->
block:Shell_services.block ->
?confirmations:int ->
?dry_run:bool ->
?verbose_signing:bool ->
?branch:int ->
source:public_key_hash ->
src_pk:public_key ->
src_sk:Client_keys.sk_uri ->
destination:Contract.t ->
?entrypoint:string ->
?arg:string ->
amount:Tez.t ->
?fee:Tez.t ->
?gas_limit:Gas.Arith.integral ->
?storage_limit:Z.t ->
?counter:Z.t ->
fee_parameter:Injection.fee_parameter ->
unit ->
(Kind.transaction Kind.manager Injection.result * Contract.t list) tzresult
Lwt.t
val reveal :
#Protocol_client_context.full ->
chain:Shell_services.chain ->
block:Shell_services.block ->
?confirmations:int ->
?dry_run:bool ->
?verbose_signing:bool ->
?branch:int ->
source:public_key_hash ->
src_pk:public_key ->
src_sk:Client_keys.sk_uri ->
?fee:Tez.t ->
fee_parameter:Injection.fee_parameter ->
unit ->
Kind.reveal Kind.manager Injection.result tzresult Lwt.t
type activation_key = {
pkh : Ed25519.Public_key_hash.t;
amount : Tez.t;
activation_code : Blinded_public_key_hash.activation_code;
mnemonic : string list;
password : string;
email : string;
}
val activation_key_encoding : activation_key Data_encoding.t
val activate_account :
#Protocol_client_context.full ->
chain:Shell_services.chain ->
block:Shell_services.block ->
?confirmations:int ->
?dry_run:bool ->
?encrypted:bool ->
?force:bool ->
activation_key ->
string ->
Kind.activate_account Injection.result tzresult Lwt.t
val activate_existing_account :
#Protocol_client_context.full ->
chain:Shell_services.chain ->
block:Shell_services.block ->
?confirmations:int ->
?dry_run:bool ->
string ->
Blinded_public_key_hash.activation_code ->
Kind.activate_account Injection.result tzresult Lwt.t
type period_info = {
current_period_kind : Voting_period.kind;
position : Int32.t;
remaining : Int32.t;
current_proposal : Protocol_hash.t option;
}
type ballots_info = {
current_quorum : Int32.t;
participation : Int32.t;
supermajority : Int32.t;
ballots : Vote.ballots;
}
val get_period_info :
#Protocol_client_context.full ->
chain:Shell_services.chain ->
block:Shell_services.block ->
period_info tzresult Lwt.t
val get_ballots_info :
#Protocol_client_context.full ->
chain:Shell_services.chain ->
block:Shell_services.block ->
ballots_info tzresult Lwt.t
val get_proposals :
#Protocol_client_context.full ->
chain:Shell_services.chain ->
block:Shell_services.block ->
Int32.t Environment.Protocol_hash.Map.t tzresult Lwt.t
val submit_proposals :
?dry_run:bool ->
?verbose_signing:bool ->
#Protocol_client_context.full ->
chain:Shell_services.chain ->
block:Shell_services.block ->
?confirmations:int ->
src_sk:Client_keys.sk_uri ->
public_key_hash ->
Protocol_hash.t list ->
Kind.proposals Injection.result_list tzresult Lwt.t
val submit_ballot :
?dry_run:bool ->
?verbose_signing:bool ->
#Protocol_client_context.full ->
chain:Shell_services.chain ->
block:Shell_services.block ->
?confirmations:int ->
src_sk:Client_keys.sk_uri ->
public_key_hash ->
Protocol_hash.t ->
Vote.ballot ->
Kind.ballot Injection.result_list tzresult Lwt.t
(** lookup an operation in [predecessors] previous blocks, and print the
receipt if found *)
val display_receipt_for_operation :
#Protocol_client_context.full ->
chain:Block_services.chain ->
?predecessors:int ->
Operation_list_hash.elt ->
unit tzresult Lwt.t
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
omlf_descriminant.mli | (** Train a
{{:https://en.wikipedia.org/wiki/Linear_discriminant_analysis#Multiclass_LDA}
Multiclass LDA model by estimating a mean vector for the features (per
class) and a common covariance matrix (common to all classes), which are
then used to model a {{:https://en.wikipedia.org/wiki/Multivariate_normal_distribution}
Multivariate normal distribution}. These, per class, distributions are used
in Bayes's rule for classification. *)
module LDA(D: Oml.Classification.Input_interfaces.Continuous_encoded_data) : sig
include Oml.Classification.Classifier_interfaces.Generative
with type feature = D.feature
and type class_ = D.class_
and type feature_probability = float
val opt : ?shrinkage:float -> unit -> opt
end
module QDA(D: Oml.Classification.Input_interfaces.Continuous_encoded_data) : sig
include Oml.Classification.Classifier_interfaces.Generative
with type feature = D.feature
and type class_ = D.class_
and type feature_probability = float
val opt : ?normalize:bool -> ?shrinkage:float -> unit -> opt
end
| (** Train a
{{:https://en.wikipedia.org/wiki/Linear_discriminant_analysis#Multiclass_LDA}
Multiclass LDA model by estimating a mean vector for the features (per
class) and a common covariance matrix (common to all classes), which are
then used to model a {{:https://en.wikipedia.org/wiki/Multivariate_normal_distribution}
Multivariate normal distribution}. These, per class, distributions are used
in Bayes's rule for classification. *) |
Bloom_annotation.mli | (* fill the s_bf field in the program statements *)
val annotate_program : AST_generic.program -> unit
(* used to compute the bloom of a pattern, skipping Ellispis
* and metavariables.
*)
val set_of_pattern_strings : ?lang:Lang.t -> AST_generic.any -> string Set_.t
(* used internally *)
(* val extract_strings: AST_generic.any -> string list *)
| (* fill the s_bf field in the program statements *)
val annotate_program : AST_generic.program -> unit |
delegate_services.ml | open Alpha_context
type info = {
balance: Tez.t ;
frozen_balance: Tez.t ;
frozen_balance_by_cycle: Delegate.frozen_balance Cycle.Map.t ;
staking_balance: Tez.t ;
delegated_contracts: Contract_hash.t list ;
delegated_balance: Tez.t ;
deactivated: bool ;
grace_period: Cycle.t ;
}
let info_encoding =
let open Data_encoding in
conv
(fun { balance ; frozen_balance ; frozen_balance_by_cycle ;
staking_balance ; delegated_contracts ; delegated_balance ;
deactivated ; grace_period } ->
(balance, frozen_balance, frozen_balance_by_cycle,
staking_balance, delegated_contracts, delegated_balance,
deactivated, grace_period))
(fun (balance, frozen_balance, frozen_balance_by_cycle,
staking_balance, delegated_contracts, delegated_balance,
deactivated, grace_period) ->
{ balance ; frozen_balance ; frozen_balance_by_cycle ;
staking_balance ; delegated_contracts ; delegated_balance ;
deactivated ; grace_period })
(obj8
(req "balance" Tez.encoding)
(req "frozen_balance" Tez.encoding)
(req "frozen_balance_by_cycle" Delegate.frozen_balance_by_cycle_encoding)
(req "staking_balance" Tez.encoding)
(req "delegated_contracts" (list Contract_hash.encoding))
(req "delegated_balance" Tez.encoding)
(req "deactivated" bool)
(req "grace_period" Cycle.encoding))
module S = struct
let path = RPC_path.(open_root / "context" / "delegates")
open Data_encoding
type list_query = {
active: bool ;
inactive: bool ;
}
let list_query :list_query RPC_query.t =
let open RPC_query in
query (fun active inactive -> { active ; inactive })
|+ flag "active" (fun t -> t.active)
|+ flag "inactive" (fun t -> t.inactive)
|> seal
let list_delegate =
RPC_service.get_service
~description:
"Lists all registered delegates."
~query: list_query
~output: (list Signature.Public_key_hash.encoding)
path
let path = RPC_path.(path /: Signature.Public_key_hash.rpc_arg)
let info =
RPC_service.get_service
~description:
"Everything about a delegate."
~query: RPC_query.empty
~output: info_encoding
path
let balance =
RPC_service.get_service
~description:
"Returns the full balance of a given delegate, \
including the frozen balances."
~query: RPC_query.empty
~output: Tez.encoding
RPC_path.(path / "balance")
let frozen_balance =
RPC_service.get_service
~description:
"Returns the total frozen balances of a given delegate, \
this includes the frozen deposits, rewards and fees."
~query: RPC_query.empty
~output: Tez.encoding
RPC_path.(path / "frozen_balance")
let frozen_balance_by_cycle =
RPC_service.get_service
~description:
"Returns the frozen balances of a given delegate, \
indexed by the cycle by which it will be unfrozen"
~query: RPC_query.empty
~output: Delegate.frozen_balance_by_cycle_encoding
RPC_path.(path / "frozen_balance_by_cycle")
let staking_balance =
RPC_service.get_service
~description:
"Returns the total amount of tokens delegated to a given delegate. \
This includes the balances of all the contracts that delegate \
to it, but also the balance of the delegate itself and its frozen \
fees and deposits. The rewards do not count in the delegated balance \
until they are unfrozen."
~query: RPC_query.empty
~output: Tez.encoding
RPC_path.(path / "staking_balance")
let delegated_contracts =
RPC_service.get_service
~description:
"Returns the list of contracts that delegate to a given delegate."
~query: RPC_query.empty
~output: (list Contract_hash.encoding)
RPC_path.(path / "delegated_contracts")
let delegated_balance =
RPC_service.get_service
~description:
"Returns the balances of all the contracts that delegate to a \
given delegate. This excludes the delegate's own balance and \
its frozen balances."
~query: RPC_query.empty
~output: Tez.encoding
RPC_path.(path / "delegated_balance")
let deactivated =
RPC_service.get_service
~description:
"Tells whether the delegate is currently tagged as deactivated or not."
~query: RPC_query.empty
~output: bool
RPC_path.(path / "deactivated")
let grace_period =
RPC_service.get_service
~description:
"Returns the cycle by the end of which the delegate might be \
deactivated if she fails to execute any delegate action. \
A deactivated delegate might be reactivated \
(without loosing any rolls) by simply re-registering as a delegate. \
For deactivated delegates, this value contains the cycle by which \
they were deactivated."
~query: RPC_query.empty
~output: Cycle.encoding
RPC_path.(path / "grace_period")
end
let register () =
let open Services_registration in
register0 S.list_delegate begin fun ctxt q () ->
Delegate.list ctxt >>= fun delegates ->
if q.active && q.inactive then
return delegates
else if q.active then
filter_map_s
(fun pkh ->
Delegate.deactivated ctxt pkh >>=? function
| true -> return_none
| false -> return_some pkh)
delegates
else if q.inactive then
filter_map_s
(fun pkh ->
Delegate.deactivated ctxt pkh >>=? function
| false -> return_none
| true -> return_some pkh)
delegates
else
return_nil
end ;
register1 S.info begin fun ctxt pkh () () ->
Delegate.full_balance ctxt pkh >>=? fun balance ->
Delegate.frozen_balance ctxt pkh >>=? fun frozen_balance ->
Delegate.frozen_balance_by_cycle ctxt pkh >>= fun frozen_balance_by_cycle ->
Delegate.staking_balance ctxt pkh >>=? fun staking_balance ->
Delegate.delegated_contracts ctxt pkh >>= fun delegated_contracts ->
Delegate.delegated_balance ctxt pkh >>=? fun delegated_balance ->
Delegate.deactivated ctxt pkh >>=? fun deactivated ->
Delegate.grace_period ctxt pkh >>=? fun grace_period ->
return {
balance ; frozen_balance ; frozen_balance_by_cycle ;
staking_balance ; delegated_contracts ; delegated_balance ;
deactivated ; grace_period
}
end ;
register1 S.balance begin fun ctxt pkh () () ->
Delegate.full_balance ctxt pkh
end ;
register1 S.frozen_balance begin fun ctxt pkh () () ->
Delegate.frozen_balance ctxt pkh
end ;
register1 S.frozen_balance_by_cycle begin fun ctxt pkh () () ->
Delegate.frozen_balance_by_cycle ctxt pkh >>= return
end ;
register1 S.staking_balance begin fun ctxt pkh () () ->
Delegate.staking_balance ctxt pkh
end ;
register1 S.delegated_contracts begin fun ctxt pkh () () ->
Delegate.delegated_contracts ctxt pkh >>= return
end ;
register1 S.delegated_balance begin fun ctxt pkh () () ->
Delegate.delegated_balance ctxt pkh
end ;
register1 S.deactivated begin fun ctxt pkh () () ->
Delegate.deactivated ctxt pkh
end ;
register1 S.grace_period begin fun ctxt pkh () () ->
Delegate.grace_period ctxt pkh
end
let list ctxt block ?(active = true) ?(inactive = false) () =
RPC_context.make_call0 S.list_delegate ctxt block { active ; inactive } ()
let info ctxt block pkh =
RPC_context.make_call1 S.info ctxt block pkh () ()
let balance ctxt block pkh =
RPC_context.make_call1 S.balance ctxt block pkh () ()
let frozen_balance ctxt block pkh =
RPC_context.make_call1 S.frozen_balance ctxt block pkh () ()
let frozen_balance_by_cycle ctxt block pkh =
RPC_context.make_call1 S.frozen_balance_by_cycle ctxt block pkh () ()
let staking_balance ctxt block pkh =
RPC_context.make_call1 S.staking_balance ctxt block pkh () ()
let delegated_contracts ctxt block pkh =
RPC_context.make_call1 S.delegated_contracts ctxt block pkh () ()
let delegated_balance ctxt block pkh =
RPC_context.make_call1 S.delegated_balance ctxt block pkh () ()
let deactivated ctxt block pkh =
RPC_context.make_call1 S.deactivated ctxt block pkh () ()
let grace_period ctxt block pkh =
RPC_context.make_call1 S.grace_period ctxt block pkh () ()
let requested_levels ~default ctxt cycles levels =
match levels, cycles with
| [], [] ->
return [default]
| levels, cycles ->
(* explicitly fail when requested levels or cycle are in the past...
or too far in the future... *)
let levels =
List.sort_uniq
Level.compare
(List.concat (List.map (Level.from_raw ctxt) levels ::
List.map (Level.levels_in_cycle ctxt) cycles)) in
map_p
(fun level ->
let current_level = Level.current ctxt in
if Level.(level <= current_level) then
return (level, None)
else
Baking.earlier_predecessor_timestamp
ctxt level >>=? fun timestamp ->
return (level, Some timestamp))
levels
module Baking_rights = struct
type t = {
level: Raw_level.t ;
delegate: Signature.Public_key_hash.t ;
priority: int ;
timestamp: Timestamp.t option ;
}
let encoding =
let open Data_encoding in
conv
(fun { level ; delegate ; priority ; timestamp } ->
(level, delegate, priority, timestamp))
(fun (level, delegate, priority, timestamp) ->
{ level ; delegate ; priority ; timestamp })
(obj4
(req "level" Raw_level.encoding)
(req "delegate" Signature.Public_key_hash.encoding)
(req "priority" uint16)
(opt "estimated_time" Timestamp.encoding))
module S = struct
open Data_encoding
let custom_root =
RPC_path.(open_root / "helpers" / "baking_rights")
type baking_rights_query = {
levels: Raw_level.t list ;
cycles: Cycle.t list ;
delegates: Signature.Public_key_hash.t list ;
max_priority: int option ;
all: bool ;
}
let baking_rights_query =
let open RPC_query in
query (fun levels cycles delegates max_priority all ->
{ levels ; cycles ; delegates ; max_priority ; all })
|+ multi_field "level" Raw_level.rpc_arg (fun t -> t.levels)
|+ multi_field "cycle" Cycle.rpc_arg (fun t -> t.cycles)
|+ multi_field "delegate" Signature.Public_key_hash.rpc_arg (fun t -> t.delegates)
|+ opt_field "max_priority" RPC_arg.int (fun t -> t.max_priority)
|+ flag "all" (fun t -> t.all)
|> seal
let baking_rights =
RPC_service.get_service
~description:
"Retrieves the list of delegates allowed to bake a block.\n\
By default, it gives the best baking priorities for bakers \
that have at least one opportunity below the 64th priority \
for the next block.\n\
Parameters `level` and `cycle` can be used to specify the \
(valid) level(s) in the past or future at which the baking \
rights have to be returned. Parameter `delegate` can be \
used to restrict the results to the given delegates. If \
parameter `all` is set, all the baking opportunities for \
each baker at each level are returned, instead of just the \
first one.\n\
Returns the list of baking slots. Also returns the minimal \
timestamps that correspond to these slots. The timestamps \
are omitted for levels in the past, and are only estimates \
for levels later that the next block, based on the \
hypothesis that all predecessor blocks were baked at the \
first priority."
~query: baking_rights_query
~output: (list encoding)
custom_root
end
let baking_priorities ctxt max_prio (level, pred_timestamp) =
Baking.baking_priorities ctxt level >>=? fun contract_list ->
let rec loop l acc priority =
if Compare.Int.(priority >= max_prio) then
return (List.rev acc)
else
let Misc.LCons (pk, next) = l in
let delegate = Signature.Public_key.hash pk in
begin
match pred_timestamp with
| None -> return_none
| Some pred_timestamp ->
Baking.minimal_time ctxt priority pred_timestamp >>=? fun t ->
return_some t
end>>=? fun timestamp ->
let acc =
{ level = level.level ; delegate ; priority ; timestamp } :: acc in
next () >>=? fun l ->
loop l acc (priority+1) in
loop contract_list [] 0
let remove_duplicated_delegates rights =
List.rev @@ fst @@
List.fold_left
(fun (acc, previous) r ->
if Signature.Public_key_hash.Set.mem r.delegate previous then
(acc, previous)
else
(r :: acc,
Signature.Public_key_hash.Set.add r.delegate previous))
([], Signature.Public_key_hash.Set.empty)
rights
let register () =
let open Services_registration in
register0 S.baking_rights begin fun ctxt q () ->
requested_levels
~default:
(Level.succ ctxt (Level.current ctxt), Some (Timestamp.current ctxt))
ctxt q.cycles q.levels >>=? fun levels ->
let max_priority =
match q.max_priority with
| None -> 64
| Some max -> max in
map_p (baking_priorities ctxt max_priority) levels >>=? fun rights ->
let rights =
if q.all then
rights
else
List.map remove_duplicated_delegates rights in
let rights = List.concat rights in
match q.delegates with
| [] -> return rights
| _ :: _ as delegates ->
let is_requested p =
List.exists (Signature.Public_key_hash.equal p.delegate) delegates in
return (List.filter is_requested rights)
end
let get ctxt
?(levels = []) ?(cycles = []) ?(delegates = []) ?(all = false)
?max_priority block =
RPC_context.make_call0 S.baking_rights ctxt block
{ levels ; cycles ; delegates ; max_priority ; all }
()
end
module Endorsing_rights = struct
type t = {
level: Raw_level.t ;
delegate: Signature.Public_key_hash.t ;
slots: int list ;
estimated_time: Time.t option ;
}
let encoding =
let open Data_encoding in
conv
(fun { level ; delegate ; slots ; estimated_time } ->
(level, delegate, slots, estimated_time))
(fun (level, delegate, slots, estimated_time) ->
{ level ; delegate ; slots ; estimated_time })
(obj4
(req "level" Raw_level.encoding)
(req "delegate" Signature.Public_key_hash.encoding)
(req "slots" (list uint16))
(opt "estimated_time" Timestamp.encoding))
module S = struct
open Data_encoding
let custom_root =
RPC_path.(open_root / "helpers" / "endorsing_rights")
type endorsing_rights_query = {
levels: Raw_level.t list ;
cycles: Cycle.t list ;
delegates: Signature.Public_key_hash.t list ;
}
let endorsing_rights_query =
let open RPC_query in
query (fun levels cycles delegates ->
{ levels ; cycles ; delegates })
|+ multi_field "level" Raw_level.rpc_arg (fun t -> t.levels)
|+ multi_field "cycle" Cycle.rpc_arg (fun t -> t.cycles)
|+ multi_field "delegate" Signature.Public_key_hash.rpc_arg (fun t -> t.delegates)
|> seal
let endorsing_rights =
RPC_service.get_service
~description:
"Retrieves the delegates allowed to endorse a block.\n\
By default, it gives the endorsement slots for delegates that \
have at least one in the next block.\n\
Parameters `level` and `cycle` can be used to specify the \
(valid) level(s) in the past or future at which the \
endorsement rights have to be returned. Parameter \
`delegate` can be used to restrict the results to the given \
delegates.\n\
Returns the list of endorsement slots. Also returns the \
minimal timestamps that correspond to these slots. The \
timestamps are omitted for levels in the past, and are only \
estimates for levels later that the next block, based on \
the hypothesis that all predecessor blocks were baked at \
the first priority."
~query: endorsing_rights_query
~output: (list encoding)
custom_root
end
let endorsement_slots ctxt (level, estimated_time) =
Baking.endorsement_rights ctxt level >>=? fun rights ->
return
(Signature.Public_key_hash.Map.fold
(fun delegate (_, slots, _) acc -> {
level = level.level ; delegate ; slots ; estimated_time
} :: acc)
rights [])
let register () =
let open Services_registration in
register0 S.endorsing_rights begin fun ctxt q () ->
requested_levels
~default: (Level.current ctxt, Some (Timestamp.current ctxt))
ctxt q.cycles q.levels >>=? fun levels ->
map_p (endorsement_slots ctxt) levels >>=? fun rights ->
let rights = List.concat rights in
match q.delegates with
| [] -> return rights
| _ :: _ as delegates ->
let is_requested p =
List.exists (Signature.Public_key_hash.equal p.delegate) delegates in
return (List.filter is_requested rights)
end
let get ctxt
?(levels = []) ?(cycles = []) ?(delegates = []) block =
RPC_context.make_call0 S.endorsing_rights ctxt block
{ levels ; cycles ; delegates }
()
end
let register () =
register () ;
Baking_rights.register () ;
Endorsing_rights.register ()
let endorsement_rights ctxt level =
Endorsing_rights.endorsement_slots ctxt (level, None) >>=? fun l ->
return (List.map (fun { Endorsing_rights.delegate ; _ } -> delegate) l)
let baking_rights ctxt max_priority =
let max = match max_priority with None -> 64 | Some m -> m in
let level = Level.current ctxt in
Baking_rights.baking_priorities ctxt max (level, None) >>=? fun l ->
return (level.level,
List.map
(fun { Baking_rights.delegate ; timestamp ; _ } ->
(delegate, timestamp)) l)
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
asttypes.mli | (** Auxiliary AST types used by parsetree and typedtree.
{b Warning:} this module is unstable and part of
{{!Compiler_libs}compiler-libs}.
*)
type constant =
Const_int of int
| Const_char of char
| Const_string of string * Location.t * string option
| Const_float of string
| Const_int32 of int32
| Const_int64 of int64
| Const_nativeint of nativeint
type rec_flag = Nonrecursive | Recursive
type direction_flag = Upto | Downto
(* Order matters, used in polymorphic comparison *)
type private_flag = Private | Public
type mutable_flag = Immutable | Mutable
type virtual_flag = Virtual | Concrete
type override_flag = Override | Fresh
type closed_flag = Closed | Open
type label = string
type arg_label =
Nolabel
| Labelled of string (** [label:T -> ...] *)
| Optional of string (** [?label:T -> ...] *)
type 'a loc = 'a Location.loc = {
txt : 'a;
loc : Location.t;
}
type variance =
| Covariant
| Contravariant
| NoVariance
type injectivity =
| Injective
| NoInjectivity
| (**************************************************************************)
(* *)
(* OCaml *)
(* *)
(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)
(* *)
(* Copyright 1996 Institut National de Recherche en Informatique et *)
(* en Automatique. *)
(* *)
(* All rights reserved. This file is distributed under the terms of *)
(* the GNU Lesser General Public License version 2.1, with the *)
(* special exception on linking described in the file LICENSE. *)
(* *)
(**************************************************************************)
|
michelson_samplers.mli | (** Sampling various Michelson values. *)
open Protocol
open Base_samplers
(** This module exposes a functor implementing various samplers for Michelson.
These allow to sample:
- types and comparable types (given a target size),
- values and comparable values of a given Michelson type (given some more
parameters fixed at functor instantiation time)
- stacks
Note that some kind of values might not be supported. At the time of writing,
the value sampler doesn't handle the following types:
- Sapling transaction and states
- Timelock chests and chest keys
- Operations
- Lambdas (ie code)
For the latter, consider using the samplers in {!Michelson_mcmc_samplers}.
*)
(** Parameters for the Michelson samplers. *)
type parameters = {
base_parameters : Michelson_samplers_base.parameters;
list_size : Base_samplers.range;
(** The range of the size, measured in number of elements, in which lists must be sampled.*)
set_size : Base_samplers.range;
(** The range of the size, measured in number of elements, in which sets must be sampled.*)
map_size : Base_samplers.range;
(** The range of the size, measured in number of bindings, in which maps must be sampled.*)
}
(** Encoding for sampler prameters. *)
val parameters_encoding : parameters Data_encoding.t
(** The module type produced by the [Make] functor. *)
module type S = sig
(** Basic Michelson samplers, re-exported for convenience by the functor. *)
module Michelson_base : Michelson_samplers_base.S
(** Samplers for random Michelson types. *)
module Random_type : sig
(** [m_type ~size] samples a type containing exactly [size] constructors. *)
val m_type : size:int -> Script_ir_translator.ex_ty sampler
(** [m_comparable_type ~size] samples a comparable type containing
exactly [size] constructors. *)
val m_comparable_type :
size:int -> Script_ir_translator.ex_comparable_ty sampler
end
(** Samplers for random Michelson values. Restrictions apply on the
supported types as listed at the beginning of this file. *)
module rec Random_value : sig
(** Sample a value given its type. *)
val value : 'a Script_typed_ir.ty -> 'a sampler
(** Sample a comparable value given its type. *)
val comparable : 'a Script_typed_ir.comparable_ty -> 'a sampler
(** Sample a stack given its type. *)
val stack : ('a, 'b) Script_typed_ir.stack_ty -> ('a * 'b) sampler
end
end
(** Instantiate a module of type {!S}. *)
module Make : functor
(P : sig
val parameters : parameters
end)
(Crypto_samplers : Crypto_samplers.Finite_key_pool_S)
-> S
module Internal_for_tests : sig
type type_name =
[ `TAddress
| `TBig_map
| `TBls12_381_fr
| `TBls12_381_g1
| `TBls12_381_g2
| `TBool
| `TBytes
| `TChain_id
| `TContract
| `TInt
| `TKey
| `TKey_hash
| `TLambda
| `TList
| `TMap
| `TMutez
| `TNat
| `TOperation
| `TOption
| `TPair
| `TSapling_state
| `TSapling_transaction
| `TSet
| `TSignature
| `TString
| `TTicket
| `TTimestamp
| `TUnion
| `TUnit ]
end
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2021 Nomadic Labs, <contact@nomadic-labs.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
lapacke.h |
#ifndef _MKL_LAPACKE_H_
#ifndef _LAPACKE_H_
#define _LAPACKE_H_
/*
* Turn on HAVE_LAPACK_CONFIG_H to redefine C-LAPACK datatypes
*/
#ifdef HAVE_LAPACK_CONFIG_H
#include "lapacke_config.h"
#endif
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#include <stdlib.h>
#ifndef lapack_int
#define lapack_int int
#endif
#ifndef lapack_logical
#define lapack_logical lapack_int
#endif
/* Complex types are structures equivalent to the
* Fortran complex types COMPLEX(4) and COMPLEX(8).
*
* One can also redefine the types with his own types
* for example by including in the code definitions like
*
* #define lapack_complex_float std::complex<float>
* #define lapack_complex_double std::complex<double>
*
* or define these types in the command line:
*
* -Dlapack_complex_float="std::complex<float>"
* -Dlapack_complex_double="std::complex<double>"
*/
#ifndef LAPACK_COMPLEX_CUSTOM
/* Complex type (single precision) */
#ifndef lapack_complex_float
#include <complex.h>
#define lapack_complex_float float _Complex
#endif
#ifndef lapack_complex_float_real
#define lapack_complex_float_real(z) (creal(z))
#endif
#ifndef lapack_complex_float_imag
#define lapack_complex_float_imag(z) (cimag(z))
#endif
lapack_complex_float lapack_make_complex_float( float re, float im );
/* Complex type (double precision) */
#ifndef lapack_complex_double
#include <complex.h>
#define lapack_complex_double double _Complex
#endif
#ifndef lapack_complex_double_real
#define lapack_complex_double_real(z) (creal(z))
#endif
#ifndef lapack_complex_double_imag
#define lapack_complex_double_imag(z) (cimag(z))
#endif
lapack_complex_double lapack_make_complex_double( double re, double im );
#endif
#ifndef LAPACKE_malloc
#define LAPACKE_malloc( size ) malloc( size )
#endif
#ifndef LAPACKE_free
#define LAPACKE_free( p ) free( p )
#endif
#define LAPACK_C2INT( x ) (lapack_int)(*((float*)&x ))
#define LAPACK_Z2INT( x ) (lapack_int)(*((double*)&x ))
#define LAPACK_ROW_MAJOR 101
#define LAPACK_COL_MAJOR 102
#define LAPACK_WORK_MEMORY_ERROR -1010
#define LAPACK_TRANSPOSE_MEMORY_ERROR -1011
/* Callback logical functions of one, two, or three arguments are used
* to select eigenvalues to sort to the top left of the Schur form.
* The value is selected if function returns TRUE (non-zero). */
typedef lapack_logical (*LAPACK_S_SELECT2) ( const float*, const float* );
typedef lapack_logical (*LAPACK_S_SELECT3)
( const float*, const float*, const float* );
typedef lapack_logical (*LAPACK_D_SELECT2) ( const double*, const double* );
typedef lapack_logical (*LAPACK_D_SELECT3)
( const double*, const double*, const double* );
typedef lapack_logical (*LAPACK_C_SELECT1) ( const lapack_complex_float* );
typedef lapack_logical (*LAPACK_C_SELECT2)
( const lapack_complex_float*, const lapack_complex_float* );
typedef lapack_logical (*LAPACK_Z_SELECT1) ( const lapack_complex_double* );
typedef lapack_logical (*LAPACK_Z_SELECT2)
( const lapack_complex_double*, const lapack_complex_double* );
#include "lapacke_mangling.h"
#define LAPACK_lsame LAPACK_GLOBAL(lsame,LSAME)
lapack_logical LAPACK_lsame( char* ca, char* cb,
lapack_int lca, lapack_int lcb );
/* C-LAPACK function prototypes */
lapack_int LAPACKE_sbdsdc( int matrix_order, char uplo, char compq,
lapack_int n, float* d, float* e, float* u,
lapack_int ldu, float* vt, lapack_int ldvt, float* q,
lapack_int* iq );
lapack_int LAPACKE_dbdsdc( int matrix_order, char uplo, char compq,
lapack_int n, double* d, double* e, double* u,
lapack_int ldu, double* vt, lapack_int ldvt,
double* q, lapack_int* iq );
lapack_int LAPACKE_sbdsqr( int matrix_order, char uplo, lapack_int n,
lapack_int ncvt, lapack_int nru, lapack_int ncc,
float* d, float* e, float* vt, lapack_int ldvt,
float* u, lapack_int ldu, float* c, lapack_int ldc );
lapack_int LAPACKE_dbdsqr( int matrix_order, char uplo, lapack_int n,
lapack_int ncvt, lapack_int nru, lapack_int ncc,
double* d, double* e, double* vt, lapack_int ldvt,
double* u, lapack_int ldu, double* c,
lapack_int ldc );
lapack_int LAPACKE_cbdsqr( int matrix_order, char uplo, lapack_int n,
lapack_int ncvt, lapack_int nru, lapack_int ncc,
float* d, float* e, lapack_complex_float* vt,
lapack_int ldvt, lapack_complex_float* u,
lapack_int ldu, lapack_complex_float* c,
lapack_int ldc );
lapack_int LAPACKE_zbdsqr( int matrix_order, char uplo, lapack_int n,
lapack_int ncvt, lapack_int nru, lapack_int ncc,
double* d, double* e, lapack_complex_double* vt,
lapack_int ldvt, lapack_complex_double* u,
lapack_int ldu, lapack_complex_double* c,
lapack_int ldc );
lapack_int LAPACKE_sdisna( char job, lapack_int m, lapack_int n, const float* d,
float* sep );
lapack_int LAPACKE_ddisna( char job, lapack_int m, lapack_int n,
const double* d, double* sep );
lapack_int LAPACKE_sgbbrd( int matrix_order, char vect, lapack_int m,
lapack_int n, lapack_int ncc, lapack_int kl,
lapack_int ku, float* ab, lapack_int ldab, float* d,
float* e, float* q, lapack_int ldq, float* pt,
lapack_int ldpt, float* c, lapack_int ldc );
lapack_int LAPACKE_dgbbrd( int matrix_order, char vect, lapack_int m,
lapack_int n, lapack_int ncc, lapack_int kl,
lapack_int ku, double* ab, lapack_int ldab,
double* d, double* e, double* q, lapack_int ldq,
double* pt, lapack_int ldpt, double* c,
lapack_int ldc );
lapack_int LAPACKE_cgbbrd( int matrix_order, char vect, lapack_int m,
lapack_int n, lapack_int ncc, lapack_int kl,
lapack_int ku, lapack_complex_float* ab,
lapack_int ldab, float* d, float* e,
lapack_complex_float* q, lapack_int ldq,
lapack_complex_float* pt, lapack_int ldpt,
lapack_complex_float* c, lapack_int ldc );
lapack_int LAPACKE_zgbbrd( int matrix_order, char vect, lapack_int m,
lapack_int n, lapack_int ncc, lapack_int kl,
lapack_int ku, lapack_complex_double* ab,
lapack_int ldab, double* d, double* e,
lapack_complex_double* q, lapack_int ldq,
lapack_complex_double* pt, lapack_int ldpt,
lapack_complex_double* c, lapack_int ldc );
lapack_int LAPACKE_sgbcon( int matrix_order, char norm, lapack_int n,
lapack_int kl, lapack_int ku, const float* ab,
lapack_int ldab, const lapack_int* ipiv, float anorm,
float* rcond );
lapack_int LAPACKE_dgbcon( int matrix_order, char norm, lapack_int n,
lapack_int kl, lapack_int ku, const double* ab,
lapack_int ldab, const lapack_int* ipiv,
double anorm, double* rcond );
lapack_int LAPACKE_cgbcon( int matrix_order, char norm, lapack_int n,
lapack_int kl, lapack_int ku,
const lapack_complex_float* ab, lapack_int ldab,
const lapack_int* ipiv, float anorm, float* rcond );
lapack_int LAPACKE_zgbcon( int matrix_order, char norm, lapack_int n,
lapack_int kl, lapack_int ku,
const lapack_complex_double* ab, lapack_int ldab,
const lapack_int* ipiv, double anorm,
double* rcond );
lapack_int LAPACKE_sgbequ( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku, const float* ab,
lapack_int ldab, float* r, float* c, float* rowcnd,
float* colcnd, float* amax );
lapack_int LAPACKE_dgbequ( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku, const double* ab,
lapack_int ldab, double* r, double* c,
double* rowcnd, double* colcnd, double* amax );
lapack_int LAPACKE_cgbequ( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku,
const lapack_complex_float* ab, lapack_int ldab,
float* r, float* c, float* rowcnd, float* colcnd,
float* amax );
lapack_int LAPACKE_zgbequ( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku,
const lapack_complex_double* ab, lapack_int ldab,
double* r, double* c, double* rowcnd, double* colcnd,
double* amax );
lapack_int LAPACKE_sgbequb( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku, const float* ab,
lapack_int ldab, float* r, float* c, float* rowcnd,
float* colcnd, float* amax );
lapack_int LAPACKE_dgbequb( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku, const double* ab,
lapack_int ldab, double* r, double* c,
double* rowcnd, double* colcnd, double* amax );
lapack_int LAPACKE_cgbequb( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku,
const lapack_complex_float* ab, lapack_int ldab,
float* r, float* c, float* rowcnd, float* colcnd,
float* amax );
lapack_int LAPACKE_zgbequb( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku,
const lapack_complex_double* ab, lapack_int ldab,
double* r, double* c, double* rowcnd,
double* colcnd, double* amax );
lapack_int LAPACKE_sgbrfs( int matrix_order, char trans, lapack_int n,
lapack_int kl, lapack_int ku, lapack_int nrhs,
const float* ab, lapack_int ldab, const float* afb,
lapack_int ldafb, const lapack_int* ipiv,
const float* b, lapack_int ldb, float* x,
lapack_int ldx, float* ferr, float* berr );
lapack_int LAPACKE_dgbrfs( int matrix_order, char trans, lapack_int n,
lapack_int kl, lapack_int ku, lapack_int nrhs,
const double* ab, lapack_int ldab, const double* afb,
lapack_int ldafb, const lapack_int* ipiv,
const double* b, lapack_int ldb, double* x,
lapack_int ldx, double* ferr, double* berr );
lapack_int LAPACKE_cgbrfs( int matrix_order, char trans, lapack_int n,
lapack_int kl, lapack_int ku, lapack_int nrhs,
const lapack_complex_float* ab, lapack_int ldab,
const lapack_complex_float* afb, lapack_int ldafb,
const lapack_int* ipiv,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx, float* ferr,
float* berr );
lapack_int LAPACKE_zgbrfs( int matrix_order, char trans, lapack_int n,
lapack_int kl, lapack_int ku, lapack_int nrhs,
const lapack_complex_double* ab, lapack_int ldab,
const lapack_complex_double* afb, lapack_int ldafb,
const lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr );
lapack_int LAPACKE_sgbrfsx( int matrix_order, char trans, char equed,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, const float* ab, lapack_int ldab,
const float* afb, lapack_int ldafb,
const lapack_int* ipiv, const float* r,
const float* c, const float* b, lapack_int ldb,
float* x, lapack_int ldx, float* rcond, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params );
lapack_int LAPACKE_dgbrfsx( int matrix_order, char trans, char equed,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, const double* ab, lapack_int ldab,
const double* afb, lapack_int ldafb,
const lapack_int* ipiv, const double* r,
const double* c, const double* b, lapack_int ldb,
double* x, lapack_int ldx, double* rcond,
double* berr, lapack_int n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int nparams, double* params );
lapack_int LAPACKE_cgbrfsx( int matrix_order, char trans, char equed,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, const lapack_complex_float* ab,
lapack_int ldab, const lapack_complex_float* afb,
lapack_int ldafb, const lapack_int* ipiv,
const float* r, const float* c,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* berr, lapack_int n_err_bnds,
float* err_bnds_norm, float* err_bnds_comp,
lapack_int nparams, float* params );
lapack_int LAPACKE_zgbrfsx( int matrix_order, char trans, char equed,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, const lapack_complex_double* ab,
lapack_int ldab, const lapack_complex_double* afb,
lapack_int ldafb, const lapack_int* ipiv,
const double* r, const double* c,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* berr, lapack_int n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int nparams, double* params );
lapack_int LAPACKE_sgbsv( int matrix_order, lapack_int n, lapack_int kl,
lapack_int ku, lapack_int nrhs, float* ab,
lapack_int ldab, lapack_int* ipiv, float* b,
lapack_int ldb );
lapack_int LAPACKE_dgbsv( int matrix_order, lapack_int n, lapack_int kl,
lapack_int ku, lapack_int nrhs, double* ab,
lapack_int ldab, lapack_int* ipiv, double* b,
lapack_int ldb );
lapack_int LAPACKE_cgbsv( int matrix_order, lapack_int n, lapack_int kl,
lapack_int ku, lapack_int nrhs,
lapack_complex_float* ab, lapack_int ldab,
lapack_int* ipiv, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zgbsv( int matrix_order, lapack_int n, lapack_int kl,
lapack_int ku, lapack_int nrhs,
lapack_complex_double* ab, lapack_int ldab,
lapack_int* ipiv, lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_sgbsvx( int matrix_order, char fact, char trans,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, float* ab, lapack_int ldab,
float* afb, lapack_int ldafb, lapack_int* ipiv,
char* equed, float* r, float* c, float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* rcond, float* ferr, float* berr,
float* rpivot );
lapack_int LAPACKE_dgbsvx( int matrix_order, char fact, char trans,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, double* ab, lapack_int ldab,
double* afb, lapack_int ldafb, lapack_int* ipiv,
char* equed, double* r, double* c, double* b,
lapack_int ldb, double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr,
double* rpivot );
lapack_int LAPACKE_cgbsvx( int matrix_order, char fact, char trans,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, lapack_complex_float* ab,
lapack_int ldab, lapack_complex_float* afb,
lapack_int ldafb, lapack_int* ipiv, char* equed,
float* r, float* c, lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* x,
lapack_int ldx, float* rcond, float* ferr,
float* berr, float* rpivot );
lapack_int LAPACKE_zgbsvx( int matrix_order, char fact, char trans,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, lapack_complex_double* ab,
lapack_int ldab, lapack_complex_double* afb,
lapack_int ldafb, lapack_int* ipiv, char* equed,
double* r, double* c, lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* x,
lapack_int ldx, double* rcond, double* ferr,
double* berr, double* rpivot );
lapack_int LAPACKE_sgbsvxx( int matrix_order, char fact, char trans,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, float* ab, lapack_int ldab,
float* afb, lapack_int ldafb, lapack_int* ipiv,
char* equed, float* r, float* c, float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* rcond, float* rpvgrw, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params );
lapack_int LAPACKE_dgbsvxx( int matrix_order, char fact, char trans,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, double* ab, lapack_int ldab,
double* afb, lapack_int ldafb, lapack_int* ipiv,
char* equed, double* r, double* c, double* b,
lapack_int ldb, double* x, lapack_int ldx,
double* rcond, double* rpvgrw, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params );
lapack_int LAPACKE_cgbsvxx( int matrix_order, char fact, char trans,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, lapack_complex_float* ab,
lapack_int ldab, lapack_complex_float* afb,
lapack_int ldafb, lapack_int* ipiv, char* equed,
float* r, float* c, lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* x,
lapack_int ldx, float* rcond, float* rpvgrw,
float* berr, lapack_int n_err_bnds,
float* err_bnds_norm, float* err_bnds_comp,
lapack_int nparams, float* params );
lapack_int LAPACKE_zgbsvxx( int matrix_order, char fact, char trans,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, lapack_complex_double* ab,
lapack_int ldab, lapack_complex_double* afb,
lapack_int ldafb, lapack_int* ipiv, char* equed,
double* r, double* c, lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* x,
lapack_int ldx, double* rcond, double* rpvgrw,
double* berr, lapack_int n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int nparams, double* params );
lapack_int LAPACKE_sgbtrf( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku, float* ab,
lapack_int ldab, lapack_int* ipiv );
lapack_int LAPACKE_dgbtrf( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku, double* ab,
lapack_int ldab, lapack_int* ipiv );
lapack_int LAPACKE_cgbtrf( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku,
lapack_complex_float* ab, lapack_int ldab,
lapack_int* ipiv );
lapack_int LAPACKE_zgbtrf( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku,
lapack_complex_double* ab, lapack_int ldab,
lapack_int* ipiv );
lapack_int LAPACKE_sgbtrs( int matrix_order, char trans, lapack_int n,
lapack_int kl, lapack_int ku, lapack_int nrhs,
const float* ab, lapack_int ldab,
const lapack_int* ipiv, float* b, lapack_int ldb );
lapack_int LAPACKE_dgbtrs( int matrix_order, char trans, lapack_int n,
lapack_int kl, lapack_int ku, lapack_int nrhs,
const double* ab, lapack_int ldab,
const lapack_int* ipiv, double* b, lapack_int ldb );
lapack_int LAPACKE_cgbtrs( int matrix_order, char trans, lapack_int n,
lapack_int kl, lapack_int ku, lapack_int nrhs,
const lapack_complex_float* ab, lapack_int ldab,
const lapack_int* ipiv, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zgbtrs( int matrix_order, char trans, lapack_int n,
lapack_int kl, lapack_int ku, lapack_int nrhs,
const lapack_complex_double* ab, lapack_int ldab,
const lapack_int* ipiv, lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_sgebak( int matrix_order, char job, char side, lapack_int n,
lapack_int ilo, lapack_int ihi, const float* scale,
lapack_int m, float* v, lapack_int ldv );
lapack_int LAPACKE_dgebak( int matrix_order, char job, char side, lapack_int n,
lapack_int ilo, lapack_int ihi, const double* scale,
lapack_int m, double* v, lapack_int ldv );
lapack_int LAPACKE_cgebak( int matrix_order, char job, char side, lapack_int n,
lapack_int ilo, lapack_int ihi, const float* scale,
lapack_int m, lapack_complex_float* v,
lapack_int ldv );
lapack_int LAPACKE_zgebak( int matrix_order, char job, char side, lapack_int n,
lapack_int ilo, lapack_int ihi, const double* scale,
lapack_int m, lapack_complex_double* v,
lapack_int ldv );
lapack_int LAPACKE_sgebal( int matrix_order, char job, lapack_int n, float* a,
lapack_int lda, lapack_int* ilo, lapack_int* ihi,
float* scale );
lapack_int LAPACKE_dgebal( int matrix_order, char job, lapack_int n, double* a,
lapack_int lda, lapack_int* ilo, lapack_int* ihi,
double* scale );
lapack_int LAPACKE_cgebal( int matrix_order, char job, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_int* ilo, lapack_int* ihi, float* scale );
lapack_int LAPACKE_zgebal( int matrix_order, char job, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_int* ilo, lapack_int* ihi, double* scale );
lapack_int LAPACKE_sgebrd( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* d, float* e,
float* tauq, float* taup );
lapack_int LAPACKE_dgebrd( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* d, double* e,
double* tauq, double* taup );
lapack_int LAPACKE_cgebrd( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda, float* d,
float* e, lapack_complex_float* tauq,
lapack_complex_float* taup );
lapack_int LAPACKE_zgebrd( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda, double* d,
double* e, lapack_complex_double* tauq,
lapack_complex_double* taup );
lapack_int LAPACKE_sgecon( int matrix_order, char norm, lapack_int n,
const float* a, lapack_int lda, float anorm,
float* rcond );
lapack_int LAPACKE_dgecon( int matrix_order, char norm, lapack_int n,
const double* a, lapack_int lda, double anorm,
double* rcond );
lapack_int LAPACKE_cgecon( int matrix_order, char norm, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
float anorm, float* rcond );
lapack_int LAPACKE_zgecon( int matrix_order, char norm, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
double anorm, double* rcond );
lapack_int LAPACKE_sgeequ( int matrix_order, lapack_int m, lapack_int n,
const float* a, lapack_int lda, float* r, float* c,
float* rowcnd, float* colcnd, float* amax );
lapack_int LAPACKE_dgeequ( int matrix_order, lapack_int m, lapack_int n,
const double* a, lapack_int lda, double* r,
double* c, double* rowcnd, double* colcnd,
double* amax );
lapack_int LAPACKE_cgeequ( int matrix_order, lapack_int m, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
float* r, float* c, float* rowcnd, float* colcnd,
float* amax );
lapack_int LAPACKE_zgeequ( int matrix_order, lapack_int m, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
double* r, double* c, double* rowcnd, double* colcnd,
double* amax );
lapack_int LAPACKE_sgeequb( int matrix_order, lapack_int m, lapack_int n,
const float* a, lapack_int lda, float* r, float* c,
float* rowcnd, float* colcnd, float* amax );
lapack_int LAPACKE_dgeequb( int matrix_order, lapack_int m, lapack_int n,
const double* a, lapack_int lda, double* r,
double* c, double* rowcnd, double* colcnd,
double* amax );
lapack_int LAPACKE_cgeequb( int matrix_order, lapack_int m, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
float* r, float* c, float* rowcnd, float* colcnd,
float* amax );
lapack_int LAPACKE_zgeequb( int matrix_order, lapack_int m, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
double* r, double* c, double* rowcnd,
double* colcnd, double* amax );
lapack_int LAPACKE_sgees( int matrix_order, char jobvs, char sort,
LAPACK_S_SELECT2 select, lapack_int n, float* a,
lapack_int lda, lapack_int* sdim, float* wr,
float* wi, float* vs, lapack_int ldvs );
lapack_int LAPACKE_dgees( int matrix_order, char jobvs, char sort,
LAPACK_D_SELECT2 select, lapack_int n, double* a,
lapack_int lda, lapack_int* sdim, double* wr,
double* wi, double* vs, lapack_int ldvs );
lapack_int LAPACKE_cgees( int matrix_order, char jobvs, char sort,
LAPACK_C_SELECT1 select, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_int* sdim, lapack_complex_float* w,
lapack_complex_float* vs, lapack_int ldvs );
lapack_int LAPACKE_zgees( int matrix_order, char jobvs, char sort,
LAPACK_Z_SELECT1 select, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_int* sdim, lapack_complex_double* w,
lapack_complex_double* vs, lapack_int ldvs );
lapack_int LAPACKE_sgeesx( int matrix_order, char jobvs, char sort,
LAPACK_S_SELECT2 select, char sense, lapack_int n,
float* a, lapack_int lda, lapack_int* sdim,
float* wr, float* wi, float* vs, lapack_int ldvs,
float* rconde, float* rcondv );
lapack_int LAPACKE_dgeesx( int matrix_order, char jobvs, char sort,
LAPACK_D_SELECT2 select, char sense, lapack_int n,
double* a, lapack_int lda, lapack_int* sdim,
double* wr, double* wi, double* vs, lapack_int ldvs,
double* rconde, double* rcondv );
lapack_int LAPACKE_cgeesx( int matrix_order, char jobvs, char sort,
LAPACK_C_SELECT1 select, char sense, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_int* sdim, lapack_complex_float* w,
lapack_complex_float* vs, lapack_int ldvs,
float* rconde, float* rcondv );
lapack_int LAPACKE_zgeesx( int matrix_order, char jobvs, char sort,
LAPACK_Z_SELECT1 select, char sense, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_int* sdim, lapack_complex_double* w,
lapack_complex_double* vs, lapack_int ldvs,
double* rconde, double* rcondv );
lapack_int LAPACKE_sgeev( int matrix_order, char jobvl, char jobvr,
lapack_int n, float* a, lapack_int lda, float* wr,
float* wi, float* vl, lapack_int ldvl, float* vr,
lapack_int ldvr );
lapack_int LAPACKE_dgeev( int matrix_order, char jobvl, char jobvr,
lapack_int n, double* a, lapack_int lda, double* wr,
double* wi, double* vl, lapack_int ldvl, double* vr,
lapack_int ldvr );
lapack_int LAPACKE_cgeev( int matrix_order, char jobvl, char jobvr,
lapack_int n, lapack_complex_float* a, lapack_int lda,
lapack_complex_float* w, lapack_complex_float* vl,
lapack_int ldvl, lapack_complex_float* vr,
lapack_int ldvr );
lapack_int LAPACKE_zgeev( int matrix_order, char jobvl, char jobvr,
lapack_int n, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* w,
lapack_complex_double* vl, lapack_int ldvl,
lapack_complex_double* vr, lapack_int ldvr );
lapack_int LAPACKE_sgeevx( int matrix_order, char balanc, char jobvl,
char jobvr, char sense, lapack_int n, float* a,
lapack_int lda, float* wr, float* wi, float* vl,
lapack_int ldvl, float* vr, lapack_int ldvr,
lapack_int* ilo, lapack_int* ihi, float* scale,
float* abnrm, float* rconde, float* rcondv );
lapack_int LAPACKE_dgeevx( int matrix_order, char balanc, char jobvl,
char jobvr, char sense, lapack_int n, double* a,
lapack_int lda, double* wr, double* wi, double* vl,
lapack_int ldvl, double* vr, lapack_int ldvr,
lapack_int* ilo, lapack_int* ihi, double* scale,
double* abnrm, double* rconde, double* rcondv );
lapack_int LAPACKE_cgeevx( int matrix_order, char balanc, char jobvl,
char jobvr, char sense, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* w, lapack_complex_float* vl,
lapack_int ldvl, lapack_complex_float* vr,
lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
float* scale, float* abnrm, float* rconde,
float* rcondv );
lapack_int LAPACKE_zgeevx( int matrix_order, char balanc, char jobvl,
char jobvr, char sense, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* w, lapack_complex_double* vl,
lapack_int ldvl, lapack_complex_double* vr,
lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
double* scale, double* abnrm, double* rconde,
double* rcondv );
lapack_int LAPACKE_sgehrd( int matrix_order, lapack_int n, lapack_int ilo,
lapack_int ihi, float* a, lapack_int lda,
float* tau );
lapack_int LAPACKE_dgehrd( int matrix_order, lapack_int n, lapack_int ilo,
lapack_int ihi, double* a, lapack_int lda,
double* tau );
lapack_int LAPACKE_cgehrd( int matrix_order, lapack_int n, lapack_int ilo,
lapack_int ihi, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* tau );
lapack_int LAPACKE_zgehrd( int matrix_order, lapack_int n, lapack_int ilo,
lapack_int ihi, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* tau );
lapack_int LAPACKE_sgejsv( int matrix_order, char joba, char jobu, char jobv,
char jobr, char jobt, char jobp, lapack_int m,
lapack_int n, float* a, lapack_int lda, float* sva,
float* u, lapack_int ldu, float* v, lapack_int ldv,
float* stat, lapack_int* istat );
lapack_int LAPACKE_dgejsv( int matrix_order, char joba, char jobu, char jobv,
char jobr, char jobt, char jobp, lapack_int m,
lapack_int n, double* a, lapack_int lda, double* sva,
double* u, lapack_int ldu, double* v, lapack_int ldv,
double* stat, lapack_int* istat );
lapack_int LAPACKE_sgelq2( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* tau );
lapack_int LAPACKE_dgelq2( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* tau );
lapack_int LAPACKE_cgelq2( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* tau );
lapack_int LAPACKE_zgelq2( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* tau );
lapack_int LAPACKE_sgelqf( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* tau );
lapack_int LAPACKE_dgelqf( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* tau );
lapack_int LAPACKE_cgelqf( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* tau );
lapack_int LAPACKE_zgelqf( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* tau );
lapack_int LAPACKE_sgels( int matrix_order, char trans, lapack_int m,
lapack_int n, lapack_int nrhs, float* a,
lapack_int lda, float* b, lapack_int ldb );
lapack_int LAPACKE_dgels( int matrix_order, char trans, lapack_int m,
lapack_int n, lapack_int nrhs, double* a,
lapack_int lda, double* b, lapack_int ldb );
lapack_int LAPACKE_cgels( int matrix_order, char trans, lapack_int m,
lapack_int n, lapack_int nrhs,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zgels( int matrix_order, char trans, lapack_int m,
lapack_int n, lapack_int nrhs,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_sgelsd( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, float* a, lapack_int lda, float* b,
lapack_int ldb, float* s, float rcond,
lapack_int* rank );
lapack_int LAPACKE_dgelsd( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, double* a, lapack_int lda,
double* b, lapack_int ldb, double* s, double rcond,
lapack_int* rank );
lapack_int LAPACKE_cgelsd( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb, float* s, float rcond,
lapack_int* rank );
lapack_int LAPACKE_zgelsd( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb, double* s, double rcond,
lapack_int* rank );
lapack_int LAPACKE_sgelss( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, float* a, lapack_int lda, float* b,
lapack_int ldb, float* s, float rcond,
lapack_int* rank );
lapack_int LAPACKE_dgelss( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, double* a, lapack_int lda,
double* b, lapack_int ldb, double* s, double rcond,
lapack_int* rank );
lapack_int LAPACKE_cgelss( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb, float* s, float rcond,
lapack_int* rank );
lapack_int LAPACKE_zgelss( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb, double* s, double rcond,
lapack_int* rank );
lapack_int LAPACKE_sgelsy( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, float* a, lapack_int lda, float* b,
lapack_int ldb, lapack_int* jpvt, float rcond,
lapack_int* rank );
lapack_int LAPACKE_dgelsy( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, double* a, lapack_int lda,
double* b, lapack_int ldb, lapack_int* jpvt,
double rcond, lapack_int* rank );
lapack_int LAPACKE_cgelsy( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb, lapack_int* jpvt, float rcond,
lapack_int* rank );
lapack_int LAPACKE_zgelsy( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb, lapack_int* jpvt, double rcond,
lapack_int* rank );
lapack_int LAPACKE_sgeqlf( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* tau );
lapack_int LAPACKE_dgeqlf( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* tau );
lapack_int LAPACKE_cgeqlf( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* tau );
lapack_int LAPACKE_zgeqlf( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* tau );
lapack_int LAPACKE_sgeqp3( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, lapack_int* jpvt,
float* tau );
lapack_int LAPACKE_dgeqp3( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, lapack_int* jpvt,
double* tau );
lapack_int LAPACKE_cgeqp3( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_int* jpvt, lapack_complex_float* tau );
lapack_int LAPACKE_zgeqp3( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_int* jpvt, lapack_complex_double* tau );
lapack_int LAPACKE_sgeqpf( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, lapack_int* jpvt,
float* tau );
lapack_int LAPACKE_dgeqpf( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, lapack_int* jpvt,
double* tau );
lapack_int LAPACKE_cgeqpf( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_int* jpvt, lapack_complex_float* tau );
lapack_int LAPACKE_zgeqpf( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_int* jpvt, lapack_complex_double* tau );
lapack_int LAPACKE_sgeqr2( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* tau );
lapack_int LAPACKE_dgeqr2( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* tau );
lapack_int LAPACKE_cgeqr2( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* tau );
lapack_int LAPACKE_zgeqr2( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* tau );
lapack_int LAPACKE_sgeqrf( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* tau );
lapack_int LAPACKE_dgeqrf( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* tau );
lapack_int LAPACKE_cgeqrf( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* tau );
lapack_int LAPACKE_zgeqrf( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* tau );
lapack_int LAPACKE_sgeqrfp( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* tau );
lapack_int LAPACKE_dgeqrfp( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* tau );
lapack_int LAPACKE_cgeqrfp( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* tau );
lapack_int LAPACKE_zgeqrfp( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* tau );
lapack_int LAPACKE_sgerfs( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const float* a, lapack_int lda,
const float* af, lapack_int ldaf,
const lapack_int* ipiv, const float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* ferr, float* berr );
lapack_int LAPACKE_dgerfs( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const double* a, lapack_int lda,
const double* af, lapack_int ldaf,
const lapack_int* ipiv, const double* b,
lapack_int ldb, double* x, lapack_int ldx,
double* ferr, double* berr );
lapack_int LAPACKE_cgerfs( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* af,
lapack_int ldaf, const lapack_int* ipiv,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx, float* ferr,
float* berr );
lapack_int LAPACKE_zgerfs( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, const lapack_complex_double* af,
lapack_int ldaf, const lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr );
lapack_int LAPACKE_sgerfsx( int matrix_order, char trans, char equed,
lapack_int n, lapack_int nrhs, const float* a,
lapack_int lda, const float* af, lapack_int ldaf,
const lapack_int* ipiv, const float* r,
const float* c, const float* b, lapack_int ldb,
float* x, lapack_int ldx, float* rcond, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params );
lapack_int LAPACKE_dgerfsx( int matrix_order, char trans, char equed,
lapack_int n, lapack_int nrhs, const double* a,
lapack_int lda, const double* af, lapack_int ldaf,
const lapack_int* ipiv, const double* r,
const double* c, const double* b, lapack_int ldb,
double* x, lapack_int ldx, double* rcond,
double* berr, lapack_int n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int nparams, double* params );
lapack_int LAPACKE_cgerfsx( int matrix_order, char trans, char equed,
lapack_int n, lapack_int nrhs,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* af, lapack_int ldaf,
const lapack_int* ipiv, const float* r,
const float* c, const lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* x,
lapack_int ldx, float* rcond, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params );
lapack_int LAPACKE_zgerfsx( int matrix_order, char trans, char equed,
lapack_int n, lapack_int nrhs,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* af, lapack_int ldaf,
const lapack_int* ipiv, const double* r,
const double* c, const lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* x,
lapack_int ldx, double* rcond, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params );
lapack_int LAPACKE_sgerqf( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* tau );
lapack_int LAPACKE_dgerqf( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* tau );
lapack_int LAPACKE_cgerqf( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* tau );
lapack_int LAPACKE_zgerqf( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* tau );
lapack_int LAPACKE_sgesdd( int matrix_order, char jobz, lapack_int m,
lapack_int n, float* a, lapack_int lda, float* s,
float* u, lapack_int ldu, float* vt,
lapack_int ldvt );
lapack_int LAPACKE_dgesdd( int matrix_order, char jobz, lapack_int m,
lapack_int n, double* a, lapack_int lda, double* s,
double* u, lapack_int ldu, double* vt,
lapack_int ldvt );
lapack_int LAPACKE_cgesdd( int matrix_order, char jobz, lapack_int m,
lapack_int n, lapack_complex_float* a,
lapack_int lda, float* s, lapack_complex_float* u,
lapack_int ldu, lapack_complex_float* vt,
lapack_int ldvt );
lapack_int LAPACKE_zgesdd( int matrix_order, char jobz, lapack_int m,
lapack_int n, lapack_complex_double* a,
lapack_int lda, double* s, lapack_complex_double* u,
lapack_int ldu, lapack_complex_double* vt,
lapack_int ldvt );
lapack_int LAPACKE_sgesv( int matrix_order, lapack_int n, lapack_int nrhs,
float* a, lapack_int lda, lapack_int* ipiv, float* b,
lapack_int ldb );
lapack_int LAPACKE_dgesv( int matrix_order, lapack_int n, lapack_int nrhs,
double* a, lapack_int lda, lapack_int* ipiv,
double* b, lapack_int ldb );
lapack_int LAPACKE_cgesv( int matrix_order, lapack_int n, lapack_int nrhs,
lapack_complex_float* a, lapack_int lda,
lapack_int* ipiv, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zgesv( int matrix_order, lapack_int n, lapack_int nrhs,
lapack_complex_double* a, lapack_int lda,
lapack_int* ipiv, lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_dsgesv( int matrix_order, lapack_int n, lapack_int nrhs,
double* a, lapack_int lda, lapack_int* ipiv,
double* b, lapack_int ldb, double* x, lapack_int ldx,
lapack_int* iter );
lapack_int LAPACKE_zcgesv( int matrix_order, lapack_int n, lapack_int nrhs,
lapack_complex_double* a, lapack_int lda,
lapack_int* ipiv, lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* x,
lapack_int ldx, lapack_int* iter );
lapack_int LAPACKE_sgesvd( int matrix_order, char jobu, char jobvt,
lapack_int m, lapack_int n, float* a, lapack_int lda,
float* s, float* u, lapack_int ldu, float* vt,
lapack_int ldvt, float* superb );
lapack_int LAPACKE_dgesvd( int matrix_order, char jobu, char jobvt,
lapack_int m, lapack_int n, double* a,
lapack_int lda, double* s, double* u, lapack_int ldu,
double* vt, lapack_int ldvt, double* superb );
lapack_int LAPACKE_cgesvd( int matrix_order, char jobu, char jobvt,
lapack_int m, lapack_int n, lapack_complex_float* a,
lapack_int lda, float* s, lapack_complex_float* u,
lapack_int ldu, lapack_complex_float* vt,
lapack_int ldvt, float* superb );
lapack_int LAPACKE_zgesvd( int matrix_order, char jobu, char jobvt,
lapack_int m, lapack_int n, lapack_complex_double* a,
lapack_int lda, double* s, lapack_complex_double* u,
lapack_int ldu, lapack_complex_double* vt,
lapack_int ldvt, double* superb );
lapack_int LAPACKE_sgesvj( int matrix_order, char joba, char jobu, char jobv,
lapack_int m, lapack_int n, float* a, lapack_int lda,
float* sva, lapack_int mv, float* v, lapack_int ldv,
float* stat );
lapack_int LAPACKE_dgesvj( int matrix_order, char joba, char jobu, char jobv,
lapack_int m, lapack_int n, double* a,
lapack_int lda, double* sva, lapack_int mv,
double* v, lapack_int ldv, double* stat );
lapack_int LAPACKE_sgesvx( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs, float* a,
lapack_int lda, float* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, float* r, float* c,
float* b, lapack_int ldb, float* x, lapack_int ldx,
float* rcond, float* ferr, float* berr,
float* rpivot );
lapack_int LAPACKE_dgesvx( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs, double* a,
lapack_int lda, double* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, double* r, double* c,
double* b, lapack_int ldb, double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr,
double* rpivot );
lapack_int LAPACKE_cgesvx( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, float* r, float* c,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* ferr, float* berr,
float* rpivot );
lapack_int LAPACKE_zgesvx( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, double* r, double* c,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr,
double* rpivot );
lapack_int LAPACKE_sgesvxx( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs, float* a,
lapack_int lda, float* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, float* r, float* c,
float* b, lapack_int ldb, float* x, lapack_int ldx,
float* rcond, float* rpvgrw, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params );
lapack_int LAPACKE_dgesvxx( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs, double* a,
lapack_int lda, double* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, double* r, double* c,
double* b, lapack_int ldb, double* x,
lapack_int ldx, double* rcond, double* rpvgrw,
double* berr, lapack_int n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int nparams, double* params );
lapack_int LAPACKE_cgesvxx( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, float* r, float* c,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* rpvgrw, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params );
lapack_int LAPACKE_zgesvxx( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, double* r, double* c,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* rpvgrw, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params );
lapack_int LAPACKE_sgetf2( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, lapack_int* ipiv );
lapack_int LAPACKE_dgetf2( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, lapack_int* ipiv );
lapack_int LAPACKE_cgetf2( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_int* ipiv );
lapack_int LAPACKE_zgetf2( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_int* ipiv );
lapack_int LAPACKE_sgetrf( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, lapack_int* ipiv );
lapack_int LAPACKE_dgetrf( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, lapack_int* ipiv );
lapack_int LAPACKE_cgetrf( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_int* ipiv );
lapack_int LAPACKE_zgetrf( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_int* ipiv );
lapack_int LAPACKE_sgetri( int matrix_order, lapack_int n, float* a,
lapack_int lda, const lapack_int* ipiv );
lapack_int LAPACKE_dgetri( int matrix_order, lapack_int n, double* a,
lapack_int lda, const lapack_int* ipiv );
lapack_int LAPACKE_cgetri( int matrix_order, lapack_int n,
lapack_complex_float* a, lapack_int lda,
const lapack_int* ipiv );
lapack_int LAPACKE_zgetri( int matrix_order, lapack_int n,
lapack_complex_double* a, lapack_int lda,
const lapack_int* ipiv );
lapack_int LAPACKE_sgetrs( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const float* a, lapack_int lda,
const lapack_int* ipiv, float* b, lapack_int ldb );
lapack_int LAPACKE_dgetrs( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const double* a, lapack_int lda,
const lapack_int* ipiv, double* b, lapack_int ldb );
lapack_int LAPACKE_cgetrs( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zgetrs( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_sggbak( int matrix_order, char job, char side, lapack_int n,
lapack_int ilo, lapack_int ihi, const float* lscale,
const float* rscale, lapack_int m, float* v,
lapack_int ldv );
lapack_int LAPACKE_dggbak( int matrix_order, char job, char side, lapack_int n,
lapack_int ilo, lapack_int ihi, const double* lscale,
const double* rscale, lapack_int m, double* v,
lapack_int ldv );
lapack_int LAPACKE_cggbak( int matrix_order, char job, char side, lapack_int n,
lapack_int ilo, lapack_int ihi, const float* lscale,
const float* rscale, lapack_int m,
lapack_complex_float* v, lapack_int ldv );
lapack_int LAPACKE_zggbak( int matrix_order, char job, char side, lapack_int n,
lapack_int ilo, lapack_int ihi, const double* lscale,
const double* rscale, lapack_int m,
lapack_complex_double* v, lapack_int ldv );
lapack_int LAPACKE_sggbal( int matrix_order, char job, lapack_int n, float* a,
lapack_int lda, float* b, lapack_int ldb,
lapack_int* ilo, lapack_int* ihi, float* lscale,
float* rscale );
lapack_int LAPACKE_dggbal( int matrix_order, char job, lapack_int n, double* a,
lapack_int lda, double* b, lapack_int ldb,
lapack_int* ilo, lapack_int* ihi, double* lscale,
double* rscale );
lapack_int LAPACKE_cggbal( int matrix_order, char job, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
lapack_int* ilo, lapack_int* ihi, float* lscale,
float* rscale );
lapack_int LAPACKE_zggbal( int matrix_order, char job, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
lapack_int* ilo, lapack_int* ihi, double* lscale,
double* rscale );
lapack_int LAPACKE_sgges( int matrix_order, char jobvsl, char jobvsr, char sort,
LAPACK_S_SELECT3 selctg, lapack_int n, float* a,
lapack_int lda, float* b, lapack_int ldb,
lapack_int* sdim, float* alphar, float* alphai,
float* beta, float* vsl, lapack_int ldvsl, float* vsr,
lapack_int ldvsr );
lapack_int LAPACKE_dgges( int matrix_order, char jobvsl, char jobvsr, char sort,
LAPACK_D_SELECT3 selctg, lapack_int n, double* a,
lapack_int lda, double* b, lapack_int ldb,
lapack_int* sdim, double* alphar, double* alphai,
double* beta, double* vsl, lapack_int ldvsl,
double* vsr, lapack_int ldvsr );
lapack_int LAPACKE_cgges( int matrix_order, char jobvsl, char jobvsr, char sort,
LAPACK_C_SELECT2 selctg, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
lapack_int* sdim, lapack_complex_float* alpha,
lapack_complex_float* beta, lapack_complex_float* vsl,
lapack_int ldvsl, lapack_complex_float* vsr,
lapack_int ldvsr );
lapack_int LAPACKE_zgges( int matrix_order, char jobvsl, char jobvsr, char sort,
LAPACK_Z_SELECT2 selctg, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
lapack_int* sdim, lapack_complex_double* alpha,
lapack_complex_double* beta,
lapack_complex_double* vsl, lapack_int ldvsl,
lapack_complex_double* vsr, lapack_int ldvsr );
lapack_int LAPACKE_sggesx( int matrix_order, char jobvsl, char jobvsr,
char sort, LAPACK_S_SELECT3 selctg, char sense,
lapack_int n, float* a, lapack_int lda, float* b,
lapack_int ldb, lapack_int* sdim, float* alphar,
float* alphai, float* beta, float* vsl,
lapack_int ldvsl, float* vsr, lapack_int ldvsr,
float* rconde, float* rcondv );
lapack_int LAPACKE_dggesx( int matrix_order, char jobvsl, char jobvsr,
char sort, LAPACK_D_SELECT3 selctg, char sense,
lapack_int n, double* a, lapack_int lda, double* b,
lapack_int ldb, lapack_int* sdim, double* alphar,
double* alphai, double* beta, double* vsl,
lapack_int ldvsl, double* vsr, lapack_int ldvsr,
double* rconde, double* rcondv );
lapack_int LAPACKE_cggesx( int matrix_order, char jobvsl, char jobvsr,
char sort, LAPACK_C_SELECT2 selctg, char sense,
lapack_int n, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb, lapack_int* sdim,
lapack_complex_float* alpha,
lapack_complex_float* beta,
lapack_complex_float* vsl, lapack_int ldvsl,
lapack_complex_float* vsr, lapack_int ldvsr,
float* rconde, float* rcondv );
lapack_int LAPACKE_zggesx( int matrix_order, char jobvsl, char jobvsr,
char sort, LAPACK_Z_SELECT2 selctg, char sense,
lapack_int n, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb, lapack_int* sdim,
lapack_complex_double* alpha,
lapack_complex_double* beta,
lapack_complex_double* vsl, lapack_int ldvsl,
lapack_complex_double* vsr, lapack_int ldvsr,
double* rconde, double* rcondv );
lapack_int LAPACKE_sggev( int matrix_order, char jobvl, char jobvr,
lapack_int n, float* a, lapack_int lda, float* b,
lapack_int ldb, float* alphar, float* alphai,
float* beta, float* vl, lapack_int ldvl, float* vr,
lapack_int ldvr );
lapack_int LAPACKE_dggev( int matrix_order, char jobvl, char jobvr,
lapack_int n, double* a, lapack_int lda, double* b,
lapack_int ldb, double* alphar, double* alphai,
double* beta, double* vl, lapack_int ldvl, double* vr,
lapack_int ldvr );
lapack_int LAPACKE_cggev( int matrix_order, char jobvl, char jobvr,
lapack_int n, lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* alpha,
lapack_complex_float* beta, lapack_complex_float* vl,
lapack_int ldvl, lapack_complex_float* vr,
lapack_int ldvr );
lapack_int LAPACKE_zggev( int matrix_order, char jobvl, char jobvr,
lapack_int n, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* alpha,
lapack_complex_double* beta,
lapack_complex_double* vl, lapack_int ldvl,
lapack_complex_double* vr, lapack_int ldvr );
lapack_int LAPACKE_sggevx( int matrix_order, char balanc, char jobvl,
char jobvr, char sense, lapack_int n, float* a,
lapack_int lda, float* b, lapack_int ldb,
float* alphar, float* alphai, float* beta, float* vl,
lapack_int ldvl, float* vr, lapack_int ldvr,
lapack_int* ilo, lapack_int* ihi, float* lscale,
float* rscale, float* abnrm, float* bbnrm,
float* rconde, float* rcondv );
lapack_int LAPACKE_dggevx( int matrix_order, char balanc, char jobvl,
char jobvr, char sense, lapack_int n, double* a,
lapack_int lda, double* b, lapack_int ldb,
double* alphar, double* alphai, double* beta,
double* vl, lapack_int ldvl, double* vr,
lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
double* lscale, double* rscale, double* abnrm,
double* bbnrm, double* rconde, double* rcondv );
lapack_int LAPACKE_cggevx( int matrix_order, char balanc, char jobvl,
char jobvr, char sense, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* alpha,
lapack_complex_float* beta, lapack_complex_float* vl,
lapack_int ldvl, lapack_complex_float* vr,
lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
float* lscale, float* rscale, float* abnrm,
float* bbnrm, float* rconde, float* rcondv );
lapack_int LAPACKE_zggevx( int matrix_order, char balanc, char jobvl,
char jobvr, char sense, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* alpha,
lapack_complex_double* beta,
lapack_complex_double* vl, lapack_int ldvl,
lapack_complex_double* vr, lapack_int ldvr,
lapack_int* ilo, lapack_int* ihi, double* lscale,
double* rscale, double* abnrm, double* bbnrm,
double* rconde, double* rcondv );
lapack_int LAPACKE_sggglm( int matrix_order, lapack_int n, lapack_int m,
lapack_int p, float* a, lapack_int lda, float* b,
lapack_int ldb, float* d, float* x, float* y );
lapack_int LAPACKE_dggglm( int matrix_order, lapack_int n, lapack_int m,
lapack_int p, double* a, lapack_int lda, double* b,
lapack_int ldb, double* d, double* x, double* y );
lapack_int LAPACKE_cggglm( int matrix_order, lapack_int n, lapack_int m,
lapack_int p, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* d,
lapack_complex_float* x, lapack_complex_float* y );
lapack_int LAPACKE_zggglm( int matrix_order, lapack_int n, lapack_int m,
lapack_int p, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* d,
lapack_complex_double* x, lapack_complex_double* y );
lapack_int LAPACKE_sgghrd( int matrix_order, char compq, char compz,
lapack_int n, lapack_int ilo, lapack_int ihi,
float* a, lapack_int lda, float* b, lapack_int ldb,
float* q, lapack_int ldq, float* z, lapack_int ldz );
lapack_int LAPACKE_dgghrd( int matrix_order, char compq, char compz,
lapack_int n, lapack_int ilo, lapack_int ihi,
double* a, lapack_int lda, double* b, lapack_int ldb,
double* q, lapack_int ldq, double* z,
lapack_int ldz );
lapack_int LAPACKE_cgghrd( int matrix_order, char compq, char compz,
lapack_int n, lapack_int ilo, lapack_int ihi,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* q, lapack_int ldq,
lapack_complex_float* z, lapack_int ldz );
lapack_int LAPACKE_zgghrd( int matrix_order, char compq, char compz,
lapack_int n, lapack_int ilo, lapack_int ihi,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* q, lapack_int ldq,
lapack_complex_double* z, lapack_int ldz );
lapack_int LAPACKE_sgglse( int matrix_order, lapack_int m, lapack_int n,
lapack_int p, float* a, lapack_int lda, float* b,
lapack_int ldb, float* c, float* d, float* x );
lapack_int LAPACKE_dgglse( int matrix_order, lapack_int m, lapack_int n,
lapack_int p, double* a, lapack_int lda, double* b,
lapack_int ldb, double* c, double* d, double* x );
lapack_int LAPACKE_cgglse( int matrix_order, lapack_int m, lapack_int n,
lapack_int p, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* c,
lapack_complex_float* d, lapack_complex_float* x );
lapack_int LAPACKE_zgglse( int matrix_order, lapack_int m, lapack_int n,
lapack_int p, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* c,
lapack_complex_double* d, lapack_complex_double* x );
lapack_int LAPACKE_sggqrf( int matrix_order, lapack_int n, lapack_int m,
lapack_int p, float* a, lapack_int lda, float* taua,
float* b, lapack_int ldb, float* taub );
lapack_int LAPACKE_dggqrf( int matrix_order, lapack_int n, lapack_int m,
lapack_int p, double* a, lapack_int lda,
double* taua, double* b, lapack_int ldb,
double* taub );
lapack_int LAPACKE_cggqrf( int matrix_order, lapack_int n, lapack_int m,
lapack_int p, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* taua,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* taub );
lapack_int LAPACKE_zggqrf( int matrix_order, lapack_int n, lapack_int m,
lapack_int p, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* taua,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* taub );
lapack_int LAPACKE_sggrqf( int matrix_order, lapack_int m, lapack_int p,
lapack_int n, float* a, lapack_int lda, float* taua,
float* b, lapack_int ldb, float* taub );
lapack_int LAPACKE_dggrqf( int matrix_order, lapack_int m, lapack_int p,
lapack_int n, double* a, lapack_int lda,
double* taua, double* b, lapack_int ldb,
double* taub );
lapack_int LAPACKE_cggrqf( int matrix_order, lapack_int m, lapack_int p,
lapack_int n, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* taua,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* taub );
lapack_int LAPACKE_zggrqf( int matrix_order, lapack_int m, lapack_int p,
lapack_int n, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* taua,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* taub );
lapack_int LAPACKE_sggsvd( int matrix_order, char jobu, char jobv, char jobq,
lapack_int m, lapack_int n, lapack_int p,
lapack_int* k, lapack_int* l, float* a,
lapack_int lda, float* b, lapack_int ldb,
float* alpha, float* beta, float* u, lapack_int ldu,
float* v, lapack_int ldv, float* q, lapack_int ldq,
lapack_int* iwork );
lapack_int LAPACKE_dggsvd( int matrix_order, char jobu, char jobv, char jobq,
lapack_int m, lapack_int n, lapack_int p,
lapack_int* k, lapack_int* l, double* a,
lapack_int lda, double* b, lapack_int ldb,
double* alpha, double* beta, double* u,
lapack_int ldu, double* v, lapack_int ldv, double* q,
lapack_int ldq, lapack_int* iwork );
lapack_int LAPACKE_cggsvd( int matrix_order, char jobu, char jobv, char jobq,
lapack_int m, lapack_int n, lapack_int p,
lapack_int* k, lapack_int* l,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
float* alpha, float* beta, lapack_complex_float* u,
lapack_int ldu, lapack_complex_float* v,
lapack_int ldv, lapack_complex_float* q,
lapack_int ldq, lapack_int* iwork );
lapack_int LAPACKE_zggsvd( int matrix_order, char jobu, char jobv, char jobq,
lapack_int m, lapack_int n, lapack_int p,
lapack_int* k, lapack_int* l,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
double* alpha, double* beta,
lapack_complex_double* u, lapack_int ldu,
lapack_complex_double* v, lapack_int ldv,
lapack_complex_double* q, lapack_int ldq,
lapack_int* iwork );
lapack_int LAPACKE_sggsvp( int matrix_order, char jobu, char jobv, char jobq,
lapack_int m, lapack_int p, lapack_int n, float* a,
lapack_int lda, float* b, lapack_int ldb, float tola,
float tolb, lapack_int* k, lapack_int* l, float* u,
lapack_int ldu, float* v, lapack_int ldv, float* q,
lapack_int ldq );
lapack_int LAPACKE_dggsvp( int matrix_order, char jobu, char jobv, char jobq,
lapack_int m, lapack_int p, lapack_int n, double* a,
lapack_int lda, double* b, lapack_int ldb,
double tola, double tolb, lapack_int* k,
lapack_int* l, double* u, lapack_int ldu, double* v,
lapack_int ldv, double* q, lapack_int ldq );
lapack_int LAPACKE_cggsvp( int matrix_order, char jobu, char jobv, char jobq,
lapack_int m, lapack_int p, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb, float tola,
float tolb, lapack_int* k, lapack_int* l,
lapack_complex_float* u, lapack_int ldu,
lapack_complex_float* v, lapack_int ldv,
lapack_complex_float* q, lapack_int ldq );
lapack_int LAPACKE_zggsvp( int matrix_order, char jobu, char jobv, char jobq,
lapack_int m, lapack_int p, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
double tola, double tolb, lapack_int* k,
lapack_int* l, lapack_complex_double* u,
lapack_int ldu, lapack_complex_double* v,
lapack_int ldv, lapack_complex_double* q,
lapack_int ldq );
lapack_int LAPACKE_sgtcon( char norm, lapack_int n, const float* dl,
const float* d, const float* du, const float* du2,
const lapack_int* ipiv, float anorm, float* rcond );
lapack_int LAPACKE_dgtcon( char norm, lapack_int n, const double* dl,
const double* d, const double* du, const double* du2,
const lapack_int* ipiv, double anorm,
double* rcond );
lapack_int LAPACKE_cgtcon( char norm, lapack_int n,
const lapack_complex_float* dl,
const lapack_complex_float* d,
const lapack_complex_float* du,
const lapack_complex_float* du2,
const lapack_int* ipiv, float anorm, float* rcond );
lapack_int LAPACKE_zgtcon( char norm, lapack_int n,
const lapack_complex_double* dl,
const lapack_complex_double* d,
const lapack_complex_double* du,
const lapack_complex_double* du2,
const lapack_int* ipiv, double anorm,
double* rcond );
lapack_int LAPACKE_sgtrfs( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const float* dl, const float* d,
const float* du, const float* dlf, const float* df,
const float* duf, const float* du2,
const lapack_int* ipiv, const float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* ferr, float* berr );
lapack_int LAPACKE_dgtrfs( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const double* dl, const double* d,
const double* du, const double* dlf,
const double* df, const double* duf,
const double* du2, const lapack_int* ipiv,
const double* b, lapack_int ldb, double* x,
lapack_int ldx, double* ferr, double* berr );
lapack_int LAPACKE_cgtrfs( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const lapack_complex_float* dl,
const lapack_complex_float* d,
const lapack_complex_float* du,
const lapack_complex_float* dlf,
const lapack_complex_float* df,
const lapack_complex_float* duf,
const lapack_complex_float* du2,
const lapack_int* ipiv,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx, float* ferr,
float* berr );
lapack_int LAPACKE_zgtrfs( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const lapack_complex_double* dl,
const lapack_complex_double* d,
const lapack_complex_double* du,
const lapack_complex_double* dlf,
const lapack_complex_double* df,
const lapack_complex_double* duf,
const lapack_complex_double* du2,
const lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr );
lapack_int LAPACKE_sgtsv( int matrix_order, lapack_int n, lapack_int nrhs,
float* dl, float* d, float* du, float* b,
lapack_int ldb );
lapack_int LAPACKE_dgtsv( int matrix_order, lapack_int n, lapack_int nrhs,
double* dl, double* d, double* du, double* b,
lapack_int ldb );
lapack_int LAPACKE_cgtsv( int matrix_order, lapack_int n, lapack_int nrhs,
lapack_complex_float* dl, lapack_complex_float* d,
lapack_complex_float* du, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zgtsv( int matrix_order, lapack_int n, lapack_int nrhs,
lapack_complex_double* dl, lapack_complex_double* d,
lapack_complex_double* du, lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_sgtsvx( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs, const float* dl,
const float* d, const float* du, float* dlf,
float* df, float* duf, float* du2, lapack_int* ipiv,
const float* b, lapack_int ldb, float* x,
lapack_int ldx, float* rcond, float* ferr,
float* berr );
lapack_int LAPACKE_dgtsvx( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs, const double* dl,
const double* d, const double* du, double* dlf,
double* df, double* duf, double* du2,
lapack_int* ipiv, const double* b, lapack_int ldb,
double* x, lapack_int ldx, double* rcond,
double* ferr, double* berr );
lapack_int LAPACKE_cgtsvx( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs,
const lapack_complex_float* dl,
const lapack_complex_float* d,
const lapack_complex_float* du,
lapack_complex_float* dlf, lapack_complex_float* df,
lapack_complex_float* duf, lapack_complex_float* du2,
lapack_int* ipiv, const lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* x,
lapack_int ldx, float* rcond, float* ferr,
float* berr );
lapack_int LAPACKE_zgtsvx( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs,
const lapack_complex_double* dl,
const lapack_complex_double* d,
const lapack_complex_double* du,
lapack_complex_double* dlf,
lapack_complex_double* df,
lapack_complex_double* duf,
lapack_complex_double* du2, lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr );
lapack_int LAPACKE_sgttrf( lapack_int n, float* dl, float* d, float* du,
float* du2, lapack_int* ipiv );
lapack_int LAPACKE_dgttrf( lapack_int n, double* dl, double* d, double* du,
double* du2, lapack_int* ipiv );
lapack_int LAPACKE_cgttrf( lapack_int n, lapack_complex_float* dl,
lapack_complex_float* d, lapack_complex_float* du,
lapack_complex_float* du2, lapack_int* ipiv );
lapack_int LAPACKE_zgttrf( lapack_int n, lapack_complex_double* dl,
lapack_complex_double* d, lapack_complex_double* du,
lapack_complex_double* du2, lapack_int* ipiv );
lapack_int LAPACKE_sgttrs( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const float* dl, const float* d,
const float* du, const float* du2,
const lapack_int* ipiv, float* b, lapack_int ldb );
lapack_int LAPACKE_dgttrs( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const double* dl, const double* d,
const double* du, const double* du2,
const lapack_int* ipiv, double* b, lapack_int ldb );
lapack_int LAPACKE_cgttrs( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const lapack_complex_float* dl,
const lapack_complex_float* d,
const lapack_complex_float* du,
const lapack_complex_float* du2,
const lapack_int* ipiv, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zgttrs( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const lapack_complex_double* dl,
const lapack_complex_double* d,
const lapack_complex_double* du,
const lapack_complex_double* du2,
const lapack_int* ipiv, lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_chbev( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_int kd, lapack_complex_float* ab,
lapack_int ldab, float* w, lapack_complex_float* z,
lapack_int ldz );
lapack_int LAPACKE_zhbev( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_int kd, lapack_complex_double* ab,
lapack_int ldab, double* w, lapack_complex_double* z,
lapack_int ldz );
lapack_int LAPACKE_chbevd( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_int kd, lapack_complex_float* ab,
lapack_int ldab, float* w, lapack_complex_float* z,
lapack_int ldz );
lapack_int LAPACKE_zhbevd( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_int kd, lapack_complex_double* ab,
lapack_int ldab, double* w, lapack_complex_double* z,
lapack_int ldz );
lapack_int LAPACKE_chbevx( int matrix_order, char jobz, char range, char uplo,
lapack_int n, lapack_int kd,
lapack_complex_float* ab, lapack_int ldab,
lapack_complex_float* q, lapack_int ldq, float vl,
float vu, lapack_int il, lapack_int iu, float abstol,
lapack_int* m, float* w, lapack_complex_float* z,
lapack_int ldz, lapack_int* ifail );
lapack_int LAPACKE_zhbevx( int matrix_order, char jobz, char range, char uplo,
lapack_int n, lapack_int kd,
lapack_complex_double* ab, lapack_int ldab,
lapack_complex_double* q, lapack_int ldq, double vl,
double vu, lapack_int il, lapack_int iu,
double abstol, lapack_int* m, double* w,
lapack_complex_double* z, lapack_int ldz,
lapack_int* ifail );
lapack_int LAPACKE_chbgst( int matrix_order, char vect, char uplo, lapack_int n,
lapack_int ka, lapack_int kb,
lapack_complex_float* ab, lapack_int ldab,
const lapack_complex_float* bb, lapack_int ldbb,
lapack_complex_float* x, lapack_int ldx );
lapack_int LAPACKE_zhbgst( int matrix_order, char vect, char uplo, lapack_int n,
lapack_int ka, lapack_int kb,
lapack_complex_double* ab, lapack_int ldab,
const lapack_complex_double* bb, lapack_int ldbb,
lapack_complex_double* x, lapack_int ldx );
lapack_int LAPACKE_chbgv( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_int ka, lapack_int kb,
lapack_complex_float* ab, lapack_int ldab,
lapack_complex_float* bb, lapack_int ldbb, float* w,
lapack_complex_float* z, lapack_int ldz );
lapack_int LAPACKE_zhbgv( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_int ka, lapack_int kb,
lapack_complex_double* ab, lapack_int ldab,
lapack_complex_double* bb, lapack_int ldbb, double* w,
lapack_complex_double* z, lapack_int ldz );
lapack_int LAPACKE_chbgvd( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_int ka, lapack_int kb,
lapack_complex_float* ab, lapack_int ldab,
lapack_complex_float* bb, lapack_int ldbb, float* w,
lapack_complex_float* z, lapack_int ldz );
lapack_int LAPACKE_zhbgvd( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_int ka, lapack_int kb,
lapack_complex_double* ab, lapack_int ldab,
lapack_complex_double* bb, lapack_int ldbb,
double* w, lapack_complex_double* z,
lapack_int ldz );
lapack_int LAPACKE_chbgvx( int matrix_order, char jobz, char range, char uplo,
lapack_int n, lapack_int ka, lapack_int kb,
lapack_complex_float* ab, lapack_int ldab,
lapack_complex_float* bb, lapack_int ldbb,
lapack_complex_float* q, lapack_int ldq, float vl,
float vu, lapack_int il, lapack_int iu, float abstol,
lapack_int* m, float* w, lapack_complex_float* z,
lapack_int ldz, lapack_int* ifail );
lapack_int LAPACKE_zhbgvx( int matrix_order, char jobz, char range, char uplo,
lapack_int n, lapack_int ka, lapack_int kb,
lapack_complex_double* ab, lapack_int ldab,
lapack_complex_double* bb, lapack_int ldbb,
lapack_complex_double* q, lapack_int ldq, double vl,
double vu, lapack_int il, lapack_int iu,
double abstol, lapack_int* m, double* w,
lapack_complex_double* z, lapack_int ldz,
lapack_int* ifail );
lapack_int LAPACKE_chbtrd( int matrix_order, char vect, char uplo, lapack_int n,
lapack_int kd, lapack_complex_float* ab,
lapack_int ldab, float* d, float* e,
lapack_complex_float* q, lapack_int ldq );
lapack_int LAPACKE_zhbtrd( int matrix_order, char vect, char uplo, lapack_int n,
lapack_int kd, lapack_complex_double* ab,
lapack_int ldab, double* d, double* e,
lapack_complex_double* q, lapack_int ldq );
lapack_int LAPACKE_checon( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
const lapack_int* ipiv, float anorm, float* rcond );
lapack_int LAPACKE_zhecon( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
const lapack_int* ipiv, double anorm,
double* rcond );
lapack_int LAPACKE_cheequb( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
float* s, float* scond, float* amax );
lapack_int LAPACKE_zheequb( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
double* s, double* scond, double* amax );
lapack_int LAPACKE_cheev( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda, float* w );
lapack_int LAPACKE_zheev( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda, double* w );
lapack_int LAPACKE_cheevd( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda, float* w );
lapack_int LAPACKE_zheevd( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
double* w );
lapack_int LAPACKE_cheevr( int matrix_order, char jobz, char range, char uplo,
lapack_int n, lapack_complex_float* a,
lapack_int lda, float vl, float vu, lapack_int il,
lapack_int iu, float abstol, lapack_int* m, float* w,
lapack_complex_float* z, lapack_int ldz,
lapack_int* isuppz );
lapack_int LAPACKE_zheevr( int matrix_order, char jobz, char range, char uplo,
lapack_int n, lapack_complex_double* a,
lapack_int lda, double vl, double vu, lapack_int il,
lapack_int iu, double abstol, lapack_int* m,
double* w, lapack_complex_double* z, lapack_int ldz,
lapack_int* isuppz );
lapack_int LAPACKE_cheevx( int matrix_order, char jobz, char range, char uplo,
lapack_int n, lapack_complex_float* a,
lapack_int lda, float vl, float vu, lapack_int il,
lapack_int iu, float abstol, lapack_int* m, float* w,
lapack_complex_float* z, lapack_int ldz,
lapack_int* ifail );
lapack_int LAPACKE_zheevx( int matrix_order, char jobz, char range, char uplo,
lapack_int n, lapack_complex_double* a,
lapack_int lda, double vl, double vu, lapack_int il,
lapack_int iu, double abstol, lapack_int* m,
double* w, lapack_complex_double* z, lapack_int ldz,
lapack_int* ifail );
lapack_int LAPACKE_chegst( int matrix_order, lapack_int itype, char uplo,
lapack_int n, lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zhegst( int matrix_order, lapack_int itype, char uplo,
lapack_int n, lapack_complex_double* a,
lapack_int lda, const lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_chegv( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb, float* w );
lapack_int LAPACKE_zhegv( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb, double* w );
lapack_int LAPACKE_chegvd( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb, float* w );
lapack_int LAPACKE_zhegvd( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb, double* w );
lapack_int LAPACKE_chegvx( int matrix_order, lapack_int itype, char jobz,
char range, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb, float vl,
float vu, lapack_int il, lapack_int iu, float abstol,
lapack_int* m, float* w, lapack_complex_float* z,
lapack_int ldz, lapack_int* ifail );
lapack_int LAPACKE_zhegvx( int matrix_order, lapack_int itype, char jobz,
char range, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb, double vl,
double vu, lapack_int il, lapack_int iu,
double abstol, lapack_int* m, double* w,
lapack_complex_double* z, lapack_int ldz,
lapack_int* ifail );
lapack_int LAPACKE_cherfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* af,
lapack_int ldaf, const lapack_int* ipiv,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx, float* ferr,
float* berr );
lapack_int LAPACKE_zherfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, const lapack_complex_double* af,
lapack_int ldaf, const lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr );
lapack_int LAPACKE_cherfsx( int matrix_order, char uplo, char equed,
lapack_int n, lapack_int nrhs,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* af, lapack_int ldaf,
const lapack_int* ipiv, const float* s,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* berr, lapack_int n_err_bnds,
float* err_bnds_norm, float* err_bnds_comp,
lapack_int nparams, float* params );
lapack_int LAPACKE_zherfsx( int matrix_order, char uplo, char equed,
lapack_int n, lapack_int nrhs,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* af, lapack_int ldaf,
const lapack_int* ipiv, const double* s,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* berr, lapack_int n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int nparams, double* params );
lapack_int LAPACKE_chesv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_float* a,
lapack_int lda, lapack_int* ipiv,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zhesv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_double* a,
lapack_int lda, lapack_int* ipiv,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_chesvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, lapack_complex_float* af,
lapack_int ldaf, lapack_int* ipiv,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* ferr, float* berr );
lapack_int LAPACKE_zhesvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, lapack_complex_double* af,
lapack_int ldaf, lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr );
lapack_int LAPACKE_chesvxx( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, float* s,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* rpvgrw, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params );
lapack_int LAPACKE_zhesvxx( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, double* s,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* rpvgrw, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params );
lapack_int LAPACKE_chetrd( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda, float* d,
float* e, lapack_complex_float* tau );
lapack_int LAPACKE_zhetrd( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda, double* d,
double* e, lapack_complex_double* tau );
lapack_int LAPACKE_chetrf( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_int* ipiv );
lapack_int LAPACKE_zhetrf( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_int* ipiv );
lapack_int LAPACKE_chetri( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
const lapack_int* ipiv );
lapack_int LAPACKE_zhetri( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
const lapack_int* ipiv );
lapack_int LAPACKE_chetrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zhetrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_chfrk( int matrix_order, char transr, char uplo, char trans,
lapack_int n, lapack_int k, float alpha,
const lapack_complex_float* a, lapack_int lda,
float beta, lapack_complex_float* c );
lapack_int LAPACKE_zhfrk( int matrix_order, char transr, char uplo, char trans,
lapack_int n, lapack_int k, double alpha,
const lapack_complex_double* a, lapack_int lda,
double beta, lapack_complex_double* c );
lapack_int LAPACKE_shgeqz( int matrix_order, char job, char compq, char compz,
lapack_int n, lapack_int ilo, lapack_int ihi,
float* h, lapack_int ldh, float* t, lapack_int ldt,
float* alphar, float* alphai, float* beta, float* q,
lapack_int ldq, float* z, lapack_int ldz );
lapack_int LAPACKE_dhgeqz( int matrix_order, char job, char compq, char compz,
lapack_int n, lapack_int ilo, lapack_int ihi,
double* h, lapack_int ldh, double* t, lapack_int ldt,
double* alphar, double* alphai, double* beta,
double* q, lapack_int ldq, double* z,
lapack_int ldz );
lapack_int LAPACKE_chgeqz( int matrix_order, char job, char compq, char compz,
lapack_int n, lapack_int ilo, lapack_int ihi,
lapack_complex_float* h, lapack_int ldh,
lapack_complex_float* t, lapack_int ldt,
lapack_complex_float* alpha,
lapack_complex_float* beta, lapack_complex_float* q,
lapack_int ldq, lapack_complex_float* z,
lapack_int ldz );
lapack_int LAPACKE_zhgeqz( int matrix_order, char job, char compq, char compz,
lapack_int n, lapack_int ilo, lapack_int ihi,
lapack_complex_double* h, lapack_int ldh,
lapack_complex_double* t, lapack_int ldt,
lapack_complex_double* alpha,
lapack_complex_double* beta,
lapack_complex_double* q, lapack_int ldq,
lapack_complex_double* z, lapack_int ldz );
lapack_int LAPACKE_chpcon( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* ap,
const lapack_int* ipiv, float anorm, float* rcond );
lapack_int LAPACKE_zhpcon( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* ap,
const lapack_int* ipiv, double anorm,
double* rcond );
lapack_int LAPACKE_chpev( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_complex_float* ap, float* w,
lapack_complex_float* z, lapack_int ldz );
lapack_int LAPACKE_zhpev( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_complex_double* ap, double* w,
lapack_complex_double* z, lapack_int ldz );
lapack_int LAPACKE_chpevd( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_complex_float* ap, float* w,
lapack_complex_float* z, lapack_int ldz );
lapack_int LAPACKE_zhpevd( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_complex_double* ap, double* w,
lapack_complex_double* z, lapack_int ldz );
lapack_int LAPACKE_chpevx( int matrix_order, char jobz, char range, char uplo,
lapack_int n, lapack_complex_float* ap, float vl,
float vu, lapack_int il, lapack_int iu, float abstol,
lapack_int* m, float* w, lapack_complex_float* z,
lapack_int ldz, lapack_int* ifail );
lapack_int LAPACKE_zhpevx( int matrix_order, char jobz, char range, char uplo,
lapack_int n, lapack_complex_double* ap, double vl,
double vu, lapack_int il, lapack_int iu,
double abstol, lapack_int* m, double* w,
lapack_complex_double* z, lapack_int ldz,
lapack_int* ifail );
lapack_int LAPACKE_chpgst( int matrix_order, lapack_int itype, char uplo,
lapack_int n, lapack_complex_float* ap,
const lapack_complex_float* bp );
lapack_int LAPACKE_zhpgst( int matrix_order, lapack_int itype, char uplo,
lapack_int n, lapack_complex_double* ap,
const lapack_complex_double* bp );
lapack_int LAPACKE_chpgv( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, lapack_complex_float* ap,
lapack_complex_float* bp, float* w,
lapack_complex_float* z, lapack_int ldz );
lapack_int LAPACKE_zhpgv( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, lapack_complex_double* ap,
lapack_complex_double* bp, double* w,
lapack_complex_double* z, lapack_int ldz );
lapack_int LAPACKE_chpgvd( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, lapack_complex_float* ap,
lapack_complex_float* bp, float* w,
lapack_complex_float* z, lapack_int ldz );
lapack_int LAPACKE_zhpgvd( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, lapack_complex_double* ap,
lapack_complex_double* bp, double* w,
lapack_complex_double* z, lapack_int ldz );
lapack_int LAPACKE_chpgvx( int matrix_order, lapack_int itype, char jobz,
char range, char uplo, lapack_int n,
lapack_complex_float* ap, lapack_complex_float* bp,
float vl, float vu, lapack_int il, lapack_int iu,
float abstol, lapack_int* m, float* w,
lapack_complex_float* z, lapack_int ldz,
lapack_int* ifail );
lapack_int LAPACKE_zhpgvx( int matrix_order, lapack_int itype, char jobz,
char range, char uplo, lapack_int n,
lapack_complex_double* ap, lapack_complex_double* bp,
double vl, double vu, lapack_int il, lapack_int iu,
double abstol, lapack_int* m, double* w,
lapack_complex_double* z, lapack_int ldz,
lapack_int* ifail );
lapack_int LAPACKE_chprfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* ap,
const lapack_complex_float* afp,
const lapack_int* ipiv,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx, float* ferr,
float* berr );
lapack_int LAPACKE_zhprfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* ap,
const lapack_complex_double* afp,
const lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr );
lapack_int LAPACKE_chpsv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_float* ap,
lapack_int* ipiv, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zhpsv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_double* ap,
lapack_int* ipiv, lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_chpsvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* ap,
lapack_complex_float* afp, lapack_int* ipiv,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* ferr, float* berr );
lapack_int LAPACKE_zhpsvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* ap,
lapack_complex_double* afp, lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr );
lapack_int LAPACKE_chptrd( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* ap, float* d, float* e,
lapack_complex_float* tau );
lapack_int LAPACKE_zhptrd( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* ap, double* d, double* e,
lapack_complex_double* tau );
lapack_int LAPACKE_chptrf( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* ap, lapack_int* ipiv );
lapack_int LAPACKE_zhptrf( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* ap, lapack_int* ipiv );
lapack_int LAPACKE_chptri( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* ap, const lapack_int* ipiv );
lapack_int LAPACKE_zhptri( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* ap, const lapack_int* ipiv );
lapack_int LAPACKE_chptrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* ap,
const lapack_int* ipiv, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zhptrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* ap,
const lapack_int* ipiv, lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_shsein( int matrix_order, char job, char eigsrc, char initv,
lapack_logical* select, lapack_int n, const float* h,
lapack_int ldh, float* wr, const float* wi,
float* vl, lapack_int ldvl, float* vr,
lapack_int ldvr, lapack_int mm, lapack_int* m,
lapack_int* ifaill, lapack_int* ifailr );
lapack_int LAPACKE_dhsein( int matrix_order, char job, char eigsrc, char initv,
lapack_logical* select, lapack_int n,
const double* h, lapack_int ldh, double* wr,
const double* wi, double* vl, lapack_int ldvl,
double* vr, lapack_int ldvr, lapack_int mm,
lapack_int* m, lapack_int* ifaill,
lapack_int* ifailr );
lapack_int LAPACKE_chsein( int matrix_order, char job, char eigsrc, char initv,
const lapack_logical* select, lapack_int n,
const lapack_complex_float* h, lapack_int ldh,
lapack_complex_float* w, lapack_complex_float* vl,
lapack_int ldvl, lapack_complex_float* vr,
lapack_int ldvr, lapack_int mm, lapack_int* m,
lapack_int* ifaill, lapack_int* ifailr );
lapack_int LAPACKE_zhsein( int matrix_order, char job, char eigsrc, char initv,
const lapack_logical* select, lapack_int n,
const lapack_complex_double* h, lapack_int ldh,
lapack_complex_double* w, lapack_complex_double* vl,
lapack_int ldvl, lapack_complex_double* vr,
lapack_int ldvr, lapack_int mm, lapack_int* m,
lapack_int* ifaill, lapack_int* ifailr );
lapack_int LAPACKE_shseqr( int matrix_order, char job, char compz, lapack_int n,
lapack_int ilo, lapack_int ihi, float* h,
lapack_int ldh, float* wr, float* wi, float* z,
lapack_int ldz );
lapack_int LAPACKE_dhseqr( int matrix_order, char job, char compz, lapack_int n,
lapack_int ilo, lapack_int ihi, double* h,
lapack_int ldh, double* wr, double* wi, double* z,
lapack_int ldz );
lapack_int LAPACKE_chseqr( int matrix_order, char job, char compz, lapack_int n,
lapack_int ilo, lapack_int ihi,
lapack_complex_float* h, lapack_int ldh,
lapack_complex_float* w, lapack_complex_float* z,
lapack_int ldz );
lapack_int LAPACKE_zhseqr( int matrix_order, char job, char compz, lapack_int n,
lapack_int ilo, lapack_int ihi,
lapack_complex_double* h, lapack_int ldh,
lapack_complex_double* w, lapack_complex_double* z,
lapack_int ldz );
lapack_int LAPACKE_clacgv( lapack_int n, lapack_complex_float* x,
lapack_int incx );
lapack_int LAPACKE_zlacgv( lapack_int n, lapack_complex_double* x,
lapack_int incx );
lapack_int LAPACKE_slacpy( int matrix_order, char uplo, lapack_int m,
lapack_int n, const float* a, lapack_int lda, float* b,
lapack_int ldb );
lapack_int LAPACKE_dlacpy( int matrix_order, char uplo, lapack_int m,
lapack_int n, const double* a, lapack_int lda, double* b,
lapack_int ldb );
lapack_int LAPACKE_clacpy( int matrix_order, char uplo, lapack_int m,
lapack_int n, const lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zlacpy( int matrix_order, char uplo, lapack_int m,
lapack_int n, const lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_zlag2c( int matrix_order, lapack_int m, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
lapack_complex_float* sa, lapack_int ldsa );
lapack_int LAPACKE_slag2d( int matrix_order, lapack_int m, lapack_int n,
const float* sa, lapack_int ldsa, double* a,
lapack_int lda );
lapack_int LAPACKE_dlag2s( int matrix_order, lapack_int m, lapack_int n,
const double* a, lapack_int lda, float* sa,
lapack_int ldsa );
lapack_int LAPACKE_clag2z( int matrix_order, lapack_int m, lapack_int n,
const lapack_complex_float* sa, lapack_int ldsa,
lapack_complex_double* a, lapack_int lda );
lapack_int LAPACKE_slagge( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku, const float* d,
float* a, lapack_int lda, lapack_int* iseed );
lapack_int LAPACKE_dlagge( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku, const double* d,
double* a, lapack_int lda, lapack_int* iseed );
lapack_int LAPACKE_clagge( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku, const float* d,
lapack_complex_float* a, lapack_int lda,
lapack_int* iseed );
lapack_int LAPACKE_zlagge( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku, const double* d,
lapack_complex_double* a, lapack_int lda,
lapack_int* iseed );
float LAPACKE_slamch( char cmach );
double LAPACKE_dlamch( char cmach );
float LAPACKE_slange( int matrix_order, char norm, lapack_int m,
lapack_int n, const float* a, lapack_int lda );
double LAPACKE_dlange( int matrix_order, char norm, lapack_int m,
lapack_int n, const double* a, lapack_int lda );
float LAPACKE_clange( int matrix_order, char norm, lapack_int m,
lapack_int n, const lapack_complex_float* a,
lapack_int lda );
double LAPACKE_zlange( int matrix_order, char norm, lapack_int m,
lapack_int n, const lapack_complex_double* a,
lapack_int lda );
float LAPACKE_clanhe( int matrix_order, char norm, char uplo, lapack_int n,
const lapack_complex_float* a, lapack_int lda );
double LAPACKE_zlanhe( int matrix_order, char norm, char uplo, lapack_int n,
const lapack_complex_double* a, lapack_int lda );
float LAPACKE_slansy( int matrix_order, char norm, char uplo, lapack_int n,
const float* a, lapack_int lda );
double LAPACKE_dlansy( int matrix_order, char norm, char uplo, lapack_int n,
const double* a, lapack_int lda );
float LAPACKE_clansy( int matrix_order, char norm, char uplo, lapack_int n,
const lapack_complex_float* a, lapack_int lda );
double LAPACKE_zlansy( int matrix_order, char norm, char uplo, lapack_int n,
const lapack_complex_double* a, lapack_int lda );
float LAPACKE_slantr( int matrix_order, char norm, char uplo, char diag,
lapack_int m, lapack_int n, const float* a,
lapack_int lda );
double LAPACKE_dlantr( int matrix_order, char norm, char uplo, char diag,
lapack_int m, lapack_int n, const double* a,
lapack_int lda );
float LAPACKE_clantr( int matrix_order, char norm, char uplo, char diag,
lapack_int m, lapack_int n, const lapack_complex_float* a,
lapack_int lda );
double LAPACKE_zlantr( int matrix_order, char norm, char uplo, char diag,
lapack_int m, lapack_int n, const lapack_complex_double* a,
lapack_int lda );
lapack_int LAPACKE_slarfb( int matrix_order, char side, char trans, char direct,
char storev, lapack_int m, lapack_int n,
lapack_int k, const float* v, lapack_int ldv,
const float* t, lapack_int ldt, float* c,
lapack_int ldc );
lapack_int LAPACKE_dlarfb( int matrix_order, char side, char trans, char direct,
char storev, lapack_int m, lapack_int n,
lapack_int k, const double* v, lapack_int ldv,
const double* t, lapack_int ldt, double* c,
lapack_int ldc );
lapack_int LAPACKE_clarfb( int matrix_order, char side, char trans, char direct,
char storev, lapack_int m, lapack_int n,
lapack_int k, const lapack_complex_float* v,
lapack_int ldv, const lapack_complex_float* t,
lapack_int ldt, lapack_complex_float* c,
lapack_int ldc );
lapack_int LAPACKE_zlarfb( int matrix_order, char side, char trans, char direct,
char storev, lapack_int m, lapack_int n,
lapack_int k, const lapack_complex_double* v,
lapack_int ldv, const lapack_complex_double* t,
lapack_int ldt, lapack_complex_double* c,
lapack_int ldc );
lapack_int LAPACKE_slarfg( lapack_int n, float* alpha, float* x,
lapack_int incx, float* tau );
lapack_int LAPACKE_dlarfg( lapack_int n, double* alpha, double* x,
lapack_int incx, double* tau );
lapack_int LAPACKE_clarfg( lapack_int n, lapack_complex_float* alpha,
lapack_complex_float* x, lapack_int incx,
lapack_complex_float* tau );
lapack_int LAPACKE_zlarfg( lapack_int n, lapack_complex_double* alpha,
lapack_complex_double* x, lapack_int incx,
lapack_complex_double* tau );
lapack_int LAPACKE_slarft( int matrix_order, char direct, char storev,
lapack_int n, lapack_int k, const float* v,
lapack_int ldv, const float* tau, float* t,
lapack_int ldt );
lapack_int LAPACKE_dlarft( int matrix_order, char direct, char storev,
lapack_int n, lapack_int k, const double* v,
lapack_int ldv, const double* tau, double* t,
lapack_int ldt );
lapack_int LAPACKE_clarft( int matrix_order, char direct, char storev,
lapack_int n, lapack_int k,
const lapack_complex_float* v, lapack_int ldv,
const lapack_complex_float* tau,
lapack_complex_float* t, lapack_int ldt );
lapack_int LAPACKE_zlarft( int matrix_order, char direct, char storev,
lapack_int n, lapack_int k,
const lapack_complex_double* v, lapack_int ldv,
const lapack_complex_double* tau,
lapack_complex_double* t, lapack_int ldt );
lapack_int LAPACKE_slarfx( int matrix_order, char side, lapack_int m,
lapack_int n, const float* v, float tau, float* c,
lapack_int ldc, float* work );
lapack_int LAPACKE_dlarfx( int matrix_order, char side, lapack_int m,
lapack_int n, const double* v, double tau, double* c,
lapack_int ldc, double* work );
lapack_int LAPACKE_clarfx( int matrix_order, char side, lapack_int m,
lapack_int n, const lapack_complex_float* v,
lapack_complex_float tau, lapack_complex_float* c,
lapack_int ldc, lapack_complex_float* work );
lapack_int LAPACKE_zlarfx( int matrix_order, char side, lapack_int m,
lapack_int n, const lapack_complex_double* v,
lapack_complex_double tau, lapack_complex_double* c,
lapack_int ldc, lapack_complex_double* work );
lapack_int LAPACKE_slarnv( lapack_int idist, lapack_int* iseed, lapack_int n,
float* x );
lapack_int LAPACKE_dlarnv( lapack_int idist, lapack_int* iseed, lapack_int n,
double* x );
lapack_int LAPACKE_clarnv( lapack_int idist, lapack_int* iseed, lapack_int n,
lapack_complex_float* x );
lapack_int LAPACKE_zlarnv( lapack_int idist, lapack_int* iseed, lapack_int n,
lapack_complex_double* x );
lapack_int LAPACKE_slaset( int matrix_order, char uplo, lapack_int m,
lapack_int n, float alpha, float beta, float* a,
lapack_int lda );
lapack_int LAPACKE_dlaset( int matrix_order, char uplo, lapack_int m,
lapack_int n, double alpha, double beta, double* a,
lapack_int lda );
lapack_int LAPACKE_claset( int matrix_order, char uplo, lapack_int m,
lapack_int n, lapack_complex_float alpha,
lapack_complex_float beta, lapack_complex_float* a,
lapack_int lda );
lapack_int LAPACKE_zlaset( int matrix_order, char uplo, lapack_int m,
lapack_int n, lapack_complex_double alpha,
lapack_complex_double beta, lapack_complex_double* a,
lapack_int lda );
lapack_int LAPACKE_slasrt( char id, lapack_int n, float* d );
lapack_int LAPACKE_dlasrt( char id, lapack_int n, double* d );
lapack_int LAPACKE_slaswp( int matrix_order, lapack_int n, float* a,
lapack_int lda, lapack_int k1, lapack_int k2,
const lapack_int* ipiv, lapack_int incx );
lapack_int LAPACKE_dlaswp( int matrix_order, lapack_int n, double* a,
lapack_int lda, lapack_int k1, lapack_int k2,
const lapack_int* ipiv, lapack_int incx );
lapack_int LAPACKE_claswp( int matrix_order, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_int k1, lapack_int k2, const lapack_int* ipiv,
lapack_int incx );
lapack_int LAPACKE_zlaswp( int matrix_order, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_int k1, lapack_int k2, const lapack_int* ipiv,
lapack_int incx );
lapack_int LAPACKE_slatms( int matrix_order, lapack_int m, lapack_int n,
char dist, lapack_int* iseed, char sym, float* d,
lapack_int mode, float cond, float dmax,
lapack_int kl, lapack_int ku, char pack, float* a,
lapack_int lda );
lapack_int LAPACKE_dlatms( int matrix_order, lapack_int m, lapack_int n,
char dist, lapack_int* iseed, char sym, double* d,
lapack_int mode, double cond, double dmax,
lapack_int kl, lapack_int ku, char pack, double* a,
lapack_int lda );
lapack_int LAPACKE_clatms( int matrix_order, lapack_int m, lapack_int n,
char dist, lapack_int* iseed, char sym, float* d,
lapack_int mode, float cond, float dmax,
lapack_int kl, lapack_int ku, char pack,
lapack_complex_float* a, lapack_int lda );
lapack_int LAPACKE_zlatms( int matrix_order, lapack_int m, lapack_int n,
char dist, lapack_int* iseed, char sym, double* d,
lapack_int mode, double cond, double dmax,
lapack_int kl, lapack_int ku, char pack,
lapack_complex_double* a, lapack_int lda );
lapack_int LAPACKE_slauum( int matrix_order, char uplo, lapack_int n, float* a,
lapack_int lda );
lapack_int LAPACKE_dlauum( int matrix_order, char uplo, lapack_int n, double* a,
lapack_int lda );
lapack_int LAPACKE_clauum( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda );
lapack_int LAPACKE_zlauum( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda );
lapack_int LAPACKE_sopgtr( int matrix_order, char uplo, lapack_int n,
const float* ap, const float* tau, float* q,
lapack_int ldq );
lapack_int LAPACKE_dopgtr( int matrix_order, char uplo, lapack_int n,
const double* ap, const double* tau, double* q,
lapack_int ldq );
lapack_int LAPACKE_sopmtr( int matrix_order, char side, char uplo, char trans,
lapack_int m, lapack_int n, const float* ap,
const float* tau, float* c, lapack_int ldc );
lapack_int LAPACKE_dopmtr( int matrix_order, char side, char uplo, char trans,
lapack_int m, lapack_int n, const double* ap,
const double* tau, double* c, lapack_int ldc );
lapack_int LAPACKE_sorgbr( int matrix_order, char vect, lapack_int m,
lapack_int n, lapack_int k, float* a, lapack_int lda,
const float* tau );
lapack_int LAPACKE_dorgbr( int matrix_order, char vect, lapack_int m,
lapack_int n, lapack_int k, double* a,
lapack_int lda, const double* tau );
lapack_int LAPACKE_sorghr( int matrix_order, lapack_int n, lapack_int ilo,
lapack_int ihi, float* a, lapack_int lda,
const float* tau );
lapack_int LAPACKE_dorghr( int matrix_order, lapack_int n, lapack_int ilo,
lapack_int ihi, double* a, lapack_int lda,
const double* tau );
lapack_int LAPACKE_sorglq( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, float* a, lapack_int lda,
const float* tau );
lapack_int LAPACKE_dorglq( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, double* a, lapack_int lda,
const double* tau );
lapack_int LAPACKE_sorgql( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, float* a, lapack_int lda,
const float* tau );
lapack_int LAPACKE_dorgql( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, double* a, lapack_int lda,
const double* tau );
lapack_int LAPACKE_sorgqr( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, float* a, lapack_int lda,
const float* tau );
lapack_int LAPACKE_dorgqr( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, double* a, lapack_int lda,
const double* tau );
lapack_int LAPACKE_sorgrq( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, float* a, lapack_int lda,
const float* tau );
lapack_int LAPACKE_dorgrq( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, double* a, lapack_int lda,
const double* tau );
lapack_int LAPACKE_sorgtr( int matrix_order, char uplo, lapack_int n, float* a,
lapack_int lda, const float* tau );
lapack_int LAPACKE_dorgtr( int matrix_order, char uplo, lapack_int n, double* a,
lapack_int lda, const double* tau );
lapack_int LAPACKE_sormbr( int matrix_order, char vect, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const float* a, lapack_int lda, const float* tau,
float* c, lapack_int ldc );
lapack_int LAPACKE_dormbr( int matrix_order, char vect, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const double* a, lapack_int lda, const double* tau,
double* c, lapack_int ldc );
lapack_int LAPACKE_sormhr( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int ilo,
lapack_int ihi, const float* a, lapack_int lda,
const float* tau, float* c, lapack_int ldc );
lapack_int LAPACKE_dormhr( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int ilo,
lapack_int ihi, const double* a, lapack_int lda,
const double* tau, double* c, lapack_int ldc );
lapack_int LAPACKE_sormlq( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const float* a, lapack_int lda, const float* tau,
float* c, lapack_int ldc );
lapack_int LAPACKE_dormlq( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const double* a, lapack_int lda, const double* tau,
double* c, lapack_int ldc );
lapack_int LAPACKE_sormql( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const float* a, lapack_int lda, const float* tau,
float* c, lapack_int ldc );
lapack_int LAPACKE_dormql( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const double* a, lapack_int lda, const double* tau,
double* c, lapack_int ldc );
lapack_int LAPACKE_sormqr( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const float* a, lapack_int lda, const float* tau,
float* c, lapack_int ldc );
lapack_int LAPACKE_dormqr( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const double* a, lapack_int lda, const double* tau,
double* c, lapack_int ldc );
lapack_int LAPACKE_sormrq( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const float* a, lapack_int lda, const float* tau,
float* c, lapack_int ldc );
lapack_int LAPACKE_dormrq( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const double* a, lapack_int lda, const double* tau,
double* c, lapack_int ldc );
lapack_int LAPACKE_sormrz( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int l, const float* a, lapack_int lda,
const float* tau, float* c, lapack_int ldc );
lapack_int LAPACKE_dormrz( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int l, const double* a, lapack_int lda,
const double* tau, double* c, lapack_int ldc );
lapack_int LAPACKE_sormtr( int matrix_order, char side, char uplo, char trans,
lapack_int m, lapack_int n, const float* a,
lapack_int lda, const float* tau, float* c,
lapack_int ldc );
lapack_int LAPACKE_dormtr( int matrix_order, char side, char uplo, char trans,
lapack_int m, lapack_int n, const double* a,
lapack_int lda, const double* tau, double* c,
lapack_int ldc );
lapack_int LAPACKE_spbcon( int matrix_order, char uplo, lapack_int n,
lapack_int kd, const float* ab, lapack_int ldab,
float anorm, float* rcond );
lapack_int LAPACKE_dpbcon( int matrix_order, char uplo, lapack_int n,
lapack_int kd, const double* ab, lapack_int ldab,
double anorm, double* rcond );
lapack_int LAPACKE_cpbcon( int matrix_order, char uplo, lapack_int n,
lapack_int kd, const lapack_complex_float* ab,
lapack_int ldab, float anorm, float* rcond );
lapack_int LAPACKE_zpbcon( int matrix_order, char uplo, lapack_int n,
lapack_int kd, const lapack_complex_double* ab,
lapack_int ldab, double anorm, double* rcond );
lapack_int LAPACKE_spbequ( int matrix_order, char uplo, lapack_int n,
lapack_int kd, const float* ab, lapack_int ldab,
float* s, float* scond, float* amax );
lapack_int LAPACKE_dpbequ( int matrix_order, char uplo, lapack_int n,
lapack_int kd, const double* ab, lapack_int ldab,
double* s, double* scond, double* amax );
lapack_int LAPACKE_cpbequ( int matrix_order, char uplo, lapack_int n,
lapack_int kd, const lapack_complex_float* ab,
lapack_int ldab, float* s, float* scond,
float* amax );
lapack_int LAPACKE_zpbequ( int matrix_order, char uplo, lapack_int n,
lapack_int kd, const lapack_complex_double* ab,
lapack_int ldab, double* s, double* scond,
double* amax );
lapack_int LAPACKE_spbrfs( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs, const float* ab,
lapack_int ldab, const float* afb, lapack_int ldafb,
const float* b, lapack_int ldb, float* x,
lapack_int ldx, float* ferr, float* berr );
lapack_int LAPACKE_dpbrfs( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs, const double* ab,
lapack_int ldab, const double* afb, lapack_int ldafb,
const double* b, lapack_int ldb, double* x,
lapack_int ldx, double* ferr, double* berr );
lapack_int LAPACKE_cpbrfs( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs,
const lapack_complex_float* ab, lapack_int ldab,
const lapack_complex_float* afb, lapack_int ldafb,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx, float* ferr,
float* berr );
lapack_int LAPACKE_zpbrfs( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs,
const lapack_complex_double* ab, lapack_int ldab,
const lapack_complex_double* afb, lapack_int ldafb,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr );
lapack_int LAPACKE_spbstf( int matrix_order, char uplo, lapack_int n,
lapack_int kb, float* bb, lapack_int ldbb );
lapack_int LAPACKE_dpbstf( int matrix_order, char uplo, lapack_int n,
lapack_int kb, double* bb, lapack_int ldbb );
lapack_int LAPACKE_cpbstf( int matrix_order, char uplo, lapack_int n,
lapack_int kb, lapack_complex_float* bb,
lapack_int ldbb );
lapack_int LAPACKE_zpbstf( int matrix_order, char uplo, lapack_int n,
lapack_int kb, lapack_complex_double* bb,
lapack_int ldbb );
lapack_int LAPACKE_spbsv( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs, float* ab,
lapack_int ldab, float* b, lapack_int ldb );
lapack_int LAPACKE_dpbsv( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs, double* ab,
lapack_int ldab, double* b, lapack_int ldb );
lapack_int LAPACKE_cpbsv( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs,
lapack_complex_float* ab, lapack_int ldab,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zpbsv( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs,
lapack_complex_double* ab, lapack_int ldab,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_spbsvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs, float* ab,
lapack_int ldab, float* afb, lapack_int ldafb,
char* equed, float* s, float* b, lapack_int ldb,
float* x, lapack_int ldx, float* rcond, float* ferr,
float* berr );
lapack_int LAPACKE_dpbsvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs, double* ab,
lapack_int ldab, double* afb, lapack_int ldafb,
char* equed, double* s, double* b, lapack_int ldb,
double* x, lapack_int ldx, double* rcond,
double* ferr, double* berr );
lapack_int LAPACKE_cpbsvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs,
lapack_complex_float* ab, lapack_int ldab,
lapack_complex_float* afb, lapack_int ldafb,
char* equed, float* s, lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* x,
lapack_int ldx, float* rcond, float* ferr,
float* berr );
lapack_int LAPACKE_zpbsvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs,
lapack_complex_double* ab, lapack_int ldab,
lapack_complex_double* afb, lapack_int ldafb,
char* equed, double* s, lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* x,
lapack_int ldx, double* rcond, double* ferr,
double* berr );
lapack_int LAPACKE_spbtrf( int matrix_order, char uplo, lapack_int n,
lapack_int kd, float* ab, lapack_int ldab );
lapack_int LAPACKE_dpbtrf( int matrix_order, char uplo, lapack_int n,
lapack_int kd, double* ab, lapack_int ldab );
lapack_int LAPACKE_cpbtrf( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_complex_float* ab,
lapack_int ldab );
lapack_int LAPACKE_zpbtrf( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_complex_double* ab,
lapack_int ldab );
lapack_int LAPACKE_spbtrs( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs, const float* ab,
lapack_int ldab, float* b, lapack_int ldb );
lapack_int LAPACKE_dpbtrs( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs, const double* ab,
lapack_int ldab, double* b, lapack_int ldb );
lapack_int LAPACKE_cpbtrs( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs,
const lapack_complex_float* ab, lapack_int ldab,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zpbtrs( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs,
const lapack_complex_double* ab, lapack_int ldab,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_spftrf( int matrix_order, char transr, char uplo,
lapack_int n, float* a );
lapack_int LAPACKE_dpftrf( int matrix_order, char transr, char uplo,
lapack_int n, double* a );
lapack_int LAPACKE_cpftrf( int matrix_order, char transr, char uplo,
lapack_int n, lapack_complex_float* a );
lapack_int LAPACKE_zpftrf( int matrix_order, char transr, char uplo,
lapack_int n, lapack_complex_double* a );
lapack_int LAPACKE_spftri( int matrix_order, char transr, char uplo,
lapack_int n, float* a );
lapack_int LAPACKE_dpftri( int matrix_order, char transr, char uplo,
lapack_int n, double* a );
lapack_int LAPACKE_cpftri( int matrix_order, char transr, char uplo,
lapack_int n, lapack_complex_float* a );
lapack_int LAPACKE_zpftri( int matrix_order, char transr, char uplo,
lapack_int n, lapack_complex_double* a );
lapack_int LAPACKE_spftrs( int matrix_order, char transr, char uplo,
lapack_int n, lapack_int nrhs, const float* a,
float* b, lapack_int ldb );
lapack_int LAPACKE_dpftrs( int matrix_order, char transr, char uplo,
lapack_int n, lapack_int nrhs, const double* a,
double* b, lapack_int ldb );
lapack_int LAPACKE_cpftrs( int matrix_order, char transr, char uplo,
lapack_int n, lapack_int nrhs,
const lapack_complex_float* a,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zpftrs( int matrix_order, char transr, char uplo,
lapack_int n, lapack_int nrhs,
const lapack_complex_double* a,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_spocon( int matrix_order, char uplo, lapack_int n,
const float* a, lapack_int lda, float anorm,
float* rcond );
lapack_int LAPACKE_dpocon( int matrix_order, char uplo, lapack_int n,
const double* a, lapack_int lda, double anorm,
double* rcond );
lapack_int LAPACKE_cpocon( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
float anorm, float* rcond );
lapack_int LAPACKE_zpocon( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
double anorm, double* rcond );
lapack_int LAPACKE_spoequ( int matrix_order, lapack_int n, const float* a,
lapack_int lda, float* s, float* scond,
float* amax );
lapack_int LAPACKE_dpoequ( int matrix_order, lapack_int n, const double* a,
lapack_int lda, double* s, double* scond,
double* amax );
lapack_int LAPACKE_cpoequ( int matrix_order, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
float* s, float* scond, float* amax );
lapack_int LAPACKE_zpoequ( int matrix_order, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
double* s, double* scond, double* amax );
lapack_int LAPACKE_spoequb( int matrix_order, lapack_int n, const float* a,
lapack_int lda, float* s, float* scond,
float* amax );
lapack_int LAPACKE_dpoequb( int matrix_order, lapack_int n, const double* a,
lapack_int lda, double* s, double* scond,
double* amax );
lapack_int LAPACKE_cpoequb( int matrix_order, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
float* s, float* scond, float* amax );
lapack_int LAPACKE_zpoequb( int matrix_order, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
double* s, double* scond, double* amax );
lapack_int LAPACKE_sporfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* a, lapack_int lda,
const float* af, lapack_int ldaf, const float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* ferr, float* berr );
lapack_int LAPACKE_dporfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* a, lapack_int lda,
const double* af, lapack_int ldaf, const double* b,
lapack_int ldb, double* x, lapack_int ldx,
double* ferr, double* berr );
lapack_int LAPACKE_cporfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* af,
lapack_int ldaf, const lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* x,
lapack_int ldx, float* ferr, float* berr );
lapack_int LAPACKE_zporfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, const lapack_complex_double* af,
lapack_int ldaf, const lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* x,
lapack_int ldx, double* ferr, double* berr );
lapack_int LAPACKE_sporfsx( int matrix_order, char uplo, char equed,
lapack_int n, lapack_int nrhs, const float* a,
lapack_int lda, const float* af, lapack_int ldaf,
const float* s, const float* b, lapack_int ldb,
float* x, lapack_int ldx, float* rcond, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params );
lapack_int LAPACKE_dporfsx( int matrix_order, char uplo, char equed,
lapack_int n, lapack_int nrhs, const double* a,
lapack_int lda, const double* af, lapack_int ldaf,
const double* s, const double* b, lapack_int ldb,
double* x, lapack_int ldx, double* rcond,
double* berr, lapack_int n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int nparams, double* params );
lapack_int LAPACKE_cporfsx( int matrix_order, char uplo, char equed,
lapack_int n, lapack_int nrhs,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* af, lapack_int ldaf,
const float* s, const lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* x,
lapack_int ldx, float* rcond, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params );
lapack_int LAPACKE_zporfsx( int matrix_order, char uplo, char equed,
lapack_int n, lapack_int nrhs,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* af, lapack_int ldaf,
const double* s, const lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* x,
lapack_int ldx, double* rcond, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params );
lapack_int LAPACKE_sposv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, float* a, lapack_int lda, float* b,
lapack_int ldb );
lapack_int LAPACKE_dposv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, double* a, lapack_int lda, double* b,
lapack_int ldb );
lapack_int LAPACKE_cposv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zposv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_dsposv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, double* a, lapack_int lda,
double* b, lapack_int ldb, double* x, lapack_int ldx,
lapack_int* iter );
lapack_int LAPACKE_zcposv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* x,
lapack_int ldx, lapack_int* iter );
lapack_int LAPACKE_sposvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int nrhs, float* a, lapack_int lda, float* af,
lapack_int ldaf, char* equed, float* s, float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* rcond, float* ferr, float* berr );
lapack_int LAPACKE_dposvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int nrhs, double* a, lapack_int lda,
double* af, lapack_int ldaf, char* equed, double* s,
double* b, lapack_int ldb, double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr );
lapack_int LAPACKE_cposvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* af,
lapack_int ldaf, char* equed, float* s,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* ferr, float* berr );
lapack_int LAPACKE_zposvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* af,
lapack_int ldaf, char* equed, double* s,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr );
lapack_int LAPACKE_sposvxx( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs, float* a,
lapack_int lda, float* af, lapack_int ldaf,
char* equed, float* s, float* b, lapack_int ldb,
float* x, lapack_int ldx, float* rcond,
float* rpvgrw, float* berr, lapack_int n_err_bnds,
float* err_bnds_norm, float* err_bnds_comp,
lapack_int nparams, float* params );
lapack_int LAPACKE_dposvxx( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs, double* a,
lapack_int lda, double* af, lapack_int ldaf,
char* equed, double* s, double* b, lapack_int ldb,
double* x, lapack_int ldx, double* rcond,
double* rpvgrw, double* berr, lapack_int n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int nparams, double* params );
lapack_int LAPACKE_cposvxx( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* af, lapack_int ldaf,
char* equed, float* s, lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* x,
lapack_int ldx, float* rcond, float* rpvgrw,
float* berr, lapack_int n_err_bnds,
float* err_bnds_norm, float* err_bnds_comp,
lapack_int nparams, float* params );
lapack_int LAPACKE_zposvxx( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* af, lapack_int ldaf,
char* equed, double* s, lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* x,
lapack_int ldx, double* rcond, double* rpvgrw,
double* berr, lapack_int n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int nparams, double* params );
lapack_int LAPACKE_spotrf( int matrix_order, char uplo, lapack_int n, float* a,
lapack_int lda );
lapack_int LAPACKE_dpotrf( int matrix_order, char uplo, lapack_int n, double* a,
lapack_int lda );
lapack_int LAPACKE_cpotrf( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda );
lapack_int LAPACKE_zpotrf( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda );
lapack_int LAPACKE_spotri( int matrix_order, char uplo, lapack_int n, float* a,
lapack_int lda );
lapack_int LAPACKE_dpotri( int matrix_order, char uplo, lapack_int n, double* a,
lapack_int lda );
lapack_int LAPACKE_cpotri( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda );
lapack_int LAPACKE_zpotri( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda );
lapack_int LAPACKE_spotrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* a, lapack_int lda,
float* b, lapack_int ldb );
lapack_int LAPACKE_dpotrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* a, lapack_int lda,
double* b, lapack_int ldb );
lapack_int LAPACKE_cpotrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zpotrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_sppcon( int matrix_order, char uplo, lapack_int n,
const float* ap, float anorm, float* rcond );
lapack_int LAPACKE_dppcon( int matrix_order, char uplo, lapack_int n,
const double* ap, double anorm, double* rcond );
lapack_int LAPACKE_cppcon( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* ap, float anorm,
float* rcond );
lapack_int LAPACKE_zppcon( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* ap, double anorm,
double* rcond );
lapack_int LAPACKE_sppequ( int matrix_order, char uplo, lapack_int n,
const float* ap, float* s, float* scond,
float* amax );
lapack_int LAPACKE_dppequ( int matrix_order, char uplo, lapack_int n,
const double* ap, double* s, double* scond,
double* amax );
lapack_int LAPACKE_cppequ( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* ap, float* s,
float* scond, float* amax );
lapack_int LAPACKE_zppequ( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* ap, double* s,
double* scond, double* amax );
lapack_int LAPACKE_spprfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* ap, const float* afp,
const float* b, lapack_int ldb, float* x,
lapack_int ldx, float* ferr, float* berr );
lapack_int LAPACKE_dpprfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* ap, const double* afp,
const double* b, lapack_int ldb, double* x,
lapack_int ldx, double* ferr, double* berr );
lapack_int LAPACKE_cpprfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* ap,
const lapack_complex_float* afp,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx, float* ferr,
float* berr );
lapack_int LAPACKE_zpprfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* ap,
const lapack_complex_double* afp,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr );
lapack_int LAPACKE_sppsv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, float* ap, float* b,
lapack_int ldb );
lapack_int LAPACKE_dppsv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, double* ap, double* b,
lapack_int ldb );
lapack_int LAPACKE_cppsv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_float* ap,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zppsv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_double* ap,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_sppsvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int nrhs, float* ap, float* afp, char* equed,
float* s, float* b, lapack_int ldb, float* x,
lapack_int ldx, float* rcond, float* ferr,
float* berr );
lapack_int LAPACKE_dppsvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int nrhs, double* ap, double* afp,
char* equed, double* s, double* b, lapack_int ldb,
double* x, lapack_int ldx, double* rcond,
double* ferr, double* berr );
lapack_int LAPACKE_cppsvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_float* ap,
lapack_complex_float* afp, char* equed, float* s,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* ferr, float* berr );
lapack_int LAPACKE_zppsvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_double* ap,
lapack_complex_double* afp, char* equed, double* s,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr );
lapack_int LAPACKE_spptrf( int matrix_order, char uplo, lapack_int n,
float* ap );
lapack_int LAPACKE_dpptrf( int matrix_order, char uplo, lapack_int n,
double* ap );
lapack_int LAPACKE_cpptrf( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* ap );
lapack_int LAPACKE_zpptrf( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* ap );
lapack_int LAPACKE_spptri( int matrix_order, char uplo, lapack_int n,
float* ap );
lapack_int LAPACKE_dpptri( int matrix_order, char uplo, lapack_int n,
double* ap );
lapack_int LAPACKE_cpptri( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* ap );
lapack_int LAPACKE_zpptri( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* ap );
lapack_int LAPACKE_spptrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* ap, float* b,
lapack_int ldb );
lapack_int LAPACKE_dpptrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* ap, double* b,
lapack_int ldb );
lapack_int LAPACKE_cpptrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* ap,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zpptrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* ap,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_spstrf( int matrix_order, char uplo, lapack_int n, float* a,
lapack_int lda, lapack_int* piv, lapack_int* rank,
float tol );
lapack_int LAPACKE_dpstrf( int matrix_order, char uplo, lapack_int n, double* a,
lapack_int lda, lapack_int* piv, lapack_int* rank,
double tol );
lapack_int LAPACKE_cpstrf( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_int* piv, lapack_int* rank, float tol );
lapack_int LAPACKE_zpstrf( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_int* piv, lapack_int* rank, double tol );
lapack_int LAPACKE_sptcon( lapack_int n, const float* d, const float* e,
float anorm, float* rcond );
lapack_int LAPACKE_dptcon( lapack_int n, const double* d, const double* e,
double anorm, double* rcond );
lapack_int LAPACKE_cptcon( lapack_int n, const float* d,
const lapack_complex_float* e, float anorm,
float* rcond );
lapack_int LAPACKE_zptcon( lapack_int n, const double* d,
const lapack_complex_double* e, double anorm,
double* rcond );
lapack_int LAPACKE_spteqr( int matrix_order, char compz, lapack_int n, float* d,
float* e, float* z, lapack_int ldz );
lapack_int LAPACKE_dpteqr( int matrix_order, char compz, lapack_int n,
double* d, double* e, double* z, lapack_int ldz );
lapack_int LAPACKE_cpteqr( int matrix_order, char compz, lapack_int n, float* d,
float* e, lapack_complex_float* z, lapack_int ldz );
lapack_int LAPACKE_zpteqr( int matrix_order, char compz, lapack_int n,
double* d, double* e, lapack_complex_double* z,
lapack_int ldz );
lapack_int LAPACKE_sptrfs( int matrix_order, lapack_int n, lapack_int nrhs,
const float* d, const float* e, const float* df,
const float* ef, const float* b, lapack_int ldb,
float* x, lapack_int ldx, float* ferr, float* berr );
lapack_int LAPACKE_dptrfs( int matrix_order, lapack_int n, lapack_int nrhs,
const double* d, const double* e, const double* df,
const double* ef, const double* b, lapack_int ldb,
double* x, lapack_int ldx, double* ferr,
double* berr );
lapack_int LAPACKE_cptrfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* d,
const lapack_complex_float* e, const float* df,
const lapack_complex_float* ef,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx, float* ferr,
float* berr );
lapack_int LAPACKE_zptrfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* d,
const lapack_complex_double* e, const double* df,
const lapack_complex_double* ef,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr );
lapack_int LAPACKE_sptsv( int matrix_order, lapack_int n, lapack_int nrhs,
float* d, float* e, float* b, lapack_int ldb );
lapack_int LAPACKE_dptsv( int matrix_order, lapack_int n, lapack_int nrhs,
double* d, double* e, double* b, lapack_int ldb );
lapack_int LAPACKE_cptsv( int matrix_order, lapack_int n, lapack_int nrhs,
float* d, lapack_complex_float* e,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zptsv( int matrix_order, lapack_int n, lapack_int nrhs,
double* d, lapack_complex_double* e,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_sptsvx( int matrix_order, char fact, lapack_int n,
lapack_int nrhs, const float* d, const float* e,
float* df, float* ef, const float* b, lapack_int ldb,
float* x, lapack_int ldx, float* rcond, float* ferr,
float* berr );
lapack_int LAPACKE_dptsvx( int matrix_order, char fact, lapack_int n,
lapack_int nrhs, const double* d, const double* e,
double* df, double* ef, const double* b,
lapack_int ldb, double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr );
lapack_int LAPACKE_cptsvx( int matrix_order, char fact, lapack_int n,
lapack_int nrhs, const float* d,
const lapack_complex_float* e, float* df,
lapack_complex_float* ef,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* ferr, float* berr );
lapack_int LAPACKE_zptsvx( int matrix_order, char fact, lapack_int n,
lapack_int nrhs, const double* d,
const lapack_complex_double* e, double* df,
lapack_complex_double* ef,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr );
lapack_int LAPACKE_spttrf( lapack_int n, float* d, float* e );
lapack_int LAPACKE_dpttrf( lapack_int n, double* d, double* e );
lapack_int LAPACKE_cpttrf( lapack_int n, float* d, lapack_complex_float* e );
lapack_int LAPACKE_zpttrf( lapack_int n, double* d, lapack_complex_double* e );
lapack_int LAPACKE_spttrs( int matrix_order, lapack_int n, lapack_int nrhs,
const float* d, const float* e, float* b,
lapack_int ldb );
lapack_int LAPACKE_dpttrs( int matrix_order, lapack_int n, lapack_int nrhs,
const double* d, const double* e, double* b,
lapack_int ldb );
lapack_int LAPACKE_cpttrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* d,
const lapack_complex_float* e,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zpttrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* d,
const lapack_complex_double* e,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_ssbev( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_int kd, float* ab, lapack_int ldab, float* w,
float* z, lapack_int ldz );
lapack_int LAPACKE_dsbev( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_int kd, double* ab, lapack_int ldab, double* w,
double* z, lapack_int ldz );
lapack_int LAPACKE_ssbevd( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_int kd, float* ab, lapack_int ldab, float* w,
float* z, lapack_int ldz );
lapack_int LAPACKE_dsbevd( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_int kd, double* ab, lapack_int ldab,
double* w, double* z, lapack_int ldz );
lapack_int LAPACKE_ssbevx( int matrix_order, char jobz, char range, char uplo,
lapack_int n, lapack_int kd, float* ab,
lapack_int ldab, float* q, lapack_int ldq, float vl,
float vu, lapack_int il, lapack_int iu, float abstol,
lapack_int* m, float* w, float* z, lapack_int ldz,
lapack_int* ifail );
lapack_int LAPACKE_dsbevx( int matrix_order, char jobz, char range, char uplo,
lapack_int n, lapack_int kd, double* ab,
lapack_int ldab, double* q, lapack_int ldq,
double vl, double vu, lapack_int il, lapack_int iu,
double abstol, lapack_int* m, double* w, double* z,
lapack_int ldz, lapack_int* ifail );
lapack_int LAPACKE_ssbgst( int matrix_order, char vect, char uplo, lapack_int n,
lapack_int ka, lapack_int kb, float* ab,
lapack_int ldab, const float* bb, lapack_int ldbb,
float* x, lapack_int ldx );
lapack_int LAPACKE_dsbgst( int matrix_order, char vect, char uplo, lapack_int n,
lapack_int ka, lapack_int kb, double* ab,
lapack_int ldab, const double* bb, lapack_int ldbb,
double* x, lapack_int ldx );
lapack_int LAPACKE_ssbgv( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_int ka, lapack_int kb, float* ab,
lapack_int ldab, float* bb, lapack_int ldbb, float* w,
float* z, lapack_int ldz );
lapack_int LAPACKE_dsbgv( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_int ka, lapack_int kb, double* ab,
lapack_int ldab, double* bb, lapack_int ldbb,
double* w, double* z, lapack_int ldz );
lapack_int LAPACKE_ssbgvd( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_int ka, lapack_int kb, float* ab,
lapack_int ldab, float* bb, lapack_int ldbb,
float* w, float* z, lapack_int ldz );
lapack_int LAPACKE_dsbgvd( int matrix_order, char jobz, char uplo, lapack_int n,
lapack_int ka, lapack_int kb, double* ab,
lapack_int ldab, double* bb, lapack_int ldbb,
double* w, double* z, lapack_int ldz );
lapack_int LAPACKE_ssbgvx( int matrix_order, char jobz, char range, char uplo,
lapack_int n, lapack_int ka, lapack_int kb,
float* ab, lapack_int ldab, float* bb,
lapack_int ldbb, float* q, lapack_int ldq, float vl,
float vu, lapack_int il, lapack_int iu, float abstol,
lapack_int* m, float* w, float* z, lapack_int ldz,
lapack_int* ifail );
lapack_int LAPACKE_dsbgvx( int matrix_order, char jobz, char range, char uplo,
lapack_int n, lapack_int ka, lapack_int kb,
double* ab, lapack_int ldab, double* bb,
lapack_int ldbb, double* q, lapack_int ldq,
double vl, double vu, lapack_int il, lapack_int iu,
double abstol, lapack_int* m, double* w, double* z,
lapack_int ldz, lapack_int* ifail );
lapack_int LAPACKE_ssbtrd( int matrix_order, char vect, char uplo, lapack_int n,
lapack_int kd, float* ab, lapack_int ldab, float* d,
float* e, float* q, lapack_int ldq );
lapack_int LAPACKE_dsbtrd( int matrix_order, char vect, char uplo, lapack_int n,
lapack_int kd, double* ab, lapack_int ldab,
double* d, double* e, double* q, lapack_int ldq );
lapack_int LAPACKE_ssfrk( int matrix_order, char transr, char uplo, char trans,
lapack_int n, lapack_int k, float alpha,
const float* a, lapack_int lda, float beta,
float* c );
lapack_int LAPACKE_dsfrk( int matrix_order, char transr, char uplo, char trans,
lapack_int n, lapack_int k, double alpha,
const double* a, lapack_int lda, double beta,
double* c );
lapack_int LAPACKE_sspcon( int matrix_order, char uplo, lapack_int n,
const float* ap, const lapack_int* ipiv, float anorm,
float* rcond );
lapack_int LAPACKE_dspcon( int matrix_order, char uplo, lapack_int n,
const double* ap, const lapack_int* ipiv,
double anorm, double* rcond );
lapack_int LAPACKE_cspcon( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* ap,
const lapack_int* ipiv, float anorm, float* rcond );
lapack_int LAPACKE_zspcon( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* ap,
const lapack_int* ipiv, double anorm,
double* rcond );
lapack_int LAPACKE_sspev( int matrix_order, char jobz, char uplo, lapack_int n,
float* ap, float* w, float* z, lapack_int ldz );
lapack_int LAPACKE_dspev( int matrix_order, char jobz, char uplo, lapack_int n,
double* ap, double* w, double* z, lapack_int ldz );
lapack_int LAPACKE_sspevd( int matrix_order, char jobz, char uplo, lapack_int n,
float* ap, float* w, float* z, lapack_int ldz );
lapack_int LAPACKE_dspevd( int matrix_order, char jobz, char uplo, lapack_int n,
double* ap, double* w, double* z, lapack_int ldz );
lapack_int LAPACKE_sspevx( int matrix_order, char jobz, char range, char uplo,
lapack_int n, float* ap, float vl, float vu,
lapack_int il, lapack_int iu, float abstol,
lapack_int* m, float* w, float* z, lapack_int ldz,
lapack_int* ifail );
lapack_int LAPACKE_dspevx( int matrix_order, char jobz, char range, char uplo,
lapack_int n, double* ap, double vl, double vu,
lapack_int il, lapack_int iu, double abstol,
lapack_int* m, double* w, double* z, lapack_int ldz,
lapack_int* ifail );
lapack_int LAPACKE_sspgst( int matrix_order, lapack_int itype, char uplo,
lapack_int n, float* ap, const float* bp );
lapack_int LAPACKE_dspgst( int matrix_order, lapack_int itype, char uplo,
lapack_int n, double* ap, const double* bp );
lapack_int LAPACKE_sspgv( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, float* ap, float* bp,
float* w, float* z, lapack_int ldz );
lapack_int LAPACKE_dspgv( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, double* ap, double* bp,
double* w, double* z, lapack_int ldz );
lapack_int LAPACKE_sspgvd( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, float* ap, float* bp,
float* w, float* z, lapack_int ldz );
lapack_int LAPACKE_dspgvd( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, double* ap, double* bp,
double* w, double* z, lapack_int ldz );
lapack_int LAPACKE_sspgvx( int matrix_order, lapack_int itype, char jobz,
char range, char uplo, lapack_int n, float* ap,
float* bp, float vl, float vu, lapack_int il,
lapack_int iu, float abstol, lapack_int* m, float* w,
float* z, lapack_int ldz, lapack_int* ifail );
lapack_int LAPACKE_dspgvx( int matrix_order, lapack_int itype, char jobz,
char range, char uplo, lapack_int n, double* ap,
double* bp, double vl, double vu, lapack_int il,
lapack_int iu, double abstol, lapack_int* m,
double* w, double* z, lapack_int ldz,
lapack_int* ifail );
lapack_int LAPACKE_ssprfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* ap, const float* afp,
const lapack_int* ipiv, const float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* ferr, float* berr );
lapack_int LAPACKE_dsprfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* ap, const double* afp,
const lapack_int* ipiv, const double* b,
lapack_int ldb, double* x, lapack_int ldx,
double* ferr, double* berr );
lapack_int LAPACKE_csprfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* ap,
const lapack_complex_float* afp,
const lapack_int* ipiv,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx, float* ferr,
float* berr );
lapack_int LAPACKE_zsprfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* ap,
const lapack_complex_double* afp,
const lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr );
lapack_int LAPACKE_sspsv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, float* ap, lapack_int* ipiv,
float* b, lapack_int ldb );
lapack_int LAPACKE_dspsv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, double* ap, lapack_int* ipiv,
double* b, lapack_int ldb );
lapack_int LAPACKE_cspsv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_float* ap,
lapack_int* ipiv, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zspsv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_double* ap,
lapack_int* ipiv, lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_sspsvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int nrhs, const float* ap, float* afp,
lapack_int* ipiv, const float* b, lapack_int ldb,
float* x, lapack_int ldx, float* rcond, float* ferr,
float* berr );
lapack_int LAPACKE_dspsvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int nrhs, const double* ap, double* afp,
lapack_int* ipiv, const double* b, lapack_int ldb,
double* x, lapack_int ldx, double* rcond,
double* ferr, double* berr );
lapack_int LAPACKE_cspsvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* ap,
lapack_complex_float* afp, lapack_int* ipiv,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* ferr, float* berr );
lapack_int LAPACKE_zspsvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* ap,
lapack_complex_double* afp, lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr );
lapack_int LAPACKE_ssptrd( int matrix_order, char uplo, lapack_int n, float* ap,
float* d, float* e, float* tau );
lapack_int LAPACKE_dsptrd( int matrix_order, char uplo, lapack_int n,
double* ap, double* d, double* e, double* tau );
lapack_int LAPACKE_ssptrf( int matrix_order, char uplo, lapack_int n, float* ap,
lapack_int* ipiv );
lapack_int LAPACKE_dsptrf( int matrix_order, char uplo, lapack_int n,
double* ap, lapack_int* ipiv );
lapack_int LAPACKE_csptrf( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* ap, lapack_int* ipiv );
lapack_int LAPACKE_zsptrf( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* ap, lapack_int* ipiv );
lapack_int LAPACKE_ssptri( int matrix_order, char uplo, lapack_int n, float* ap,
const lapack_int* ipiv );
lapack_int LAPACKE_dsptri( int matrix_order, char uplo, lapack_int n,
double* ap, const lapack_int* ipiv );
lapack_int LAPACKE_csptri( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* ap, const lapack_int* ipiv );
lapack_int LAPACKE_zsptri( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* ap, const lapack_int* ipiv );
lapack_int LAPACKE_ssptrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* ap,
const lapack_int* ipiv, float* b, lapack_int ldb );
lapack_int LAPACKE_dsptrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* ap,
const lapack_int* ipiv, double* b, lapack_int ldb );
lapack_int LAPACKE_csptrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* ap,
const lapack_int* ipiv, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zsptrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* ap,
const lapack_int* ipiv, lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_sstebz( char range, char order, lapack_int n, float vl,
float vu, lapack_int il, lapack_int iu, float abstol,
const float* d, const float* e, lapack_int* m,
lapack_int* nsplit, float* w, lapack_int* iblock,
lapack_int* isplit );
lapack_int LAPACKE_dstebz( char range, char order, lapack_int n, double vl,
double vu, lapack_int il, lapack_int iu,
double abstol, const double* d, const double* e,
lapack_int* m, lapack_int* nsplit, double* w,
lapack_int* iblock, lapack_int* isplit );
lapack_int LAPACKE_sstedc( int matrix_order, char compz, lapack_int n, float* d,
float* e, float* z, lapack_int ldz );
lapack_int LAPACKE_dstedc( int matrix_order, char compz, lapack_int n,
double* d, double* e, double* z, lapack_int ldz );
lapack_int LAPACKE_cstedc( int matrix_order, char compz, lapack_int n, float* d,
float* e, lapack_complex_float* z, lapack_int ldz );
lapack_int LAPACKE_zstedc( int matrix_order, char compz, lapack_int n,
double* d, double* e, lapack_complex_double* z,
lapack_int ldz );
lapack_int LAPACKE_sstegr( int matrix_order, char jobz, char range,
lapack_int n, float* d, float* e, float vl, float vu,
lapack_int il, lapack_int iu, float abstol,
lapack_int* m, float* w, float* z, lapack_int ldz,
lapack_int* isuppz );
lapack_int LAPACKE_dstegr( int matrix_order, char jobz, char range,
lapack_int n, double* d, double* e, double vl,
double vu, lapack_int il, lapack_int iu,
double abstol, lapack_int* m, double* w, double* z,
lapack_int ldz, lapack_int* isuppz );
lapack_int LAPACKE_cstegr( int matrix_order, char jobz, char range,
lapack_int n, float* d, float* e, float vl, float vu,
lapack_int il, lapack_int iu, float abstol,
lapack_int* m, float* w, lapack_complex_float* z,
lapack_int ldz, lapack_int* isuppz );
lapack_int LAPACKE_zstegr( int matrix_order, char jobz, char range,
lapack_int n, double* d, double* e, double vl,
double vu, lapack_int il, lapack_int iu,
double abstol, lapack_int* m, double* w,
lapack_complex_double* z, lapack_int ldz,
lapack_int* isuppz );
lapack_int LAPACKE_sstein( int matrix_order, lapack_int n, const float* d,
const float* e, lapack_int m, const float* w,
const lapack_int* iblock, const lapack_int* isplit,
float* z, lapack_int ldz, lapack_int* ifailv );
lapack_int LAPACKE_dstein( int matrix_order, lapack_int n, const double* d,
const double* e, lapack_int m, const double* w,
const lapack_int* iblock, const lapack_int* isplit,
double* z, lapack_int ldz, lapack_int* ifailv );
lapack_int LAPACKE_cstein( int matrix_order, lapack_int n, const float* d,
const float* e, lapack_int m, const float* w,
const lapack_int* iblock, const lapack_int* isplit,
lapack_complex_float* z, lapack_int ldz,
lapack_int* ifailv );
lapack_int LAPACKE_zstein( int matrix_order, lapack_int n, const double* d,
const double* e, lapack_int m, const double* w,
const lapack_int* iblock, const lapack_int* isplit,
lapack_complex_double* z, lapack_int ldz,
lapack_int* ifailv );
lapack_int LAPACKE_sstemr( int matrix_order, char jobz, char range,
lapack_int n, float* d, float* e, float vl, float vu,
lapack_int il, lapack_int iu, lapack_int* m,
float* w, float* z, lapack_int ldz, lapack_int nzc,
lapack_int* isuppz, lapack_logical* tryrac );
lapack_int LAPACKE_dstemr( int matrix_order, char jobz, char range,
lapack_int n, double* d, double* e, double vl,
double vu, lapack_int il, lapack_int iu,
lapack_int* m, double* w, double* z, lapack_int ldz,
lapack_int nzc, lapack_int* isuppz,
lapack_logical* tryrac );
lapack_int LAPACKE_cstemr( int matrix_order, char jobz, char range,
lapack_int n, float* d, float* e, float vl, float vu,
lapack_int il, lapack_int iu, lapack_int* m,
float* w, lapack_complex_float* z, lapack_int ldz,
lapack_int nzc, lapack_int* isuppz,
lapack_logical* tryrac );
lapack_int LAPACKE_zstemr( int matrix_order, char jobz, char range,
lapack_int n, double* d, double* e, double vl,
double vu, lapack_int il, lapack_int iu,
lapack_int* m, double* w, lapack_complex_double* z,
lapack_int ldz, lapack_int nzc, lapack_int* isuppz,
lapack_logical* tryrac );
lapack_int LAPACKE_ssteqr( int matrix_order, char compz, lapack_int n, float* d,
float* e, float* z, lapack_int ldz );
lapack_int LAPACKE_dsteqr( int matrix_order, char compz, lapack_int n,
double* d, double* e, double* z, lapack_int ldz );
lapack_int LAPACKE_csteqr( int matrix_order, char compz, lapack_int n, float* d,
float* e, lapack_complex_float* z, lapack_int ldz );
lapack_int LAPACKE_zsteqr( int matrix_order, char compz, lapack_int n,
double* d, double* e, lapack_complex_double* z,
lapack_int ldz );
lapack_int LAPACKE_ssterf( lapack_int n, float* d, float* e );
lapack_int LAPACKE_dsterf( lapack_int n, double* d, double* e );
lapack_int LAPACKE_sstev( int matrix_order, char jobz, lapack_int n, float* d,
float* e, float* z, lapack_int ldz );
lapack_int LAPACKE_dstev( int matrix_order, char jobz, lapack_int n, double* d,
double* e, double* z, lapack_int ldz );
lapack_int LAPACKE_sstevd( int matrix_order, char jobz, lapack_int n, float* d,
float* e, float* z, lapack_int ldz );
lapack_int LAPACKE_dstevd( int matrix_order, char jobz, lapack_int n, double* d,
double* e, double* z, lapack_int ldz );
lapack_int LAPACKE_sstevr( int matrix_order, char jobz, char range,
lapack_int n, float* d, float* e, float vl, float vu,
lapack_int il, lapack_int iu, float abstol,
lapack_int* m, float* w, float* z, lapack_int ldz,
lapack_int* isuppz );
lapack_int LAPACKE_dstevr( int matrix_order, char jobz, char range,
lapack_int n, double* d, double* e, double vl,
double vu, lapack_int il, lapack_int iu,
double abstol, lapack_int* m, double* w, double* z,
lapack_int ldz, lapack_int* isuppz );
lapack_int LAPACKE_sstevx( int matrix_order, char jobz, char range,
lapack_int n, float* d, float* e, float vl, float vu,
lapack_int il, lapack_int iu, float abstol,
lapack_int* m, float* w, float* z, lapack_int ldz,
lapack_int* ifail );
lapack_int LAPACKE_dstevx( int matrix_order, char jobz, char range,
lapack_int n, double* d, double* e, double vl,
double vu, lapack_int il, lapack_int iu,
double abstol, lapack_int* m, double* w, double* z,
lapack_int ldz, lapack_int* ifail );
lapack_int LAPACKE_ssycon( int matrix_order, char uplo, lapack_int n,
const float* a, lapack_int lda,
const lapack_int* ipiv, float anorm, float* rcond );
lapack_int LAPACKE_dsycon( int matrix_order, char uplo, lapack_int n,
const double* a, lapack_int lda,
const lapack_int* ipiv, double anorm,
double* rcond );
lapack_int LAPACKE_csycon( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
const lapack_int* ipiv, float anorm, float* rcond );
lapack_int LAPACKE_zsycon( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
const lapack_int* ipiv, double anorm,
double* rcond );
lapack_int LAPACKE_ssyequb( int matrix_order, char uplo, lapack_int n,
const float* a, lapack_int lda, float* s,
float* scond, float* amax );
lapack_int LAPACKE_dsyequb( int matrix_order, char uplo, lapack_int n,
const double* a, lapack_int lda, double* s,
double* scond, double* amax );
lapack_int LAPACKE_csyequb( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
float* s, float* scond, float* amax );
lapack_int LAPACKE_zsyequb( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
double* s, double* scond, double* amax );
lapack_int LAPACKE_ssyev( int matrix_order, char jobz, char uplo, lapack_int n,
float* a, lapack_int lda, float* w );
lapack_int LAPACKE_dsyev( int matrix_order, char jobz, char uplo, lapack_int n,
double* a, lapack_int lda, double* w );
lapack_int LAPACKE_ssyevd( int matrix_order, char jobz, char uplo, lapack_int n,
float* a, lapack_int lda, float* w );
lapack_int LAPACKE_dsyevd( int matrix_order, char jobz, char uplo, lapack_int n,
double* a, lapack_int lda, double* w );
lapack_int LAPACKE_ssyevr( int matrix_order, char jobz, char range, char uplo,
lapack_int n, float* a, lapack_int lda, float vl,
float vu, lapack_int il, lapack_int iu, float abstol,
lapack_int* m, float* w, float* z, lapack_int ldz,
lapack_int* isuppz );
lapack_int LAPACKE_dsyevr( int matrix_order, char jobz, char range, char uplo,
lapack_int n, double* a, lapack_int lda, double vl,
double vu, lapack_int il, lapack_int iu,
double abstol, lapack_int* m, double* w, double* z,
lapack_int ldz, lapack_int* isuppz );
lapack_int LAPACKE_ssyevx( int matrix_order, char jobz, char range, char uplo,
lapack_int n, float* a, lapack_int lda, float vl,
float vu, lapack_int il, lapack_int iu, float abstol,
lapack_int* m, float* w, float* z, lapack_int ldz,
lapack_int* ifail );
lapack_int LAPACKE_dsyevx( int matrix_order, char jobz, char range, char uplo,
lapack_int n, double* a, lapack_int lda, double vl,
double vu, lapack_int il, lapack_int iu,
double abstol, lapack_int* m, double* w, double* z,
lapack_int ldz, lapack_int* ifail );
lapack_int LAPACKE_ssygst( int matrix_order, lapack_int itype, char uplo,
lapack_int n, float* a, lapack_int lda,
const float* b, lapack_int ldb );
lapack_int LAPACKE_dsygst( int matrix_order, lapack_int itype, char uplo,
lapack_int n, double* a, lapack_int lda,
const double* b, lapack_int ldb );
lapack_int LAPACKE_ssygv( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, float* a, lapack_int lda,
float* b, lapack_int ldb, float* w );
lapack_int LAPACKE_dsygv( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, double* a, lapack_int lda,
double* b, lapack_int ldb, double* w );
lapack_int LAPACKE_ssygvd( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, float* a, lapack_int lda,
float* b, lapack_int ldb, float* w );
lapack_int LAPACKE_dsygvd( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, double* a, lapack_int lda,
double* b, lapack_int ldb, double* w );
lapack_int LAPACKE_ssygvx( int matrix_order, lapack_int itype, char jobz,
char range, char uplo, lapack_int n, float* a,
lapack_int lda, float* b, lapack_int ldb, float vl,
float vu, lapack_int il, lapack_int iu, float abstol,
lapack_int* m, float* w, float* z, lapack_int ldz,
lapack_int* ifail );
lapack_int LAPACKE_dsygvx( int matrix_order, lapack_int itype, char jobz,
char range, char uplo, lapack_int n, double* a,
lapack_int lda, double* b, lapack_int ldb, double vl,
double vu, lapack_int il, lapack_int iu,
double abstol, lapack_int* m, double* w, double* z,
lapack_int ldz, lapack_int* ifail );
lapack_int LAPACKE_ssyrfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* a, lapack_int lda,
const float* af, lapack_int ldaf,
const lapack_int* ipiv, const float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* ferr, float* berr );
lapack_int LAPACKE_dsyrfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* a, lapack_int lda,
const double* af, lapack_int ldaf,
const lapack_int* ipiv, const double* b,
lapack_int ldb, double* x, lapack_int ldx,
double* ferr, double* berr );
lapack_int LAPACKE_csyrfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* af,
lapack_int ldaf, const lapack_int* ipiv,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx, float* ferr,
float* berr );
lapack_int LAPACKE_zsyrfs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, const lapack_complex_double* af,
lapack_int ldaf, const lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr );
lapack_int LAPACKE_ssyrfsx( int matrix_order, char uplo, char equed,
lapack_int n, lapack_int nrhs, const float* a,
lapack_int lda, const float* af, lapack_int ldaf,
const lapack_int* ipiv, const float* s,
const float* b, lapack_int ldb, float* x,
lapack_int ldx, float* rcond, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params );
lapack_int LAPACKE_dsyrfsx( int matrix_order, char uplo, char equed,
lapack_int n, lapack_int nrhs, const double* a,
lapack_int lda, const double* af, lapack_int ldaf,
const lapack_int* ipiv, const double* s,
const double* b, lapack_int ldb, double* x,
lapack_int ldx, double* rcond, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params );
lapack_int LAPACKE_csyrfsx( int matrix_order, char uplo, char equed,
lapack_int n, lapack_int nrhs,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* af, lapack_int ldaf,
const lapack_int* ipiv, const float* s,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* berr, lapack_int n_err_bnds,
float* err_bnds_norm, float* err_bnds_comp,
lapack_int nparams, float* params );
lapack_int LAPACKE_zsyrfsx( int matrix_order, char uplo, char equed,
lapack_int n, lapack_int nrhs,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* af, lapack_int ldaf,
const lapack_int* ipiv, const double* s,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* berr, lapack_int n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int nparams, double* params );
lapack_int LAPACKE_ssysv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, float* a, lapack_int lda,
lapack_int* ipiv, float* b, lapack_int ldb );
lapack_int LAPACKE_dsysv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, double* a, lapack_int lda,
lapack_int* ipiv, double* b, lapack_int ldb );
lapack_int LAPACKE_csysv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_float* a,
lapack_int lda, lapack_int* ipiv,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zsysv( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_double* a,
lapack_int lda, lapack_int* ipiv,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_ssysvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int nrhs, const float* a, lapack_int lda,
float* af, lapack_int ldaf, lapack_int* ipiv,
const float* b, lapack_int ldb, float* x,
lapack_int ldx, float* rcond, float* ferr,
float* berr );
lapack_int LAPACKE_dsysvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int nrhs, const double* a, lapack_int lda,
double* af, lapack_int ldaf, lapack_int* ipiv,
const double* b, lapack_int ldb, double* x,
lapack_int ldx, double* rcond, double* ferr,
double* berr );
lapack_int LAPACKE_csysvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, lapack_complex_float* af,
lapack_int ldaf, lapack_int* ipiv,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* ferr, float* berr );
lapack_int LAPACKE_zsysvx( int matrix_order, char fact, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, lapack_complex_double* af,
lapack_int ldaf, lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr );
lapack_int LAPACKE_ssysvxx( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs, float* a,
lapack_int lda, float* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, float* s, float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* rcond, float* rpvgrw, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params );
lapack_int LAPACKE_dsysvxx( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs, double* a,
lapack_int lda, double* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, double* s, double* b,
lapack_int ldb, double* x, lapack_int ldx,
double* rcond, double* rpvgrw, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params );
lapack_int LAPACKE_csysvxx( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, float* s,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* rpvgrw, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params );
lapack_int LAPACKE_zsysvxx( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, double* s,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* rpvgrw, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params );
lapack_int LAPACKE_ssytrd( int matrix_order, char uplo, lapack_int n, float* a,
lapack_int lda, float* d, float* e, float* tau );
lapack_int LAPACKE_dsytrd( int matrix_order, char uplo, lapack_int n, double* a,
lapack_int lda, double* d, double* e, double* tau );
lapack_int LAPACKE_ssytrf( int matrix_order, char uplo, lapack_int n, float* a,
lapack_int lda, lapack_int* ipiv );
lapack_int LAPACKE_dsytrf( int matrix_order, char uplo, lapack_int n, double* a,
lapack_int lda, lapack_int* ipiv );
lapack_int LAPACKE_csytrf( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_int* ipiv );
lapack_int LAPACKE_zsytrf( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_int* ipiv );
lapack_int LAPACKE_ssytri( int matrix_order, char uplo, lapack_int n, float* a,
lapack_int lda, const lapack_int* ipiv );
lapack_int LAPACKE_dsytri( int matrix_order, char uplo, lapack_int n, double* a,
lapack_int lda, const lapack_int* ipiv );
lapack_int LAPACKE_csytri( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
const lapack_int* ipiv );
lapack_int LAPACKE_zsytri( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
const lapack_int* ipiv );
lapack_int LAPACKE_ssytrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* a, lapack_int lda,
const lapack_int* ipiv, float* b, lapack_int ldb );
lapack_int LAPACKE_dsytrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* a, lapack_int lda,
const lapack_int* ipiv, double* b, lapack_int ldb );
lapack_int LAPACKE_csytrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zsytrs( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_stbcon( int matrix_order, char norm, char uplo, char diag,
lapack_int n, lapack_int kd, const float* ab,
lapack_int ldab, float* rcond );
lapack_int LAPACKE_dtbcon( int matrix_order, char norm, char uplo, char diag,
lapack_int n, lapack_int kd, const double* ab,
lapack_int ldab, double* rcond );
lapack_int LAPACKE_ctbcon( int matrix_order, char norm, char uplo, char diag,
lapack_int n, lapack_int kd,
const lapack_complex_float* ab, lapack_int ldab,
float* rcond );
lapack_int LAPACKE_ztbcon( int matrix_order, char norm, char uplo, char diag,
lapack_int n, lapack_int kd,
const lapack_complex_double* ab, lapack_int ldab,
double* rcond );
lapack_int LAPACKE_stbrfs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int kd, lapack_int nrhs,
const float* ab, lapack_int ldab, const float* b,
lapack_int ldb, const float* x, lapack_int ldx,
float* ferr, float* berr );
lapack_int LAPACKE_dtbrfs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int kd, lapack_int nrhs,
const double* ab, lapack_int ldab, const double* b,
lapack_int ldb, const double* x, lapack_int ldx,
double* ferr, double* berr );
lapack_int LAPACKE_ctbrfs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int kd, lapack_int nrhs,
const lapack_complex_float* ab, lapack_int ldab,
const lapack_complex_float* b, lapack_int ldb,
const lapack_complex_float* x, lapack_int ldx,
float* ferr, float* berr );
lapack_int LAPACKE_ztbrfs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int kd, lapack_int nrhs,
const lapack_complex_double* ab, lapack_int ldab,
const lapack_complex_double* b, lapack_int ldb,
const lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr );
lapack_int LAPACKE_stbtrs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int kd, lapack_int nrhs,
const float* ab, lapack_int ldab, float* b,
lapack_int ldb );
lapack_int LAPACKE_dtbtrs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int kd, lapack_int nrhs,
const double* ab, lapack_int ldab, double* b,
lapack_int ldb );
lapack_int LAPACKE_ctbtrs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int kd, lapack_int nrhs,
const lapack_complex_float* ab, lapack_int ldab,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_ztbtrs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int kd, lapack_int nrhs,
const lapack_complex_double* ab, lapack_int ldab,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_stfsm( int matrix_order, char transr, char side, char uplo,
char trans, char diag, lapack_int m, lapack_int n,
float alpha, const float* a, float* b,
lapack_int ldb );
lapack_int LAPACKE_dtfsm( int matrix_order, char transr, char side, char uplo,
char trans, char diag, lapack_int m, lapack_int n,
double alpha, const double* a, double* b,
lapack_int ldb );
lapack_int LAPACKE_ctfsm( int matrix_order, char transr, char side, char uplo,
char trans, char diag, lapack_int m, lapack_int n,
lapack_complex_float alpha,
const lapack_complex_float* a,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_ztfsm( int matrix_order, char transr, char side, char uplo,
char trans, char diag, lapack_int m, lapack_int n,
lapack_complex_double alpha,
const lapack_complex_double* a,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_stftri( int matrix_order, char transr, char uplo, char diag,
lapack_int n, float* a );
lapack_int LAPACKE_dtftri( int matrix_order, char transr, char uplo, char diag,
lapack_int n, double* a );
lapack_int LAPACKE_ctftri( int matrix_order, char transr, char uplo, char diag,
lapack_int n, lapack_complex_float* a );
lapack_int LAPACKE_ztftri( int matrix_order, char transr, char uplo, char diag,
lapack_int n, lapack_complex_double* a );
lapack_int LAPACKE_stfttp( int matrix_order, char transr, char uplo,
lapack_int n, const float* arf, float* ap );
lapack_int LAPACKE_dtfttp( int matrix_order, char transr, char uplo,
lapack_int n, const double* arf, double* ap );
lapack_int LAPACKE_ctfttp( int matrix_order, char transr, char uplo,
lapack_int n, const lapack_complex_float* arf,
lapack_complex_float* ap );
lapack_int LAPACKE_ztfttp( int matrix_order, char transr, char uplo,
lapack_int n, const lapack_complex_double* arf,
lapack_complex_double* ap );
lapack_int LAPACKE_stfttr( int matrix_order, char transr, char uplo,
lapack_int n, const float* arf, float* a,
lapack_int lda );
lapack_int LAPACKE_dtfttr( int matrix_order, char transr, char uplo,
lapack_int n, const double* arf, double* a,
lapack_int lda );
lapack_int LAPACKE_ctfttr( int matrix_order, char transr, char uplo,
lapack_int n, const lapack_complex_float* arf,
lapack_complex_float* a, lapack_int lda );
lapack_int LAPACKE_ztfttr( int matrix_order, char transr, char uplo,
lapack_int n, const lapack_complex_double* arf,
lapack_complex_double* a, lapack_int lda );
lapack_int LAPACKE_stgevc( int matrix_order, char side, char howmny,
const lapack_logical* select, lapack_int n,
const float* s, lapack_int lds, const float* p,
lapack_int ldp, float* vl, lapack_int ldvl,
float* vr, lapack_int ldvr, lapack_int mm,
lapack_int* m );
lapack_int LAPACKE_dtgevc( int matrix_order, char side, char howmny,
const lapack_logical* select, lapack_int n,
const double* s, lapack_int lds, const double* p,
lapack_int ldp, double* vl, lapack_int ldvl,
double* vr, lapack_int ldvr, lapack_int mm,
lapack_int* m );
lapack_int LAPACKE_ctgevc( int matrix_order, char side, char howmny,
const lapack_logical* select, lapack_int n,
const lapack_complex_float* s, lapack_int lds,
const lapack_complex_float* p, lapack_int ldp,
lapack_complex_float* vl, lapack_int ldvl,
lapack_complex_float* vr, lapack_int ldvr,
lapack_int mm, lapack_int* m );
lapack_int LAPACKE_ztgevc( int matrix_order, char side, char howmny,
const lapack_logical* select, lapack_int n,
const lapack_complex_double* s, lapack_int lds,
const lapack_complex_double* p, lapack_int ldp,
lapack_complex_double* vl, lapack_int ldvl,
lapack_complex_double* vr, lapack_int ldvr,
lapack_int mm, lapack_int* m );
lapack_int LAPACKE_stgexc( int matrix_order, lapack_logical wantq,
lapack_logical wantz, lapack_int n, float* a,
lapack_int lda, float* b, lapack_int ldb, float* q,
lapack_int ldq, float* z, lapack_int ldz,
lapack_int* ifst, lapack_int* ilst );
lapack_int LAPACKE_dtgexc( int matrix_order, lapack_logical wantq,
lapack_logical wantz, lapack_int n, double* a,
lapack_int lda, double* b, lapack_int ldb, double* q,
lapack_int ldq, double* z, lapack_int ldz,
lapack_int* ifst, lapack_int* ilst );
lapack_int LAPACKE_ctgexc( int matrix_order, lapack_logical wantq,
lapack_logical wantz, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* q, lapack_int ldq,
lapack_complex_float* z, lapack_int ldz,
lapack_int ifst, lapack_int ilst );
lapack_int LAPACKE_ztgexc( int matrix_order, lapack_logical wantq,
lapack_logical wantz, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* q, lapack_int ldq,
lapack_complex_double* z, lapack_int ldz,
lapack_int ifst, lapack_int ilst );
lapack_int LAPACKE_stgsen( int matrix_order, lapack_int ijob,
lapack_logical wantq, lapack_logical wantz,
const lapack_logical* select, lapack_int n, float* a,
lapack_int lda, float* b, lapack_int ldb,
float* alphar, float* alphai, float* beta, float* q,
lapack_int ldq, float* z, lapack_int ldz,
lapack_int* m, float* pl, float* pr, float* dif );
lapack_int LAPACKE_dtgsen( int matrix_order, lapack_int ijob,
lapack_logical wantq, lapack_logical wantz,
const lapack_logical* select, lapack_int n,
double* a, lapack_int lda, double* b, lapack_int ldb,
double* alphar, double* alphai, double* beta,
double* q, lapack_int ldq, double* z, lapack_int ldz,
lapack_int* m, double* pl, double* pr, double* dif );
lapack_int LAPACKE_ctgsen( int matrix_order, lapack_int ijob,
lapack_logical wantq, lapack_logical wantz,
const lapack_logical* select, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* alpha,
lapack_complex_float* beta, lapack_complex_float* q,
lapack_int ldq, lapack_complex_float* z,
lapack_int ldz, lapack_int* m, float* pl, float* pr,
float* dif );
lapack_int LAPACKE_ztgsen( int matrix_order, lapack_int ijob,
lapack_logical wantq, lapack_logical wantz,
const lapack_logical* select, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* alpha,
lapack_complex_double* beta,
lapack_complex_double* q, lapack_int ldq,
lapack_complex_double* z, lapack_int ldz,
lapack_int* m, double* pl, double* pr, double* dif );
lapack_int LAPACKE_stgsja( int matrix_order, char jobu, char jobv, char jobq,
lapack_int m, lapack_int p, lapack_int n,
lapack_int k, lapack_int l, float* a, lapack_int lda,
float* b, lapack_int ldb, float tola, float tolb,
float* alpha, float* beta, float* u, lapack_int ldu,
float* v, lapack_int ldv, float* q, lapack_int ldq,
lapack_int* ncycle );
lapack_int LAPACKE_dtgsja( int matrix_order, char jobu, char jobv, char jobq,
lapack_int m, lapack_int p, lapack_int n,
lapack_int k, lapack_int l, double* a,
lapack_int lda, double* b, lapack_int ldb,
double tola, double tolb, double* alpha,
double* beta, double* u, lapack_int ldu, double* v,
lapack_int ldv, double* q, lapack_int ldq,
lapack_int* ncycle );
lapack_int LAPACKE_ctgsja( int matrix_order, char jobu, char jobv, char jobq,
lapack_int m, lapack_int p, lapack_int n,
lapack_int k, lapack_int l, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb, float tola, float tolb, float* alpha,
float* beta, lapack_complex_float* u, lapack_int ldu,
lapack_complex_float* v, lapack_int ldv,
lapack_complex_float* q, lapack_int ldq,
lapack_int* ncycle );
lapack_int LAPACKE_ztgsja( int matrix_order, char jobu, char jobv, char jobq,
lapack_int m, lapack_int p, lapack_int n,
lapack_int k, lapack_int l, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb, double tola, double tolb,
double* alpha, double* beta,
lapack_complex_double* u, lapack_int ldu,
lapack_complex_double* v, lapack_int ldv,
lapack_complex_double* q, lapack_int ldq,
lapack_int* ncycle );
lapack_int LAPACKE_stgsna( int matrix_order, char job, char howmny,
const lapack_logical* select, lapack_int n,
const float* a, lapack_int lda, const float* b,
lapack_int ldb, const float* vl, lapack_int ldvl,
const float* vr, lapack_int ldvr, float* s,
float* dif, lapack_int mm, lapack_int* m );
lapack_int LAPACKE_dtgsna( int matrix_order, char job, char howmny,
const lapack_logical* select, lapack_int n,
const double* a, lapack_int lda, const double* b,
lapack_int ldb, const double* vl, lapack_int ldvl,
const double* vr, lapack_int ldvr, double* s,
double* dif, lapack_int mm, lapack_int* m );
lapack_int LAPACKE_ctgsna( int matrix_order, char job, char howmny,
const lapack_logical* select, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* b, lapack_int ldb,
const lapack_complex_float* vl, lapack_int ldvl,
const lapack_complex_float* vr, lapack_int ldvr,
float* s, float* dif, lapack_int mm, lapack_int* m );
lapack_int LAPACKE_ztgsna( int matrix_order, char job, char howmny,
const lapack_logical* select, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* b, lapack_int ldb,
const lapack_complex_double* vl, lapack_int ldvl,
const lapack_complex_double* vr, lapack_int ldvr,
double* s, double* dif, lapack_int mm,
lapack_int* m );
lapack_int LAPACKE_stgsyl( int matrix_order, char trans, lapack_int ijob,
lapack_int m, lapack_int n, const float* a,
lapack_int lda, const float* b, lapack_int ldb,
float* c, lapack_int ldc, const float* d,
lapack_int ldd, const float* e, lapack_int lde,
float* f, lapack_int ldf, float* scale, float* dif );
lapack_int LAPACKE_dtgsyl( int matrix_order, char trans, lapack_int ijob,
lapack_int m, lapack_int n, const double* a,
lapack_int lda, const double* b, lapack_int ldb,
double* c, lapack_int ldc, const double* d,
lapack_int ldd, const double* e, lapack_int lde,
double* f, lapack_int ldf, double* scale,
double* dif );
lapack_int LAPACKE_ctgsyl( int matrix_order, char trans, lapack_int ijob,
lapack_int m, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* c, lapack_int ldc,
const lapack_complex_float* d, lapack_int ldd,
const lapack_complex_float* e, lapack_int lde,
lapack_complex_float* f, lapack_int ldf,
float* scale, float* dif );
lapack_int LAPACKE_ztgsyl( int matrix_order, char trans, lapack_int ijob,
lapack_int m, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* c, lapack_int ldc,
const lapack_complex_double* d, lapack_int ldd,
const lapack_complex_double* e, lapack_int lde,
lapack_complex_double* f, lapack_int ldf,
double* scale, double* dif );
lapack_int LAPACKE_stpcon( int matrix_order, char norm, char uplo, char diag,
lapack_int n, const float* ap, float* rcond );
lapack_int LAPACKE_dtpcon( int matrix_order, char norm, char uplo, char diag,
lapack_int n, const double* ap, double* rcond );
lapack_int LAPACKE_ctpcon( int matrix_order, char norm, char uplo, char diag,
lapack_int n, const lapack_complex_float* ap,
float* rcond );
lapack_int LAPACKE_ztpcon( int matrix_order, char norm, char uplo, char diag,
lapack_int n, const lapack_complex_double* ap,
double* rcond );
lapack_int LAPACKE_stprfs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int nrhs, const float* ap,
const float* b, lapack_int ldb, const float* x,
lapack_int ldx, float* ferr, float* berr );
lapack_int LAPACKE_dtprfs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int nrhs, const double* ap,
const double* b, lapack_int ldb, const double* x,
lapack_int ldx, double* ferr, double* berr );
lapack_int LAPACKE_ctprfs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int nrhs,
const lapack_complex_float* ap,
const lapack_complex_float* b, lapack_int ldb,
const lapack_complex_float* x, lapack_int ldx,
float* ferr, float* berr );
lapack_int LAPACKE_ztprfs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int nrhs,
const lapack_complex_double* ap,
const lapack_complex_double* b, lapack_int ldb,
const lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr );
lapack_int LAPACKE_stptri( int matrix_order, char uplo, char diag, lapack_int n,
float* ap );
lapack_int LAPACKE_dtptri( int matrix_order, char uplo, char diag, lapack_int n,
double* ap );
lapack_int LAPACKE_ctptri( int matrix_order, char uplo, char diag, lapack_int n,
lapack_complex_float* ap );
lapack_int LAPACKE_ztptri( int matrix_order, char uplo, char diag, lapack_int n,
lapack_complex_double* ap );
lapack_int LAPACKE_stptrs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int nrhs, const float* ap,
float* b, lapack_int ldb );
lapack_int LAPACKE_dtptrs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int nrhs, const double* ap,
double* b, lapack_int ldb );
lapack_int LAPACKE_ctptrs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int nrhs,
const lapack_complex_float* ap,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_ztptrs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int nrhs,
const lapack_complex_double* ap,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_stpttf( int matrix_order, char transr, char uplo,
lapack_int n, const float* ap, float* arf );
lapack_int LAPACKE_dtpttf( int matrix_order, char transr, char uplo,
lapack_int n, const double* ap, double* arf );
lapack_int LAPACKE_ctpttf( int matrix_order, char transr, char uplo,
lapack_int n, const lapack_complex_float* ap,
lapack_complex_float* arf );
lapack_int LAPACKE_ztpttf( int matrix_order, char transr, char uplo,
lapack_int n, const lapack_complex_double* ap,
lapack_complex_double* arf );
lapack_int LAPACKE_stpttr( int matrix_order, char uplo, lapack_int n,
const float* ap, float* a, lapack_int lda );
lapack_int LAPACKE_dtpttr( int matrix_order, char uplo, lapack_int n,
const double* ap, double* a, lapack_int lda );
lapack_int LAPACKE_ctpttr( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* ap,
lapack_complex_float* a, lapack_int lda );
lapack_int LAPACKE_ztpttr( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* ap,
lapack_complex_double* a, lapack_int lda );
lapack_int LAPACKE_strcon( int matrix_order, char norm, char uplo, char diag,
lapack_int n, const float* a, lapack_int lda,
float* rcond );
lapack_int LAPACKE_dtrcon( int matrix_order, char norm, char uplo, char diag,
lapack_int n, const double* a, lapack_int lda,
double* rcond );
lapack_int LAPACKE_ctrcon( int matrix_order, char norm, char uplo, char diag,
lapack_int n, const lapack_complex_float* a,
lapack_int lda, float* rcond );
lapack_int LAPACKE_ztrcon( int matrix_order, char norm, char uplo, char diag,
lapack_int n, const lapack_complex_double* a,
lapack_int lda, double* rcond );
lapack_int LAPACKE_strevc( int matrix_order, char side, char howmny,
lapack_logical* select, lapack_int n, const float* t,
lapack_int ldt, float* vl, lapack_int ldvl,
float* vr, lapack_int ldvr, lapack_int mm,
lapack_int* m );
lapack_int LAPACKE_dtrevc( int matrix_order, char side, char howmny,
lapack_logical* select, lapack_int n,
const double* t, lapack_int ldt, double* vl,
lapack_int ldvl, double* vr, lapack_int ldvr,
lapack_int mm, lapack_int* m );
lapack_int LAPACKE_ctrevc( int matrix_order, char side, char howmny,
const lapack_logical* select, lapack_int n,
lapack_complex_float* t, lapack_int ldt,
lapack_complex_float* vl, lapack_int ldvl,
lapack_complex_float* vr, lapack_int ldvr,
lapack_int mm, lapack_int* m );
lapack_int LAPACKE_ztrevc( int matrix_order, char side, char howmny,
const lapack_logical* select, lapack_int n,
lapack_complex_double* t, lapack_int ldt,
lapack_complex_double* vl, lapack_int ldvl,
lapack_complex_double* vr, lapack_int ldvr,
lapack_int mm, lapack_int* m );
lapack_int LAPACKE_strexc( int matrix_order, char compq, lapack_int n, float* t,
lapack_int ldt, float* q, lapack_int ldq,
lapack_int* ifst, lapack_int* ilst );
lapack_int LAPACKE_dtrexc( int matrix_order, char compq, lapack_int n,
double* t, lapack_int ldt, double* q, lapack_int ldq,
lapack_int* ifst, lapack_int* ilst );
lapack_int LAPACKE_ctrexc( int matrix_order, char compq, lapack_int n,
lapack_complex_float* t, lapack_int ldt,
lapack_complex_float* q, lapack_int ldq,
lapack_int ifst, lapack_int ilst );
lapack_int LAPACKE_ztrexc( int matrix_order, char compq, lapack_int n,
lapack_complex_double* t, lapack_int ldt,
lapack_complex_double* q, lapack_int ldq,
lapack_int ifst, lapack_int ilst );
lapack_int LAPACKE_strrfs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int nrhs, const float* a,
lapack_int lda, const float* b, lapack_int ldb,
const float* x, lapack_int ldx, float* ferr,
float* berr );
lapack_int LAPACKE_dtrrfs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int nrhs, const double* a,
lapack_int lda, const double* b, lapack_int ldb,
const double* x, lapack_int ldx, double* ferr,
double* berr );
lapack_int LAPACKE_ctrrfs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int nrhs,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* b, lapack_int ldb,
const lapack_complex_float* x, lapack_int ldx,
float* ferr, float* berr );
lapack_int LAPACKE_ztrrfs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int nrhs,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* b, lapack_int ldb,
const lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr );
lapack_int LAPACKE_strsen( int matrix_order, char job, char compq,
const lapack_logical* select, lapack_int n, float* t,
lapack_int ldt, float* q, lapack_int ldq, float* wr,
float* wi, lapack_int* m, float* s, float* sep );
lapack_int LAPACKE_dtrsen( int matrix_order, char job, char compq,
const lapack_logical* select, lapack_int n,
double* t, lapack_int ldt, double* q, lapack_int ldq,
double* wr, double* wi, lapack_int* m, double* s,
double* sep );
lapack_int LAPACKE_ctrsen( int matrix_order, char job, char compq,
const lapack_logical* select, lapack_int n,
lapack_complex_float* t, lapack_int ldt,
lapack_complex_float* q, lapack_int ldq,
lapack_complex_float* w, lapack_int* m, float* s,
float* sep );
lapack_int LAPACKE_ztrsen( int matrix_order, char job, char compq,
const lapack_logical* select, lapack_int n,
lapack_complex_double* t, lapack_int ldt,
lapack_complex_double* q, lapack_int ldq,
lapack_complex_double* w, lapack_int* m, double* s,
double* sep );
lapack_int LAPACKE_strsna( int matrix_order, char job, char howmny,
const lapack_logical* select, lapack_int n,
const float* t, lapack_int ldt, const float* vl,
lapack_int ldvl, const float* vr, lapack_int ldvr,
float* s, float* sep, lapack_int mm, lapack_int* m );
lapack_int LAPACKE_dtrsna( int matrix_order, char job, char howmny,
const lapack_logical* select, lapack_int n,
const double* t, lapack_int ldt, const double* vl,
lapack_int ldvl, const double* vr, lapack_int ldvr,
double* s, double* sep, lapack_int mm,
lapack_int* m );
lapack_int LAPACKE_ctrsna( int matrix_order, char job, char howmny,
const lapack_logical* select, lapack_int n,
const lapack_complex_float* t, lapack_int ldt,
const lapack_complex_float* vl, lapack_int ldvl,
const lapack_complex_float* vr, lapack_int ldvr,
float* s, float* sep, lapack_int mm, lapack_int* m );
lapack_int LAPACKE_ztrsna( int matrix_order, char job, char howmny,
const lapack_logical* select, lapack_int n,
const lapack_complex_double* t, lapack_int ldt,
const lapack_complex_double* vl, lapack_int ldvl,
const lapack_complex_double* vr, lapack_int ldvr,
double* s, double* sep, lapack_int mm,
lapack_int* m );
lapack_int LAPACKE_strsyl( int matrix_order, char trana, char tranb,
lapack_int isgn, lapack_int m, lapack_int n,
const float* a, lapack_int lda, const float* b,
lapack_int ldb, float* c, lapack_int ldc,
float* scale );
lapack_int LAPACKE_dtrsyl( int matrix_order, char trana, char tranb,
lapack_int isgn, lapack_int m, lapack_int n,
const double* a, lapack_int lda, const double* b,
lapack_int ldb, double* c, lapack_int ldc,
double* scale );
lapack_int LAPACKE_ctrsyl( int matrix_order, char trana, char tranb,
lapack_int isgn, lapack_int m, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* c, lapack_int ldc,
float* scale );
lapack_int LAPACKE_ztrsyl( int matrix_order, char trana, char tranb,
lapack_int isgn, lapack_int m, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* c, lapack_int ldc,
double* scale );
lapack_int LAPACKE_strtri( int matrix_order, char uplo, char diag, lapack_int n,
float* a, lapack_int lda );
lapack_int LAPACKE_dtrtri( int matrix_order, char uplo, char diag, lapack_int n,
double* a, lapack_int lda );
lapack_int LAPACKE_ctrtri( int matrix_order, char uplo, char diag, lapack_int n,
lapack_complex_float* a, lapack_int lda );
lapack_int LAPACKE_ztrtri( int matrix_order, char uplo, char diag, lapack_int n,
lapack_complex_double* a, lapack_int lda );
lapack_int LAPACKE_strtrs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int nrhs, const float* a,
lapack_int lda, float* b, lapack_int ldb );
lapack_int LAPACKE_dtrtrs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int nrhs, const double* a,
lapack_int lda, double* b, lapack_int ldb );
lapack_int LAPACKE_ctrtrs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int nrhs,
const lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_ztrtrs( int matrix_order, char uplo, char trans, char diag,
lapack_int n, lapack_int nrhs,
const lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_strttf( int matrix_order, char transr, char uplo,
lapack_int n, const float* a, lapack_int lda,
float* arf );
lapack_int LAPACKE_dtrttf( int matrix_order, char transr, char uplo,
lapack_int n, const double* a, lapack_int lda,
double* arf );
lapack_int LAPACKE_ctrttf( int matrix_order, char transr, char uplo,
lapack_int n, const lapack_complex_float* a,
lapack_int lda, lapack_complex_float* arf );
lapack_int LAPACKE_ztrttf( int matrix_order, char transr, char uplo,
lapack_int n, const lapack_complex_double* a,
lapack_int lda, lapack_complex_double* arf );
lapack_int LAPACKE_strttp( int matrix_order, char uplo, lapack_int n,
const float* a, lapack_int lda, float* ap );
lapack_int LAPACKE_dtrttp( int matrix_order, char uplo, lapack_int n,
const double* a, lapack_int lda, double* ap );
lapack_int LAPACKE_ctrttp( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
lapack_complex_float* ap );
lapack_int LAPACKE_ztrttp( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
lapack_complex_double* ap );
lapack_int LAPACKE_stzrzf( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* tau );
lapack_int LAPACKE_dtzrzf( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* tau );
lapack_int LAPACKE_ctzrzf( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* tau );
lapack_int LAPACKE_ztzrzf( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* tau );
lapack_int LAPACKE_cungbr( int matrix_order, char vect, lapack_int m,
lapack_int n, lapack_int k, lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* tau );
lapack_int LAPACKE_zungbr( int matrix_order, char vect, lapack_int m,
lapack_int n, lapack_int k, lapack_complex_double* a,
lapack_int lda, const lapack_complex_double* tau );
lapack_int LAPACKE_cunghr( int matrix_order, lapack_int n, lapack_int ilo,
lapack_int ihi, lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* tau );
lapack_int LAPACKE_zunghr( int matrix_order, lapack_int n, lapack_int ilo,
lapack_int ihi, lapack_complex_double* a,
lapack_int lda, const lapack_complex_double* tau );
lapack_int LAPACKE_cunglq( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* tau );
lapack_int LAPACKE_zunglq( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, lapack_complex_double* a,
lapack_int lda, const lapack_complex_double* tau );
lapack_int LAPACKE_cungql( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* tau );
lapack_int LAPACKE_zungql( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, lapack_complex_double* a,
lapack_int lda, const lapack_complex_double* tau );
lapack_int LAPACKE_cungqr( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* tau );
lapack_int LAPACKE_zungqr( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, lapack_complex_double* a,
lapack_int lda, const lapack_complex_double* tau );
lapack_int LAPACKE_cungrq( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* tau );
lapack_int LAPACKE_zungrq( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, lapack_complex_double* a,
lapack_int lda, const lapack_complex_double* tau );
lapack_int LAPACKE_cungtr( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* tau );
lapack_int LAPACKE_zungtr( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* tau );
lapack_int LAPACKE_cunmbr( int matrix_order, char vect, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int ldc );
lapack_int LAPACKE_zunmbr( int matrix_order, char vect, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int ldc );
lapack_int LAPACKE_cunmhr( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int ilo,
lapack_int ihi, const lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int ldc );
lapack_int LAPACKE_zunmhr( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int ilo,
lapack_int ihi, const lapack_complex_double* a,
lapack_int lda, const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int ldc );
lapack_int LAPACKE_cunmlq( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int ldc );
lapack_int LAPACKE_zunmlq( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int ldc );
lapack_int LAPACKE_cunmql( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int ldc );
lapack_int LAPACKE_zunmql( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int ldc );
lapack_int LAPACKE_cunmqr( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int ldc );
lapack_int LAPACKE_zunmqr( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int ldc );
lapack_int LAPACKE_cunmrq( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int ldc );
lapack_int LAPACKE_zunmrq( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int ldc );
lapack_int LAPACKE_cunmrz( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int l, const lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int ldc );
lapack_int LAPACKE_zunmrz( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int l, const lapack_complex_double* a,
lapack_int lda, const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int ldc );
lapack_int LAPACKE_cunmtr( int matrix_order, char side, char uplo, char trans,
lapack_int m, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int ldc );
lapack_int LAPACKE_zunmtr( int matrix_order, char side, char uplo, char trans,
lapack_int m, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int ldc );
lapack_int LAPACKE_cupgtr( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* ap,
const lapack_complex_float* tau,
lapack_complex_float* q, lapack_int ldq );
lapack_int LAPACKE_zupgtr( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* ap,
const lapack_complex_double* tau,
lapack_complex_double* q, lapack_int ldq );
lapack_int LAPACKE_cupmtr( int matrix_order, char side, char uplo, char trans,
lapack_int m, lapack_int n,
const lapack_complex_float* ap,
const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int ldc );
lapack_int LAPACKE_zupmtr( int matrix_order, char side, char uplo, char trans,
lapack_int m, lapack_int n,
const lapack_complex_double* ap,
const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int ldc );
lapack_int LAPACKE_sbdsdc_work( int matrix_order, char uplo, char compq,
lapack_int n, float* d, float* e, float* u,
lapack_int ldu, float* vt, lapack_int ldvt,
float* q, lapack_int* iq, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dbdsdc_work( int matrix_order, char uplo, char compq,
lapack_int n, double* d, double* e, double* u,
lapack_int ldu, double* vt, lapack_int ldvt,
double* q, lapack_int* iq, double* work,
lapack_int* iwork );
lapack_int LAPACKE_sbdsqr_work( int matrix_order, char uplo, lapack_int n,
lapack_int ncvt, lapack_int nru, lapack_int ncc,
float* d, float* e, float* vt, lapack_int ldvt,
float* u, lapack_int ldu, float* c,
lapack_int ldc, float* work );
lapack_int LAPACKE_dbdsqr_work( int matrix_order, char uplo, lapack_int n,
lapack_int ncvt, lapack_int nru, lapack_int ncc,
double* d, double* e, double* vt,
lapack_int ldvt, double* u, lapack_int ldu,
double* c, lapack_int ldc, double* work );
lapack_int LAPACKE_cbdsqr_work( int matrix_order, char uplo, lapack_int n,
lapack_int ncvt, lapack_int nru, lapack_int ncc,
float* d, float* e, lapack_complex_float* vt,
lapack_int ldvt, lapack_complex_float* u,
lapack_int ldu, lapack_complex_float* c,
lapack_int ldc, float* work );
lapack_int LAPACKE_zbdsqr_work( int matrix_order, char uplo, lapack_int n,
lapack_int ncvt, lapack_int nru, lapack_int ncc,
double* d, double* e, lapack_complex_double* vt,
lapack_int ldvt, lapack_complex_double* u,
lapack_int ldu, lapack_complex_double* c,
lapack_int ldc, double* work );
lapack_int LAPACKE_sdisna_work( char job, lapack_int m, lapack_int n,
const float* d, float* sep );
lapack_int LAPACKE_ddisna_work( char job, lapack_int m, lapack_int n,
const double* d, double* sep );
lapack_int LAPACKE_sgbbrd_work( int matrix_order, char vect, lapack_int m,
lapack_int n, lapack_int ncc, lapack_int kl,
lapack_int ku, float* ab, lapack_int ldab,
float* d, float* e, float* q, lapack_int ldq,
float* pt, lapack_int ldpt, float* c,
lapack_int ldc, float* work );
lapack_int LAPACKE_dgbbrd_work( int matrix_order, char vect, lapack_int m,
lapack_int n, lapack_int ncc, lapack_int kl,
lapack_int ku, double* ab, lapack_int ldab,
double* d, double* e, double* q, lapack_int ldq,
double* pt, lapack_int ldpt, double* c,
lapack_int ldc, double* work );
lapack_int LAPACKE_cgbbrd_work( int matrix_order, char vect, lapack_int m,
lapack_int n, lapack_int ncc, lapack_int kl,
lapack_int ku, lapack_complex_float* ab,
lapack_int ldab, float* d, float* e,
lapack_complex_float* q, lapack_int ldq,
lapack_complex_float* pt, lapack_int ldpt,
lapack_complex_float* c, lapack_int ldc,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zgbbrd_work( int matrix_order, char vect, lapack_int m,
lapack_int n, lapack_int ncc, lapack_int kl,
lapack_int ku, lapack_complex_double* ab,
lapack_int ldab, double* d, double* e,
lapack_complex_double* q, lapack_int ldq,
lapack_complex_double* pt, lapack_int ldpt,
lapack_complex_double* c, lapack_int ldc,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_sgbcon_work( int matrix_order, char norm, lapack_int n,
lapack_int kl, lapack_int ku, const float* ab,
lapack_int ldab, const lapack_int* ipiv,
float anorm, float* rcond, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dgbcon_work( int matrix_order, char norm, lapack_int n,
lapack_int kl, lapack_int ku, const double* ab,
lapack_int ldab, const lapack_int* ipiv,
double anorm, double* rcond, double* work,
lapack_int* iwork );
lapack_int LAPACKE_cgbcon_work( int matrix_order, char norm, lapack_int n,
lapack_int kl, lapack_int ku,
const lapack_complex_float* ab, lapack_int ldab,
const lapack_int* ipiv, float anorm,
float* rcond, lapack_complex_float* work,
float* rwork );
lapack_int LAPACKE_zgbcon_work( int matrix_order, char norm, lapack_int n,
lapack_int kl, lapack_int ku,
const lapack_complex_double* ab,
lapack_int ldab, const lapack_int* ipiv,
double anorm, double* rcond,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_sgbequ_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku, const float* ab,
lapack_int ldab, float* r, float* c,
float* rowcnd, float* colcnd, float* amax );
lapack_int LAPACKE_dgbequ_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku, const double* ab,
lapack_int ldab, double* r, double* c,
double* rowcnd, double* colcnd, double* amax );
lapack_int LAPACKE_cgbequ_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku,
const lapack_complex_float* ab, lapack_int ldab,
float* r, float* c, float* rowcnd,
float* colcnd, float* amax );
lapack_int LAPACKE_zgbequ_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku,
const lapack_complex_double* ab,
lapack_int ldab, double* r, double* c,
double* rowcnd, double* colcnd, double* amax );
lapack_int LAPACKE_sgbequb_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku, const float* ab,
lapack_int ldab, float* r, float* c,
float* rowcnd, float* colcnd, float* amax );
lapack_int LAPACKE_dgbequb_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku, const double* ab,
lapack_int ldab, double* r, double* c,
double* rowcnd, double* colcnd, double* amax );
lapack_int LAPACKE_cgbequb_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku,
const lapack_complex_float* ab,
lapack_int ldab, float* r, float* c,
float* rowcnd, float* colcnd, float* amax );
lapack_int LAPACKE_zgbequb_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku,
const lapack_complex_double* ab,
lapack_int ldab, double* r, double* c,
double* rowcnd, double* colcnd, double* amax );
lapack_int LAPACKE_sgbrfs_work( int matrix_order, char trans, lapack_int n,
lapack_int kl, lapack_int ku, lapack_int nrhs,
const float* ab, lapack_int ldab,
const float* afb, lapack_int ldafb,
const lapack_int* ipiv, const float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* ferr, float* berr, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dgbrfs_work( int matrix_order, char trans, lapack_int n,
lapack_int kl, lapack_int ku, lapack_int nrhs,
const double* ab, lapack_int ldab,
const double* afb, lapack_int ldafb,
const lapack_int* ipiv, const double* b,
lapack_int ldb, double* x, lapack_int ldx,
double* ferr, double* berr, double* work,
lapack_int* iwork );
lapack_int LAPACKE_cgbrfs_work( int matrix_order, char trans, lapack_int n,
lapack_int kl, lapack_int ku, lapack_int nrhs,
const lapack_complex_float* ab, lapack_int ldab,
const lapack_complex_float* afb,
lapack_int ldafb, const lapack_int* ipiv,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* ferr, float* berr,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zgbrfs_work( int matrix_order, char trans, lapack_int n,
lapack_int kl, lapack_int ku, lapack_int nrhs,
const lapack_complex_double* ab,
lapack_int ldab,
const lapack_complex_double* afb,
lapack_int ldafb, const lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_sgbrfsx_work( int matrix_order, char trans, char equed,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, const float* ab,
lapack_int ldab, const float* afb,
lapack_int ldafb, const lapack_int* ipiv,
const float* r, const float* c, const float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* rcond, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dgbrfsx_work( int matrix_order, char trans, char equed,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, const double* ab,
lapack_int ldab, const double* afb,
lapack_int ldafb, const lapack_int* ipiv,
const double* r, const double* c,
const double* b, lapack_int ldb, double* x,
lapack_int ldx, double* rcond, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params, double* work,
lapack_int* iwork );
lapack_int LAPACKE_cgbrfsx_work( int matrix_order, char trans, char equed,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs,
const lapack_complex_float* ab,
lapack_int ldab,
const lapack_complex_float* afb,
lapack_int ldafb, const lapack_int* ipiv,
const float* r, const float* c,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params, lapack_complex_float* work,
float* rwork );
lapack_int LAPACKE_zgbrfsx_work( int matrix_order, char trans, char equed,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs,
const lapack_complex_double* ab,
lapack_int ldab,
const lapack_complex_double* afb,
lapack_int ldafb, const lapack_int* ipiv,
const double* r, const double* c,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params, lapack_complex_double* work,
double* rwork );
lapack_int LAPACKE_sgbsv_work( int matrix_order, lapack_int n, lapack_int kl,
lapack_int ku, lapack_int nrhs, float* ab,
lapack_int ldab, lapack_int* ipiv, float* b,
lapack_int ldb );
lapack_int LAPACKE_dgbsv_work( int matrix_order, lapack_int n, lapack_int kl,
lapack_int ku, lapack_int nrhs, double* ab,
lapack_int ldab, lapack_int* ipiv, double* b,
lapack_int ldb );
lapack_int LAPACKE_cgbsv_work( int matrix_order, lapack_int n, lapack_int kl,
lapack_int ku, lapack_int nrhs,
lapack_complex_float* ab, lapack_int ldab,
lapack_int* ipiv, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zgbsv_work( int matrix_order, lapack_int n, lapack_int kl,
lapack_int ku, lapack_int nrhs,
lapack_complex_double* ab, lapack_int ldab,
lapack_int* ipiv, lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_sgbsvx_work( int matrix_order, char fact, char trans,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, float* ab, lapack_int ldab,
float* afb, lapack_int ldafb, lapack_int* ipiv,
char* equed, float* r, float* c, float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* rcond, float* ferr, float* berr,
float* work, lapack_int* iwork );
lapack_int LAPACKE_dgbsvx_work( int matrix_order, char fact, char trans,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, double* ab, lapack_int ldab,
double* afb, lapack_int ldafb, lapack_int* ipiv,
char* equed, double* r, double* c, double* b,
lapack_int ldb, double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr,
double* work, lapack_int* iwork );
lapack_int LAPACKE_cgbsvx_work( int matrix_order, char fact, char trans,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, lapack_complex_float* ab,
lapack_int ldab, lapack_complex_float* afb,
lapack_int ldafb, lapack_int* ipiv, char* equed,
float* r, float* c, lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* x,
lapack_int ldx, float* rcond, float* ferr,
float* berr, lapack_complex_float* work,
float* rwork );
lapack_int LAPACKE_zgbsvx_work( int matrix_order, char fact, char trans,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, lapack_complex_double* ab,
lapack_int ldab, lapack_complex_double* afb,
lapack_int ldafb, lapack_int* ipiv, char* equed,
double* r, double* c, lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* x,
lapack_int ldx, double* rcond, double* ferr,
double* berr, lapack_complex_double* work,
double* rwork );
lapack_int LAPACKE_sgbsvxx_work( int matrix_order, char fact, char trans,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, float* ab, lapack_int ldab,
float* afb, lapack_int ldafb, lapack_int* ipiv,
char* equed, float* r, float* c, float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* rcond, float* rpvgrw, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dgbsvxx_work( int matrix_order, char fact, char trans,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, double* ab, lapack_int ldab,
double* afb, lapack_int ldafb,
lapack_int* ipiv, char* equed, double* r,
double* c, double* b, lapack_int ldb,
double* x, lapack_int ldx, double* rcond,
double* rpvgrw, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params, double* work,
lapack_int* iwork );
lapack_int LAPACKE_cgbsvxx_work( int matrix_order, char fact, char trans,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, lapack_complex_float* ab,
lapack_int ldab, lapack_complex_float* afb,
lapack_int ldafb, lapack_int* ipiv,
char* equed, float* r, float* c,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* rpvgrw, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params, lapack_complex_float* work,
float* rwork );
lapack_int LAPACKE_zgbsvxx_work( int matrix_order, char fact, char trans,
lapack_int n, lapack_int kl, lapack_int ku,
lapack_int nrhs, lapack_complex_double* ab,
lapack_int ldab, lapack_complex_double* afb,
lapack_int ldafb, lapack_int* ipiv,
char* equed, double* r, double* c,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* rpvgrw, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params, lapack_complex_double* work,
double* rwork );
lapack_int LAPACKE_sgbtrf_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku, float* ab,
lapack_int ldab, lapack_int* ipiv );
lapack_int LAPACKE_dgbtrf_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku, double* ab,
lapack_int ldab, lapack_int* ipiv );
lapack_int LAPACKE_cgbtrf_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku,
lapack_complex_float* ab, lapack_int ldab,
lapack_int* ipiv );
lapack_int LAPACKE_zgbtrf_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku,
lapack_complex_double* ab, lapack_int ldab,
lapack_int* ipiv );
lapack_int LAPACKE_sgbtrs_work( int matrix_order, char trans, lapack_int n,
lapack_int kl, lapack_int ku, lapack_int nrhs,
const float* ab, lapack_int ldab,
const lapack_int* ipiv, float* b,
lapack_int ldb );
lapack_int LAPACKE_dgbtrs_work( int matrix_order, char trans, lapack_int n,
lapack_int kl, lapack_int ku, lapack_int nrhs,
const double* ab, lapack_int ldab,
const lapack_int* ipiv, double* b,
lapack_int ldb );
lapack_int LAPACKE_cgbtrs_work( int matrix_order, char trans, lapack_int n,
lapack_int kl, lapack_int ku, lapack_int nrhs,
const lapack_complex_float* ab, lapack_int ldab,
const lapack_int* ipiv, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zgbtrs_work( int matrix_order, char trans, lapack_int n,
lapack_int kl, lapack_int ku, lapack_int nrhs,
const lapack_complex_double* ab,
lapack_int ldab, const lapack_int* ipiv,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_sgebak_work( int matrix_order, char job, char side,
lapack_int n, lapack_int ilo, lapack_int ihi,
const float* scale, lapack_int m, float* v,
lapack_int ldv );
lapack_int LAPACKE_dgebak_work( int matrix_order, char job, char side,
lapack_int n, lapack_int ilo, lapack_int ihi,
const double* scale, lapack_int m, double* v,
lapack_int ldv );
lapack_int LAPACKE_cgebak_work( int matrix_order, char job, char side,
lapack_int n, lapack_int ilo, lapack_int ihi,
const float* scale, lapack_int m,
lapack_complex_float* v, lapack_int ldv );
lapack_int LAPACKE_zgebak_work( int matrix_order, char job, char side,
lapack_int n, lapack_int ilo, lapack_int ihi,
const double* scale, lapack_int m,
lapack_complex_double* v, lapack_int ldv );
lapack_int LAPACKE_sgebal_work( int matrix_order, char job, lapack_int n,
float* a, lapack_int lda, lapack_int* ilo,
lapack_int* ihi, float* scale );
lapack_int LAPACKE_dgebal_work( int matrix_order, char job, lapack_int n,
double* a, lapack_int lda, lapack_int* ilo,
lapack_int* ihi, double* scale );
lapack_int LAPACKE_cgebal_work( int matrix_order, char job, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_int* ilo, lapack_int* ihi,
float* scale );
lapack_int LAPACKE_zgebal_work( int matrix_order, char job, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_int* ilo, lapack_int* ihi,
double* scale );
lapack_int LAPACKE_sgebrd_work( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* d, float* e,
float* tauq, float* taup, float* work,
lapack_int lwork );
lapack_int LAPACKE_dgebrd_work( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* d, double* e,
double* tauq, double* taup, double* work,
lapack_int lwork );
lapack_int LAPACKE_cgebrd_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
float* d, float* e, lapack_complex_float* tauq,
lapack_complex_float* taup,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zgebrd_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
double* d, double* e,
lapack_complex_double* tauq,
lapack_complex_double* taup,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_sgecon_work( int matrix_order, char norm, lapack_int n,
const float* a, lapack_int lda, float anorm,
float* rcond, float* work, lapack_int* iwork );
lapack_int LAPACKE_dgecon_work( int matrix_order, char norm, lapack_int n,
const double* a, lapack_int lda, double anorm,
double* rcond, double* work,
lapack_int* iwork );
lapack_int LAPACKE_cgecon_work( int matrix_order, char norm, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
float anorm, float* rcond,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zgecon_work( int matrix_order, char norm, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
double anorm, double* rcond,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_sgeequ_work( int matrix_order, lapack_int m, lapack_int n,
const float* a, lapack_int lda, float* r,
float* c, float* rowcnd, float* colcnd,
float* amax );
lapack_int LAPACKE_dgeequ_work( int matrix_order, lapack_int m, lapack_int n,
const double* a, lapack_int lda, double* r,
double* c, double* rowcnd, double* colcnd,
double* amax );
lapack_int LAPACKE_cgeequ_work( int matrix_order, lapack_int m, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
float* r, float* c, float* rowcnd,
float* colcnd, float* amax );
lapack_int LAPACKE_zgeequ_work( int matrix_order, lapack_int m, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
double* r, double* c, double* rowcnd,
double* colcnd, double* amax );
lapack_int LAPACKE_sgeequb_work( int matrix_order, lapack_int m, lapack_int n,
const float* a, lapack_int lda, float* r,
float* c, float* rowcnd, float* colcnd,
float* amax );
lapack_int LAPACKE_dgeequb_work( int matrix_order, lapack_int m, lapack_int n,
const double* a, lapack_int lda, double* r,
double* c, double* rowcnd, double* colcnd,
double* amax );
lapack_int LAPACKE_cgeequb_work( int matrix_order, lapack_int m, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
float* r, float* c, float* rowcnd,
float* colcnd, float* amax );
lapack_int LAPACKE_zgeequb_work( int matrix_order, lapack_int m, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
double* r, double* c, double* rowcnd,
double* colcnd, double* amax );
lapack_int LAPACKE_sgees_work( int matrix_order, char jobvs, char sort,
LAPACK_S_SELECT2 select, lapack_int n, float* a,
lapack_int lda, lapack_int* sdim, float* wr,
float* wi, float* vs, lapack_int ldvs,
float* work, lapack_int lwork,
lapack_logical* bwork );
lapack_int LAPACKE_dgees_work( int matrix_order, char jobvs, char sort,
LAPACK_D_SELECT2 select, lapack_int n, double* a,
lapack_int lda, lapack_int* sdim, double* wr,
double* wi, double* vs, lapack_int ldvs,
double* work, lapack_int lwork,
lapack_logical* bwork );
lapack_int LAPACKE_cgees_work( int matrix_order, char jobvs, char sort,
LAPACK_C_SELECT1 select, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_int* sdim, lapack_complex_float* w,
lapack_complex_float* vs, lapack_int ldvs,
lapack_complex_float* work, lapack_int lwork,
float* rwork, lapack_logical* bwork );
lapack_int LAPACKE_zgees_work( int matrix_order, char jobvs, char sort,
LAPACK_Z_SELECT1 select, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_int* sdim, lapack_complex_double* w,
lapack_complex_double* vs, lapack_int ldvs,
lapack_complex_double* work, lapack_int lwork,
double* rwork, lapack_logical* bwork );
lapack_int LAPACKE_sgeesx_work( int matrix_order, char jobvs, char sort,
LAPACK_S_SELECT2 select, char sense,
lapack_int n, float* a, lapack_int lda,
lapack_int* sdim, float* wr, float* wi,
float* vs, lapack_int ldvs, float* rconde,
float* rcondv, float* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork,
lapack_logical* bwork );
lapack_int LAPACKE_dgeesx_work( int matrix_order, char jobvs, char sort,
LAPACK_D_SELECT2 select, char sense,
lapack_int n, double* a, lapack_int lda,
lapack_int* sdim, double* wr, double* wi,
double* vs, lapack_int ldvs, double* rconde,
double* rcondv, double* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork,
lapack_logical* bwork );
lapack_int LAPACKE_cgeesx_work( int matrix_order, char jobvs, char sort,
LAPACK_C_SELECT1 select, char sense,
lapack_int n, lapack_complex_float* a,
lapack_int lda, lapack_int* sdim,
lapack_complex_float* w,
lapack_complex_float* vs, lapack_int ldvs,
float* rconde, float* rcondv,
lapack_complex_float* work, lapack_int lwork,
float* rwork, lapack_logical* bwork );
lapack_int LAPACKE_zgeesx_work( int matrix_order, char jobvs, char sort,
LAPACK_Z_SELECT1 select, char sense,
lapack_int n, lapack_complex_double* a,
lapack_int lda, lapack_int* sdim,
lapack_complex_double* w,
lapack_complex_double* vs, lapack_int ldvs,
double* rconde, double* rcondv,
lapack_complex_double* work, lapack_int lwork,
double* rwork, lapack_logical* bwork );
lapack_int LAPACKE_sgeev_work( int matrix_order, char jobvl, char jobvr,
lapack_int n, float* a, lapack_int lda,
float* wr, float* wi, float* vl, lapack_int ldvl,
float* vr, lapack_int ldvr, float* work,
lapack_int lwork );
lapack_int LAPACKE_dgeev_work( int matrix_order, char jobvl, char jobvr,
lapack_int n, double* a, lapack_int lda,
double* wr, double* wi, double* vl,
lapack_int ldvl, double* vr, lapack_int ldvr,
double* work, lapack_int lwork );
lapack_int LAPACKE_cgeev_work( int matrix_order, char jobvl, char jobvr,
lapack_int n, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* w,
lapack_complex_float* vl, lapack_int ldvl,
lapack_complex_float* vr, lapack_int ldvr,
lapack_complex_float* work, lapack_int lwork,
float* rwork );
lapack_int LAPACKE_zgeev_work( int matrix_order, char jobvl, char jobvr,
lapack_int n, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* w,
lapack_complex_double* vl, lapack_int ldvl,
lapack_complex_double* vr, lapack_int ldvr,
lapack_complex_double* work, lapack_int lwork,
double* rwork );
lapack_int LAPACKE_sgeevx_work( int matrix_order, char balanc, char jobvl,
char jobvr, char sense, lapack_int n, float* a,
lapack_int lda, float* wr, float* wi, float* vl,
lapack_int ldvl, float* vr, lapack_int ldvr,
lapack_int* ilo, lapack_int* ihi, float* scale,
float* abnrm, float* rconde, float* rcondv,
float* work, lapack_int lwork,
lapack_int* iwork );
lapack_int LAPACKE_dgeevx_work( int matrix_order, char balanc, char jobvl,
char jobvr, char sense, lapack_int n, double* a,
lapack_int lda, double* wr, double* wi,
double* vl, lapack_int ldvl, double* vr,
lapack_int ldvr, lapack_int* ilo,
lapack_int* ihi, double* scale, double* abnrm,
double* rconde, double* rcondv, double* work,
lapack_int lwork, lapack_int* iwork );
lapack_int LAPACKE_cgeevx_work( int matrix_order, char balanc, char jobvl,
char jobvr, char sense, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* w,
lapack_complex_float* vl, lapack_int ldvl,
lapack_complex_float* vr, lapack_int ldvr,
lapack_int* ilo, lapack_int* ihi, float* scale,
float* abnrm, float* rconde, float* rcondv,
lapack_complex_float* work, lapack_int lwork,
float* rwork );
lapack_int LAPACKE_zgeevx_work( int matrix_order, char balanc, char jobvl,
char jobvr, char sense, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* w,
lapack_complex_double* vl, lapack_int ldvl,
lapack_complex_double* vr, lapack_int ldvr,
lapack_int* ilo, lapack_int* ihi, double* scale,
double* abnrm, double* rconde, double* rcondv,
lapack_complex_double* work, lapack_int lwork,
double* rwork );
lapack_int LAPACKE_sgehrd_work( int matrix_order, lapack_int n, lapack_int ilo,
lapack_int ihi, float* a, lapack_int lda,
float* tau, float* work, lapack_int lwork );
lapack_int LAPACKE_dgehrd_work( int matrix_order, lapack_int n, lapack_int ilo,
lapack_int ihi, double* a, lapack_int lda,
double* tau, double* work, lapack_int lwork );
lapack_int LAPACKE_cgehrd_work( int matrix_order, lapack_int n, lapack_int ilo,
lapack_int ihi, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* tau,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zgehrd_work( int matrix_order, lapack_int n, lapack_int ilo,
lapack_int ihi, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* tau,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_sgejsv_work( int matrix_order, char joba, char jobu,
char jobv, char jobr, char jobt, char jobp,
lapack_int m, lapack_int n, float* a,
lapack_int lda, float* sva, float* u,
lapack_int ldu, float* v, lapack_int ldv,
float* work, lapack_int lwork,
lapack_int* iwork );
lapack_int LAPACKE_dgejsv_work( int matrix_order, char joba, char jobu,
char jobv, char jobr, char jobt, char jobp,
lapack_int m, lapack_int n, double* a,
lapack_int lda, double* sva, double* u,
lapack_int ldu, double* v, lapack_int ldv,
double* work, lapack_int lwork,
lapack_int* iwork );
lapack_int LAPACKE_sgelq2_work( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* tau,
float* work );
lapack_int LAPACKE_dgelq2_work( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* tau,
double* work );
lapack_int LAPACKE_cgelq2_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* tau,
lapack_complex_float* work );
lapack_int LAPACKE_zgelq2_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* tau,
lapack_complex_double* work );
lapack_int LAPACKE_sgelqf_work( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* tau,
float* work, lapack_int lwork );
lapack_int LAPACKE_dgelqf_work( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* tau,
double* work, lapack_int lwork );
lapack_int LAPACKE_cgelqf_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* tau,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zgelqf_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* tau,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_sgels_work( int matrix_order, char trans, lapack_int m,
lapack_int n, lapack_int nrhs, float* a,
lapack_int lda, float* b, lapack_int ldb,
float* work, lapack_int lwork );
lapack_int LAPACKE_dgels_work( int matrix_order, char trans, lapack_int m,
lapack_int n, lapack_int nrhs, double* a,
lapack_int lda, double* b, lapack_int ldb,
double* work, lapack_int lwork );
lapack_int LAPACKE_cgels_work( int matrix_order, char trans, lapack_int m,
lapack_int n, lapack_int nrhs,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zgels_work( int matrix_order, char trans, lapack_int m,
lapack_int n, lapack_int nrhs,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_sgelsd_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, float* a, lapack_int lda,
float* b, lapack_int ldb, float* s, float rcond,
lapack_int* rank, float* work, lapack_int lwork,
lapack_int* iwork );
lapack_int LAPACKE_dgelsd_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, double* a, lapack_int lda,
double* b, lapack_int ldb, double* s,
double rcond, lapack_int* rank, double* work,
lapack_int lwork, lapack_int* iwork );
lapack_int LAPACKE_cgelsd_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb, float* s, float rcond,
lapack_int* rank, lapack_complex_float* work,
lapack_int lwork, float* rwork,
lapack_int* iwork );
lapack_int LAPACKE_zgelsd_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb, double* s, double rcond,
lapack_int* rank, lapack_complex_double* work,
lapack_int lwork, double* rwork,
lapack_int* iwork );
lapack_int LAPACKE_sgelss_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, float* a, lapack_int lda,
float* b, lapack_int ldb, float* s, float rcond,
lapack_int* rank, float* work,
lapack_int lwork );
lapack_int LAPACKE_dgelss_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, double* a, lapack_int lda,
double* b, lapack_int ldb, double* s,
double rcond, lapack_int* rank, double* work,
lapack_int lwork );
lapack_int LAPACKE_cgelss_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb, float* s, float rcond,
lapack_int* rank, lapack_complex_float* work,
lapack_int lwork, float* rwork );
lapack_int LAPACKE_zgelss_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb, double* s, double rcond,
lapack_int* rank, lapack_complex_double* work,
lapack_int lwork, double* rwork );
lapack_int LAPACKE_sgelsy_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, float* a, lapack_int lda,
float* b, lapack_int ldb, lapack_int* jpvt,
float rcond, lapack_int* rank, float* work,
lapack_int lwork );
lapack_int LAPACKE_dgelsy_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, double* a, lapack_int lda,
double* b, lapack_int ldb, lapack_int* jpvt,
double rcond, lapack_int* rank, double* work,
lapack_int lwork );
lapack_int LAPACKE_cgelsy_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb, lapack_int* jpvt, float rcond,
lapack_int* rank, lapack_complex_float* work,
lapack_int lwork, float* rwork );
lapack_int LAPACKE_zgelsy_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int nrhs, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb, lapack_int* jpvt, double rcond,
lapack_int* rank, lapack_complex_double* work,
lapack_int lwork, double* rwork );
lapack_int LAPACKE_sgeqlf_work( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* tau,
float* work, lapack_int lwork );
lapack_int LAPACKE_dgeqlf_work( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* tau,
double* work, lapack_int lwork );
lapack_int LAPACKE_cgeqlf_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* tau,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zgeqlf_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* tau,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_sgeqp3_work( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, lapack_int* jpvt,
float* tau, float* work, lapack_int lwork );
lapack_int LAPACKE_dgeqp3_work( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, lapack_int* jpvt,
double* tau, double* work, lapack_int lwork );
lapack_int LAPACKE_cgeqp3_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_int* jpvt, lapack_complex_float* tau,
lapack_complex_float* work, lapack_int lwork,
float* rwork );
lapack_int LAPACKE_zgeqp3_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_int* jpvt, lapack_complex_double* tau,
lapack_complex_double* work, lapack_int lwork,
double* rwork );
lapack_int LAPACKE_sgeqpf_work( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, lapack_int* jpvt,
float* tau, float* work );
lapack_int LAPACKE_dgeqpf_work( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, lapack_int* jpvt,
double* tau, double* work );
lapack_int LAPACKE_cgeqpf_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_int* jpvt, lapack_complex_float* tau,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zgeqpf_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_int* jpvt, lapack_complex_double* tau,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_sgeqr2_work( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* tau,
float* work );
lapack_int LAPACKE_dgeqr2_work( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* tau,
double* work );
lapack_int LAPACKE_cgeqr2_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* tau,
lapack_complex_float* work );
lapack_int LAPACKE_zgeqr2_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* tau,
lapack_complex_double* work );
lapack_int LAPACKE_sgeqrf_work( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* tau,
float* work, lapack_int lwork );
lapack_int LAPACKE_dgeqrf_work( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* tau,
double* work, lapack_int lwork );
lapack_int LAPACKE_cgeqrf_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* tau,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zgeqrf_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* tau,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_sgeqrfp_work( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* tau,
float* work, lapack_int lwork );
lapack_int LAPACKE_dgeqrfp_work( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* tau,
double* work, lapack_int lwork );
lapack_int LAPACKE_cgeqrfp_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* tau,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zgeqrfp_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* tau,
lapack_complex_double* work,
lapack_int lwork );
lapack_int LAPACKE_sgerfs_work( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const float* a, lapack_int lda,
const float* af, lapack_int ldaf,
const lapack_int* ipiv, const float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* ferr, float* berr, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dgerfs_work( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const double* a,
lapack_int lda, const double* af,
lapack_int ldaf, const lapack_int* ipiv,
const double* b, lapack_int ldb, double* x,
lapack_int ldx, double* ferr, double* berr,
double* work, lapack_int* iwork );
lapack_int LAPACKE_cgerfs_work( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* af,
lapack_int ldaf, const lapack_int* ipiv,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* ferr, float* berr,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zgerfs_work( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, const lapack_complex_double* af,
lapack_int ldaf, const lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_sgerfsx_work( int matrix_order, char trans, char equed,
lapack_int n, lapack_int nrhs, const float* a,
lapack_int lda, const float* af,
lapack_int ldaf, const lapack_int* ipiv,
const float* r, const float* c, const float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* rcond, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dgerfsx_work( int matrix_order, char trans, char equed,
lapack_int n, lapack_int nrhs, const double* a,
lapack_int lda, const double* af,
lapack_int ldaf, const lapack_int* ipiv,
const double* r, const double* c,
const double* b, lapack_int ldb, double* x,
lapack_int ldx, double* rcond, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params, double* work,
lapack_int* iwork );
lapack_int LAPACKE_cgerfsx_work( int matrix_order, char trans, char equed,
lapack_int n, lapack_int nrhs,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* af,
lapack_int ldaf, const lapack_int* ipiv,
const float* r, const float* c,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params, lapack_complex_float* work,
float* rwork );
lapack_int LAPACKE_zgerfsx_work( int matrix_order, char trans, char equed,
lapack_int n, lapack_int nrhs,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* af,
lapack_int ldaf, const lapack_int* ipiv,
const double* r, const double* c,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params, lapack_complex_double* work,
double* rwork );
lapack_int LAPACKE_sgerqf_work( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* tau,
float* work, lapack_int lwork );
lapack_int LAPACKE_dgerqf_work( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* tau,
double* work, lapack_int lwork );
lapack_int LAPACKE_cgerqf_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* tau,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zgerqf_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* tau,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_sgesdd_work( int matrix_order, char jobz, lapack_int m,
lapack_int n, float* a, lapack_int lda,
float* s, float* u, lapack_int ldu, float* vt,
lapack_int ldvt, float* work, lapack_int lwork,
lapack_int* iwork );
lapack_int LAPACKE_dgesdd_work( int matrix_order, char jobz, lapack_int m,
lapack_int n, double* a, lapack_int lda,
double* s, double* u, lapack_int ldu,
double* vt, lapack_int ldvt, double* work,
lapack_int lwork, lapack_int* iwork );
lapack_int LAPACKE_cgesdd_work( int matrix_order, char jobz, lapack_int m,
lapack_int n, lapack_complex_float* a,
lapack_int lda, float* s,
lapack_complex_float* u, lapack_int ldu,
lapack_complex_float* vt, lapack_int ldvt,
lapack_complex_float* work, lapack_int lwork,
float* rwork, lapack_int* iwork );
lapack_int LAPACKE_zgesdd_work( int matrix_order, char jobz, lapack_int m,
lapack_int n, lapack_complex_double* a,
lapack_int lda, double* s,
lapack_complex_double* u, lapack_int ldu,
lapack_complex_double* vt, lapack_int ldvt,
lapack_complex_double* work, lapack_int lwork,
double* rwork, lapack_int* iwork );
lapack_int LAPACKE_sgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
float* a, lapack_int lda, lapack_int* ipiv,
float* b, lapack_int ldb );
lapack_int LAPACKE_dgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
double* a, lapack_int lda, lapack_int* ipiv,
double* b, lapack_int ldb );
lapack_int LAPACKE_cgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
lapack_complex_float* a, lapack_int lda,
lapack_int* ipiv, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
lapack_complex_double* a, lapack_int lda,
lapack_int* ipiv, lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_dsgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
double* a, lapack_int lda, lapack_int* ipiv,
double* b, lapack_int ldb, double* x,
lapack_int ldx, double* work, float* swork,
lapack_int* iter );
lapack_int LAPACKE_zcgesv_work( int matrix_order, lapack_int n, lapack_int nrhs,
lapack_complex_double* a, lapack_int lda,
lapack_int* ipiv, lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* x,
lapack_int ldx, lapack_complex_double* work,
lapack_complex_float* swork, double* rwork,
lapack_int* iter );
lapack_int LAPACKE_sgesvd_work( int matrix_order, char jobu, char jobvt,
lapack_int m, lapack_int n, float* a,
lapack_int lda, float* s, float* u,
lapack_int ldu, float* vt, lapack_int ldvt,
float* work, lapack_int lwork );
lapack_int LAPACKE_dgesvd_work( int matrix_order, char jobu, char jobvt,
lapack_int m, lapack_int n, double* a,
lapack_int lda, double* s, double* u,
lapack_int ldu, double* vt, lapack_int ldvt,
double* work, lapack_int lwork );
lapack_int LAPACKE_cgesvd_work( int matrix_order, char jobu, char jobvt,
lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
float* s, lapack_complex_float* u,
lapack_int ldu, lapack_complex_float* vt,
lapack_int ldvt, lapack_complex_float* work,
lapack_int lwork, float* rwork );
lapack_int LAPACKE_zgesvd_work( int matrix_order, char jobu, char jobvt,
lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
double* s, lapack_complex_double* u,
lapack_int ldu, lapack_complex_double* vt,
lapack_int ldvt, lapack_complex_double* work,
lapack_int lwork, double* rwork );
lapack_int LAPACKE_sgesvj_work( int matrix_order, char joba, char jobu,
char jobv, lapack_int m, lapack_int n, float* a,
lapack_int lda, float* sva, lapack_int mv,
float* v, lapack_int ldv, float* work,
lapack_int lwork );
lapack_int LAPACKE_dgesvj_work( int matrix_order, char joba, char jobu,
char jobv, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* sva,
lapack_int mv, double* v, lapack_int ldv,
double* work, lapack_int lwork );
lapack_int LAPACKE_sgesvx_work( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs, float* a,
lapack_int lda, float* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, float* r,
float* c, float* b, lapack_int ldb, float* x,
lapack_int ldx, float* rcond, float* ferr,
float* berr, float* work, lapack_int* iwork );
lapack_int LAPACKE_dgesvx_work( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs, double* a,
lapack_int lda, double* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, double* r,
double* c, double* b, lapack_int ldb, double* x,
lapack_int ldx, double* rcond, double* ferr,
double* berr, double* work, lapack_int* iwork );
lapack_int LAPACKE_cgesvx_work( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, float* r,
float* c, lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* x,
lapack_int ldx, float* rcond, float* ferr,
float* berr, lapack_complex_float* work,
float* rwork );
lapack_int LAPACKE_zgesvx_work( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, double* r,
double* c, lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* x,
lapack_int ldx, double* rcond, double* ferr,
double* berr, lapack_complex_double* work,
double* rwork );
lapack_int LAPACKE_sgesvxx_work( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs, float* a,
lapack_int lda, float* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, float* r,
float* c, float* b, lapack_int ldb, float* x,
lapack_int ldx, float* rcond, float* rpvgrw,
float* berr, lapack_int n_err_bnds,
float* err_bnds_norm, float* err_bnds_comp,
lapack_int nparams, float* params, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dgesvxx_work( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs, double* a,
lapack_int lda, double* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, double* r,
double* c, double* b, lapack_int ldb,
double* x, lapack_int ldx, double* rcond,
double* rpvgrw, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params, double* work,
lapack_int* iwork );
lapack_int LAPACKE_cgesvxx_work( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, float* r,
float* c, lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* x,
lapack_int ldx, float* rcond, float* rpvgrw,
float* berr, lapack_int n_err_bnds,
float* err_bnds_norm, float* err_bnds_comp,
lapack_int nparams, float* params,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zgesvxx_work( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, double* r,
double* c, lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* x,
lapack_int ldx, double* rcond, double* rpvgrw,
double* berr, lapack_int n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int nparams, double* params,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_sgetf2_work( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, lapack_int* ipiv );
lapack_int LAPACKE_dgetf2_work( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, lapack_int* ipiv );
lapack_int LAPACKE_cgetf2_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_int* ipiv );
lapack_int LAPACKE_zgetf2_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_int* ipiv );
lapack_int LAPACKE_sgetrf_work( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, lapack_int* ipiv );
lapack_int LAPACKE_dgetrf_work( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, lapack_int* ipiv );
lapack_int LAPACKE_cgetrf_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_int* ipiv );
lapack_int LAPACKE_zgetrf_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_int* ipiv );
lapack_int LAPACKE_sgetri_work( int matrix_order, lapack_int n, float* a,
lapack_int lda, const lapack_int* ipiv,
float* work, lapack_int lwork );
lapack_int LAPACKE_dgetri_work( int matrix_order, lapack_int n, double* a,
lapack_int lda, const lapack_int* ipiv,
double* work, lapack_int lwork );
lapack_int LAPACKE_cgetri_work( int matrix_order, lapack_int n,
lapack_complex_float* a, lapack_int lda,
const lapack_int* ipiv,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zgetri_work( int matrix_order, lapack_int n,
lapack_complex_double* a, lapack_int lda,
const lapack_int* ipiv,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_sgetrs_work( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const float* a, lapack_int lda,
const lapack_int* ipiv, float* b,
lapack_int ldb );
lapack_int LAPACKE_dgetrs_work( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const double* a,
lapack_int lda, const lapack_int* ipiv,
double* b, lapack_int ldb );
lapack_int LAPACKE_cgetrs_work( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zgetrs_work( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_sggbak_work( int matrix_order, char job, char side,
lapack_int n, lapack_int ilo, lapack_int ihi,
const float* lscale, const float* rscale,
lapack_int m, float* v, lapack_int ldv );
lapack_int LAPACKE_dggbak_work( int matrix_order, char job, char side,
lapack_int n, lapack_int ilo, lapack_int ihi,
const double* lscale, const double* rscale,
lapack_int m, double* v, lapack_int ldv );
lapack_int LAPACKE_cggbak_work( int matrix_order, char job, char side,
lapack_int n, lapack_int ilo, lapack_int ihi,
const float* lscale, const float* rscale,
lapack_int m, lapack_complex_float* v,
lapack_int ldv );
lapack_int LAPACKE_zggbak_work( int matrix_order, char job, char side,
lapack_int n, lapack_int ilo, lapack_int ihi,
const double* lscale, const double* rscale,
lapack_int m, lapack_complex_double* v,
lapack_int ldv );
lapack_int LAPACKE_sggbal_work( int matrix_order, char job, lapack_int n,
float* a, lapack_int lda, float* b,
lapack_int ldb, lapack_int* ilo,
lapack_int* ihi, float* lscale, float* rscale,
float* work );
lapack_int LAPACKE_dggbal_work( int matrix_order, char job, lapack_int n,
double* a, lapack_int lda, double* b,
lapack_int ldb, lapack_int* ilo,
lapack_int* ihi, double* lscale, double* rscale,
double* work );
lapack_int LAPACKE_cggbal_work( int matrix_order, char job, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
lapack_int* ilo, lapack_int* ihi, float* lscale,
float* rscale, float* work );
lapack_int LAPACKE_zggbal_work( int matrix_order, char job, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
lapack_int* ilo, lapack_int* ihi,
double* lscale, double* rscale, double* work );
lapack_int LAPACKE_sgges_work( int matrix_order, char jobvsl, char jobvsr,
char sort, LAPACK_S_SELECT3 selctg, lapack_int n,
float* a, lapack_int lda, float* b,
lapack_int ldb, lapack_int* sdim, float* alphar,
float* alphai, float* beta, float* vsl,
lapack_int ldvsl, float* vsr, lapack_int ldvsr,
float* work, lapack_int lwork,
lapack_logical* bwork );
lapack_int LAPACKE_dgges_work( int matrix_order, char jobvsl, char jobvsr,
char sort, LAPACK_D_SELECT3 selctg, lapack_int n,
double* a, lapack_int lda, double* b,
lapack_int ldb, lapack_int* sdim, double* alphar,
double* alphai, double* beta, double* vsl,
lapack_int ldvsl, double* vsr, lapack_int ldvsr,
double* work, lapack_int lwork,
lapack_logical* bwork );
lapack_int LAPACKE_cgges_work( int matrix_order, char jobvsl, char jobvsr,
char sort, LAPACK_C_SELECT2 selctg, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
lapack_int* sdim, lapack_complex_float* alpha,
lapack_complex_float* beta,
lapack_complex_float* vsl, lapack_int ldvsl,
lapack_complex_float* vsr, lapack_int ldvsr,
lapack_complex_float* work, lapack_int lwork,
float* rwork, lapack_logical* bwork );
lapack_int LAPACKE_zgges_work( int matrix_order, char jobvsl, char jobvsr,
char sort, LAPACK_Z_SELECT2 selctg, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
lapack_int* sdim, lapack_complex_double* alpha,
lapack_complex_double* beta,
lapack_complex_double* vsl, lapack_int ldvsl,
lapack_complex_double* vsr, lapack_int ldvsr,
lapack_complex_double* work, lapack_int lwork,
double* rwork, lapack_logical* bwork );
lapack_int LAPACKE_sggesx_work( int matrix_order, char jobvsl, char jobvsr,
char sort, LAPACK_S_SELECT3 selctg, char sense,
lapack_int n, float* a, lapack_int lda,
float* b, lapack_int ldb, lapack_int* sdim,
float* alphar, float* alphai, float* beta,
float* vsl, lapack_int ldvsl, float* vsr,
lapack_int ldvsr, float* rconde, float* rcondv,
float* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork,
lapack_logical* bwork );
lapack_int LAPACKE_dggesx_work( int matrix_order, char jobvsl, char jobvsr,
char sort, LAPACK_D_SELECT3 selctg, char sense,
lapack_int n, double* a, lapack_int lda,
double* b, lapack_int ldb, lapack_int* sdim,
double* alphar, double* alphai, double* beta,
double* vsl, lapack_int ldvsl, double* vsr,
lapack_int ldvsr, double* rconde,
double* rcondv, double* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork,
lapack_logical* bwork );
lapack_int LAPACKE_cggesx_work( int matrix_order, char jobvsl, char jobvsr,
char sort, LAPACK_C_SELECT2 selctg, char sense,
lapack_int n, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb, lapack_int* sdim,
lapack_complex_float* alpha,
lapack_complex_float* beta,
lapack_complex_float* vsl, lapack_int ldvsl,
lapack_complex_float* vsr, lapack_int ldvsr,
float* rconde, float* rcondv,
lapack_complex_float* work, lapack_int lwork,
float* rwork, lapack_int* iwork,
lapack_int liwork, lapack_logical* bwork );
lapack_int LAPACKE_zggesx_work( int matrix_order, char jobvsl, char jobvsr,
char sort, LAPACK_Z_SELECT2 selctg, char sense,
lapack_int n, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb, lapack_int* sdim,
lapack_complex_double* alpha,
lapack_complex_double* beta,
lapack_complex_double* vsl, lapack_int ldvsl,
lapack_complex_double* vsr, lapack_int ldvsr,
double* rconde, double* rcondv,
lapack_complex_double* work, lapack_int lwork,
double* rwork, lapack_int* iwork,
lapack_int liwork, lapack_logical* bwork );
lapack_int LAPACKE_sggev_work( int matrix_order, char jobvl, char jobvr,
lapack_int n, float* a, lapack_int lda, float* b,
lapack_int ldb, float* alphar, float* alphai,
float* beta, float* vl, lapack_int ldvl,
float* vr, lapack_int ldvr, float* work,
lapack_int lwork );
lapack_int LAPACKE_dggev_work( int matrix_order, char jobvl, char jobvr,
lapack_int n, double* a, lapack_int lda,
double* b, lapack_int ldb, double* alphar,
double* alphai, double* beta, double* vl,
lapack_int ldvl, double* vr, lapack_int ldvr,
double* work, lapack_int lwork );
lapack_int LAPACKE_cggev_work( int matrix_order, char jobvl, char jobvr,
lapack_int n, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* alpha,
lapack_complex_float* beta,
lapack_complex_float* vl, lapack_int ldvl,
lapack_complex_float* vr, lapack_int ldvr,
lapack_complex_float* work, lapack_int lwork,
float* rwork );
lapack_int LAPACKE_zggev_work( int matrix_order, char jobvl, char jobvr,
lapack_int n, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* alpha,
lapack_complex_double* beta,
lapack_complex_double* vl, lapack_int ldvl,
lapack_complex_double* vr, lapack_int ldvr,
lapack_complex_double* work, lapack_int lwork,
double* rwork );
lapack_int LAPACKE_sggevx_work( int matrix_order, char balanc, char jobvl,
char jobvr, char sense, lapack_int n, float* a,
lapack_int lda, float* b, lapack_int ldb,
float* alphar, float* alphai, float* beta,
float* vl, lapack_int ldvl, float* vr,
lapack_int ldvr, lapack_int* ilo,
lapack_int* ihi, float* lscale, float* rscale,
float* abnrm, float* bbnrm, float* rconde,
float* rcondv, float* work, lapack_int lwork,
lapack_int* iwork, lapack_logical* bwork );
lapack_int LAPACKE_dggevx_work( int matrix_order, char balanc, char jobvl,
char jobvr, char sense, lapack_int n, double* a,
lapack_int lda, double* b, lapack_int ldb,
double* alphar, double* alphai, double* beta,
double* vl, lapack_int ldvl, double* vr,
lapack_int ldvr, lapack_int* ilo,
lapack_int* ihi, double* lscale, double* rscale,
double* abnrm, double* bbnrm, double* rconde,
double* rcondv, double* work, lapack_int lwork,
lapack_int* iwork, lapack_logical* bwork );
lapack_int LAPACKE_cggevx_work( int matrix_order, char balanc, char jobvl,
char jobvr, char sense, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* alpha,
lapack_complex_float* beta,
lapack_complex_float* vl, lapack_int ldvl,
lapack_complex_float* vr, lapack_int ldvr,
lapack_int* ilo, lapack_int* ihi, float* lscale,
float* rscale, float* abnrm, float* bbnrm,
float* rconde, float* rcondv,
lapack_complex_float* work, lapack_int lwork,
float* rwork, lapack_int* iwork,
lapack_logical* bwork );
lapack_int LAPACKE_zggevx_work( int matrix_order, char balanc, char jobvl,
char jobvr, char sense, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* alpha,
lapack_complex_double* beta,
lapack_complex_double* vl, lapack_int ldvl,
lapack_complex_double* vr, lapack_int ldvr,
lapack_int* ilo, lapack_int* ihi,
double* lscale, double* rscale, double* abnrm,
double* bbnrm, double* rconde, double* rcondv,
lapack_complex_double* work, lapack_int lwork,
double* rwork, lapack_int* iwork,
lapack_logical* bwork );
lapack_int LAPACKE_sggglm_work( int matrix_order, lapack_int n, lapack_int m,
lapack_int p, float* a, lapack_int lda,
float* b, lapack_int ldb, float* d, float* x,
float* y, float* work, lapack_int lwork );
lapack_int LAPACKE_dggglm_work( int matrix_order, lapack_int n, lapack_int m,
lapack_int p, double* a, lapack_int lda,
double* b, lapack_int ldb, double* d, double* x,
double* y, double* work, lapack_int lwork );
lapack_int LAPACKE_cggglm_work( int matrix_order, lapack_int n, lapack_int m,
lapack_int p, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* d,
lapack_complex_float* x,
lapack_complex_float* y,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zggglm_work( int matrix_order, lapack_int n, lapack_int m,
lapack_int p, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* d,
lapack_complex_double* x,
lapack_complex_double* y,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_sgghrd_work( int matrix_order, char compq, char compz,
lapack_int n, lapack_int ilo, lapack_int ihi,
float* a, lapack_int lda, float* b,
lapack_int ldb, float* q, lapack_int ldq,
float* z, lapack_int ldz );
lapack_int LAPACKE_dgghrd_work( int matrix_order, char compq, char compz,
lapack_int n, lapack_int ilo, lapack_int ihi,
double* a, lapack_int lda, double* b,
lapack_int ldb, double* q, lapack_int ldq,
double* z, lapack_int ldz );
lapack_int LAPACKE_cgghrd_work( int matrix_order, char compq, char compz,
lapack_int n, lapack_int ilo, lapack_int ihi,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* q, lapack_int ldq,
lapack_complex_float* z, lapack_int ldz );
lapack_int LAPACKE_zgghrd_work( int matrix_order, char compq, char compz,
lapack_int n, lapack_int ilo, lapack_int ihi,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* q, lapack_int ldq,
lapack_complex_double* z, lapack_int ldz );
lapack_int LAPACKE_sgglse_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int p, float* a, lapack_int lda,
float* b, lapack_int ldb, float* c, float* d,
float* x, float* work, lapack_int lwork );
lapack_int LAPACKE_dgglse_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int p, double* a, lapack_int lda,
double* b, lapack_int ldb, double* c, double* d,
double* x, double* work, lapack_int lwork );
lapack_int LAPACKE_cgglse_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int p, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* c,
lapack_complex_float* d,
lapack_complex_float* x,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zgglse_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int p, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* c,
lapack_complex_double* d,
lapack_complex_double* x,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_sggqrf_work( int matrix_order, lapack_int n, lapack_int m,
lapack_int p, float* a, lapack_int lda,
float* taua, float* b, lapack_int ldb,
float* taub, float* work, lapack_int lwork );
lapack_int LAPACKE_dggqrf_work( int matrix_order, lapack_int n, lapack_int m,
lapack_int p, double* a, lapack_int lda,
double* taua, double* b, lapack_int ldb,
double* taub, double* work, lapack_int lwork );
lapack_int LAPACKE_cggqrf_work( int matrix_order, lapack_int n, lapack_int m,
lapack_int p, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* taua,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* taub,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zggqrf_work( int matrix_order, lapack_int n, lapack_int m,
lapack_int p, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* taua,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* taub,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_sggrqf_work( int matrix_order, lapack_int m, lapack_int p,
lapack_int n, float* a, lapack_int lda,
float* taua, float* b, lapack_int ldb,
float* taub, float* work, lapack_int lwork );
lapack_int LAPACKE_dggrqf_work( int matrix_order, lapack_int m, lapack_int p,
lapack_int n, double* a, lapack_int lda,
double* taua, double* b, lapack_int ldb,
double* taub, double* work, lapack_int lwork );
lapack_int LAPACKE_cggrqf_work( int matrix_order, lapack_int m, lapack_int p,
lapack_int n, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* taua,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* taub,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zggrqf_work( int matrix_order, lapack_int m, lapack_int p,
lapack_int n, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* taua,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* taub,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_sggsvd_work( int matrix_order, char jobu, char jobv,
char jobq, lapack_int m, lapack_int n,
lapack_int p, lapack_int* k, lapack_int* l,
float* a, lapack_int lda, float* b,
lapack_int ldb, float* alpha, float* beta,
float* u, lapack_int ldu, float* v,
lapack_int ldv, float* q, lapack_int ldq,
float* work, lapack_int* iwork );
lapack_int LAPACKE_dggsvd_work( int matrix_order, char jobu, char jobv,
char jobq, lapack_int m, lapack_int n,
lapack_int p, lapack_int* k, lapack_int* l,
double* a, lapack_int lda, double* b,
lapack_int ldb, double* alpha, double* beta,
double* u, lapack_int ldu, double* v,
lapack_int ldv, double* q, lapack_int ldq,
double* work, lapack_int* iwork );
lapack_int LAPACKE_cggsvd_work( int matrix_order, char jobu, char jobv,
char jobq, lapack_int m, lapack_int n,
lapack_int p, lapack_int* k, lapack_int* l,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
float* alpha, float* beta,
lapack_complex_float* u, lapack_int ldu,
lapack_complex_float* v, lapack_int ldv,
lapack_complex_float* q, lapack_int ldq,
lapack_complex_float* work, float* rwork,
lapack_int* iwork );
lapack_int LAPACKE_zggsvd_work( int matrix_order, char jobu, char jobv,
char jobq, lapack_int m, lapack_int n,
lapack_int p, lapack_int* k, lapack_int* l,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
double* alpha, double* beta,
lapack_complex_double* u, lapack_int ldu,
lapack_complex_double* v, lapack_int ldv,
lapack_complex_double* q, lapack_int ldq,
lapack_complex_double* work, double* rwork,
lapack_int* iwork );
lapack_int LAPACKE_sggsvp_work( int matrix_order, char jobu, char jobv,
char jobq, lapack_int m, lapack_int p,
lapack_int n, float* a, lapack_int lda,
float* b, lapack_int ldb, float tola,
float tolb, lapack_int* k, lapack_int* l,
float* u, lapack_int ldu, float* v,
lapack_int ldv, float* q, lapack_int ldq,
lapack_int* iwork, float* tau, float* work );
lapack_int LAPACKE_dggsvp_work( int matrix_order, char jobu, char jobv,
char jobq, lapack_int m, lapack_int p,
lapack_int n, double* a, lapack_int lda,
double* b, lapack_int ldb, double tola,
double tolb, lapack_int* k, lapack_int* l,
double* u, lapack_int ldu, double* v,
lapack_int ldv, double* q, lapack_int ldq,
lapack_int* iwork, double* tau, double* work );
lapack_int LAPACKE_cggsvp_work( int matrix_order, char jobu, char jobv,
char jobq, lapack_int m, lapack_int p,
lapack_int n, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb, float tola, float tolb,
lapack_int* k, lapack_int* l,
lapack_complex_float* u, lapack_int ldu,
lapack_complex_float* v, lapack_int ldv,
lapack_complex_float* q, lapack_int ldq,
lapack_int* iwork, float* rwork,
lapack_complex_float* tau,
lapack_complex_float* work );
lapack_int LAPACKE_zggsvp_work( int matrix_order, char jobu, char jobv,
char jobq, lapack_int m, lapack_int p,
lapack_int n, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb, double tola, double tolb,
lapack_int* k, lapack_int* l,
lapack_complex_double* u, lapack_int ldu,
lapack_complex_double* v, lapack_int ldv,
lapack_complex_double* q, lapack_int ldq,
lapack_int* iwork, double* rwork,
lapack_complex_double* tau,
lapack_complex_double* work );
lapack_int LAPACKE_sgtcon_work( char norm, lapack_int n, const float* dl,
const float* d, const float* du,
const float* du2, const lapack_int* ipiv,
float anorm, float* rcond, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dgtcon_work( char norm, lapack_int n, const double* dl,
const double* d, const double* du,
const double* du2, const lapack_int* ipiv,
double anorm, double* rcond, double* work,
lapack_int* iwork );
lapack_int LAPACKE_cgtcon_work( char norm, lapack_int n,
const lapack_complex_float* dl,
const lapack_complex_float* d,
const lapack_complex_float* du,
const lapack_complex_float* du2,
const lapack_int* ipiv, float anorm,
float* rcond, lapack_complex_float* work );
lapack_int LAPACKE_zgtcon_work( char norm, lapack_int n,
const lapack_complex_double* dl,
const lapack_complex_double* d,
const lapack_complex_double* du,
const lapack_complex_double* du2,
const lapack_int* ipiv, double anorm,
double* rcond, lapack_complex_double* work );
lapack_int LAPACKE_sgtrfs_work( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const float* dl,
const float* d, const float* du,
const float* dlf, const float* df,
const float* duf, const float* du2,
const lapack_int* ipiv, const float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* ferr, float* berr, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dgtrfs_work( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const double* dl,
const double* d, const double* du,
const double* dlf, const double* df,
const double* duf, const double* du2,
const lapack_int* ipiv, const double* b,
lapack_int ldb, double* x, lapack_int ldx,
double* ferr, double* berr, double* work,
lapack_int* iwork );
lapack_int LAPACKE_cgtrfs_work( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const lapack_complex_float* dl,
const lapack_complex_float* d,
const lapack_complex_float* du,
const lapack_complex_float* dlf,
const lapack_complex_float* df,
const lapack_complex_float* duf,
const lapack_complex_float* du2,
const lapack_int* ipiv,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* ferr, float* berr,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zgtrfs_work( int matrix_order, char trans, lapack_int n,
lapack_int nrhs,
const lapack_complex_double* dl,
const lapack_complex_double* d,
const lapack_complex_double* du,
const lapack_complex_double* dlf,
const lapack_complex_double* df,
const lapack_complex_double* duf,
const lapack_complex_double* du2,
const lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_sgtsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
float* dl, float* d, float* du, float* b,
lapack_int ldb );
lapack_int LAPACKE_dgtsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
double* dl, double* d, double* du, double* b,
lapack_int ldb );
lapack_int LAPACKE_cgtsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
lapack_complex_float* dl,
lapack_complex_float* d,
lapack_complex_float* du,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zgtsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
lapack_complex_double* dl,
lapack_complex_double* d,
lapack_complex_double* du,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_sgtsvx_work( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs, const float* dl,
const float* d, const float* du, float* dlf,
float* df, float* duf, float* du2,
lapack_int* ipiv, const float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* rcond, float* ferr, float* berr,
float* work, lapack_int* iwork );
lapack_int LAPACKE_dgtsvx_work( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs, const double* dl,
const double* d, const double* du, double* dlf,
double* df, double* duf, double* du2,
lapack_int* ipiv, const double* b,
lapack_int ldb, double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr,
double* work, lapack_int* iwork );
lapack_int LAPACKE_cgtsvx_work( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs,
const lapack_complex_float* dl,
const lapack_complex_float* d,
const lapack_complex_float* du,
lapack_complex_float* dlf,
lapack_complex_float* df,
lapack_complex_float* duf,
lapack_complex_float* du2, lapack_int* ipiv,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* ferr, float* berr,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zgtsvx_work( int matrix_order, char fact, char trans,
lapack_int n, lapack_int nrhs,
const lapack_complex_double* dl,
const lapack_complex_double* d,
const lapack_complex_double* du,
lapack_complex_double* dlf,
lapack_complex_double* df,
lapack_complex_double* duf,
lapack_complex_double* du2, lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_sgttrf_work( lapack_int n, float* dl, float* d, float* du,
float* du2, lapack_int* ipiv );
lapack_int LAPACKE_dgttrf_work( lapack_int n, double* dl, double* d, double* du,
double* du2, lapack_int* ipiv );
lapack_int LAPACKE_cgttrf_work( lapack_int n, lapack_complex_float* dl,
lapack_complex_float* d,
lapack_complex_float* du,
lapack_complex_float* du2, lapack_int* ipiv );
lapack_int LAPACKE_zgttrf_work( lapack_int n, lapack_complex_double* dl,
lapack_complex_double* d,
lapack_complex_double* du,
lapack_complex_double* du2, lapack_int* ipiv );
lapack_int LAPACKE_sgttrs_work( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const float* dl,
const float* d, const float* du,
const float* du2, const lapack_int* ipiv,
float* b, lapack_int ldb );
lapack_int LAPACKE_dgttrs_work( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const double* dl,
const double* d, const double* du,
const double* du2, const lapack_int* ipiv,
double* b, lapack_int ldb );
lapack_int LAPACKE_cgttrs_work( int matrix_order, char trans, lapack_int n,
lapack_int nrhs, const lapack_complex_float* dl,
const lapack_complex_float* d,
const lapack_complex_float* du,
const lapack_complex_float* du2,
const lapack_int* ipiv, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zgttrs_work( int matrix_order, char trans, lapack_int n,
lapack_int nrhs,
const lapack_complex_double* dl,
const lapack_complex_double* d,
const lapack_complex_double* du,
const lapack_complex_double* du2,
const lapack_int* ipiv,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_chbev_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_int kd,
lapack_complex_float* ab, lapack_int ldab,
float* w, lapack_complex_float* z,
lapack_int ldz, lapack_complex_float* work,
float* rwork );
lapack_int LAPACKE_zhbev_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_int kd,
lapack_complex_double* ab, lapack_int ldab,
double* w, lapack_complex_double* z,
lapack_int ldz, lapack_complex_double* work,
double* rwork );
lapack_int LAPACKE_chbevd_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_int kd,
lapack_complex_float* ab, lapack_int ldab,
float* w, lapack_complex_float* z,
lapack_int ldz, lapack_complex_float* work,
lapack_int lwork, float* rwork,
lapack_int lrwork, lapack_int* iwork,
lapack_int liwork );
lapack_int LAPACKE_zhbevd_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_int kd,
lapack_complex_double* ab, lapack_int ldab,
double* w, lapack_complex_double* z,
lapack_int ldz, lapack_complex_double* work,
lapack_int lwork, double* rwork,
lapack_int lrwork, lapack_int* iwork,
lapack_int liwork );
lapack_int LAPACKE_chbevx_work( int matrix_order, char jobz, char range,
char uplo, lapack_int n, lapack_int kd,
lapack_complex_float* ab, lapack_int ldab,
lapack_complex_float* q, lapack_int ldq,
float vl, float vu, lapack_int il,
lapack_int iu, float abstol, lapack_int* m,
float* w, lapack_complex_float* z,
lapack_int ldz, lapack_complex_float* work,
float* rwork, lapack_int* iwork,
lapack_int* ifail );
lapack_int LAPACKE_zhbevx_work( int matrix_order, char jobz, char range,
char uplo, lapack_int n, lapack_int kd,
lapack_complex_double* ab, lapack_int ldab,
lapack_complex_double* q, lapack_int ldq,
double vl, double vu, lapack_int il,
lapack_int iu, double abstol, lapack_int* m,
double* w, lapack_complex_double* z,
lapack_int ldz, lapack_complex_double* work,
double* rwork, lapack_int* iwork,
lapack_int* ifail );
lapack_int LAPACKE_chbgst_work( int matrix_order, char vect, char uplo,
lapack_int n, lapack_int ka, lapack_int kb,
lapack_complex_float* ab, lapack_int ldab,
const lapack_complex_float* bb, lapack_int ldbb,
lapack_complex_float* x, lapack_int ldx,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zhbgst_work( int matrix_order, char vect, char uplo,
lapack_int n, lapack_int ka, lapack_int kb,
lapack_complex_double* ab, lapack_int ldab,
const lapack_complex_double* bb,
lapack_int ldbb, lapack_complex_double* x,
lapack_int ldx, lapack_complex_double* work,
double* rwork );
lapack_int LAPACKE_chbgv_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_int ka, lapack_int kb,
lapack_complex_float* ab, lapack_int ldab,
lapack_complex_float* bb, lapack_int ldbb,
float* w, lapack_complex_float* z,
lapack_int ldz, lapack_complex_float* work,
float* rwork );
lapack_int LAPACKE_zhbgv_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_int ka, lapack_int kb,
lapack_complex_double* ab, lapack_int ldab,
lapack_complex_double* bb, lapack_int ldbb,
double* w, lapack_complex_double* z,
lapack_int ldz, lapack_complex_double* work,
double* rwork );
lapack_int LAPACKE_chbgvd_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_int ka, lapack_int kb,
lapack_complex_float* ab, lapack_int ldab,
lapack_complex_float* bb, lapack_int ldbb,
float* w, lapack_complex_float* z,
lapack_int ldz, lapack_complex_float* work,
lapack_int lwork, float* rwork,
lapack_int lrwork, lapack_int* iwork,
lapack_int liwork );
lapack_int LAPACKE_zhbgvd_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_int ka, lapack_int kb,
lapack_complex_double* ab, lapack_int ldab,
lapack_complex_double* bb, lapack_int ldbb,
double* w, lapack_complex_double* z,
lapack_int ldz, lapack_complex_double* work,
lapack_int lwork, double* rwork,
lapack_int lrwork, lapack_int* iwork,
lapack_int liwork );
lapack_int LAPACKE_chbgvx_work( int matrix_order, char jobz, char range,
char uplo, lapack_int n, lapack_int ka,
lapack_int kb, lapack_complex_float* ab,
lapack_int ldab, lapack_complex_float* bb,
lapack_int ldbb, lapack_complex_float* q,
lapack_int ldq, float vl, float vu,
lapack_int il, lapack_int iu, float abstol,
lapack_int* m, float* w,
lapack_complex_float* z, lapack_int ldz,
lapack_complex_float* work, float* rwork,
lapack_int* iwork, lapack_int* ifail );
lapack_int LAPACKE_zhbgvx_work( int matrix_order, char jobz, char range,
char uplo, lapack_int n, lapack_int ka,
lapack_int kb, lapack_complex_double* ab,
lapack_int ldab, lapack_complex_double* bb,
lapack_int ldbb, lapack_complex_double* q,
lapack_int ldq, double vl, double vu,
lapack_int il, lapack_int iu, double abstol,
lapack_int* m, double* w,
lapack_complex_double* z, lapack_int ldz,
lapack_complex_double* work, double* rwork,
lapack_int* iwork, lapack_int* ifail );
lapack_int LAPACKE_chbtrd_work( int matrix_order, char vect, char uplo,
lapack_int n, lapack_int kd,
lapack_complex_float* ab, lapack_int ldab,
float* d, float* e, lapack_complex_float* q,
lapack_int ldq, lapack_complex_float* work );
lapack_int LAPACKE_zhbtrd_work( int matrix_order, char vect, char uplo,
lapack_int n, lapack_int kd,
lapack_complex_double* ab, lapack_int ldab,
double* d, double* e, lapack_complex_double* q,
lapack_int ldq, lapack_complex_double* work );
lapack_int LAPACKE_checon_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
const lapack_int* ipiv, float anorm,
float* rcond, lapack_complex_float* work );
lapack_int LAPACKE_zhecon_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
const lapack_int* ipiv, double anorm,
double* rcond, lapack_complex_double* work );
lapack_int LAPACKE_cheequb_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
float* s, float* scond, float* amax,
lapack_complex_float* work );
lapack_int LAPACKE_zheequb_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
double* s, double* scond, double* amax,
lapack_complex_double* work );
lapack_int LAPACKE_cheev_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_complex_float* a,
lapack_int lda, float* w,
lapack_complex_float* work, lapack_int lwork,
float* rwork );
lapack_int LAPACKE_zheev_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_complex_double* a,
lapack_int lda, double* w,
lapack_complex_double* work, lapack_int lwork,
double* rwork );
lapack_int LAPACKE_cheevd_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_complex_float* a,
lapack_int lda, float* w,
lapack_complex_float* work, lapack_int lwork,
float* rwork, lapack_int lrwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_zheevd_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_complex_double* a,
lapack_int lda, double* w,
lapack_complex_double* work, lapack_int lwork,
double* rwork, lapack_int lrwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_cheevr_work( int matrix_order, char jobz, char range,
char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
float vl, float vu, lapack_int il,
lapack_int iu, float abstol, lapack_int* m,
float* w, lapack_complex_float* z,
lapack_int ldz, lapack_int* isuppz,
lapack_complex_float* work, lapack_int lwork,
float* rwork, lapack_int lrwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_zheevr_work( int matrix_order, char jobz, char range,
char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
double vl, double vu, lapack_int il,
lapack_int iu, double abstol, lapack_int* m,
double* w, lapack_complex_double* z,
lapack_int ldz, lapack_int* isuppz,
lapack_complex_double* work, lapack_int lwork,
double* rwork, lapack_int lrwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_cheevx_work( int matrix_order, char jobz, char range,
char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
float vl, float vu, lapack_int il,
lapack_int iu, float abstol, lapack_int* m,
float* w, lapack_complex_float* z,
lapack_int ldz, lapack_complex_float* work,
lapack_int lwork, float* rwork,
lapack_int* iwork, lapack_int* ifail );
lapack_int LAPACKE_zheevx_work( int matrix_order, char jobz, char range,
char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
double vl, double vu, lapack_int il,
lapack_int iu, double abstol, lapack_int* m,
double* w, lapack_complex_double* z,
lapack_int ldz, lapack_complex_double* work,
lapack_int lwork, double* rwork,
lapack_int* iwork, lapack_int* ifail );
lapack_int LAPACKE_chegst_work( int matrix_order, lapack_int itype, char uplo,
lapack_int n, lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zhegst_work( int matrix_order, lapack_int itype, char uplo,
lapack_int n, lapack_complex_double* a,
lapack_int lda, const lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_chegv_work( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb, float* w,
lapack_complex_float* work, lapack_int lwork,
float* rwork );
lapack_int LAPACKE_zhegv_work( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
double* w, lapack_complex_double* work,
lapack_int lwork, double* rwork );
lapack_int LAPACKE_chegvd_work( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
float* w, lapack_complex_float* work,
lapack_int lwork, float* rwork,
lapack_int lrwork, lapack_int* iwork,
lapack_int liwork );
lapack_int LAPACKE_zhegvd_work( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
double* w, lapack_complex_double* work,
lapack_int lwork, double* rwork,
lapack_int lrwork, lapack_int* iwork,
lapack_int liwork );
lapack_int LAPACKE_chegvx_work( int matrix_order, lapack_int itype, char jobz,
char range, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
float vl, float vu, lapack_int il,
lapack_int iu, float abstol, lapack_int* m,
float* w, lapack_complex_float* z,
lapack_int ldz, lapack_complex_float* work,
lapack_int lwork, float* rwork,
lapack_int* iwork, lapack_int* ifail );
lapack_int LAPACKE_zhegvx_work( int matrix_order, lapack_int itype, char jobz,
char range, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
double vl, double vu, lapack_int il,
lapack_int iu, double abstol, lapack_int* m,
double* w, lapack_complex_double* z,
lapack_int ldz, lapack_complex_double* work,
lapack_int lwork, double* rwork,
lapack_int* iwork, lapack_int* ifail );
lapack_int LAPACKE_cherfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* af,
lapack_int ldaf, const lapack_int* ipiv,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* ferr, float* berr,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zherfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, const lapack_complex_double* af,
lapack_int ldaf, const lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_cherfsx_work( int matrix_order, char uplo, char equed,
lapack_int n, lapack_int nrhs,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* af,
lapack_int ldaf, const lapack_int* ipiv,
const float* s, const lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* x,
lapack_int ldx, float* rcond, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params, lapack_complex_float* work,
float* rwork );
lapack_int LAPACKE_zherfsx_work( int matrix_order, char uplo, char equed,
lapack_int n, lapack_int nrhs,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* af,
lapack_int ldaf, const lapack_int* ipiv,
const double* s,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params, lapack_complex_double* work,
double* rwork );
lapack_int LAPACKE_chesv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_float* a,
lapack_int lda, lapack_int* ipiv,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zhesv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_double* a,
lapack_int lda, lapack_int* ipiv,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_chesvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
const lapack_complex_float* a, lapack_int lda,
lapack_complex_float* af, lapack_int ldaf,
lapack_int* ipiv, const lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* x,
lapack_int ldx, float* rcond, float* ferr,
float* berr, lapack_complex_float* work,
lapack_int lwork, float* rwork );
lapack_int LAPACKE_zhesvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
const lapack_complex_double* a, lapack_int lda,
lapack_complex_double* af, lapack_int ldaf,
lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr,
lapack_complex_double* work, lapack_int lwork,
double* rwork );
lapack_int LAPACKE_chesvxx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, float* s,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* rpvgrw, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params, lapack_complex_float* work,
float* rwork );
lapack_int LAPACKE_zhesvxx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, double* s,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* rpvgrw, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params, lapack_complex_double* work,
double* rwork );
lapack_int LAPACKE_chetrd_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
float* d, float* e, lapack_complex_float* tau,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zhetrd_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
double* d, double* e,
lapack_complex_double* tau,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_chetrf_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_int* ipiv, lapack_complex_float* work,
lapack_int lwork );
lapack_int LAPACKE_zhetrf_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_int* ipiv, lapack_complex_double* work,
lapack_int lwork );
lapack_int LAPACKE_chetri_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
const lapack_int* ipiv,
lapack_complex_float* work );
lapack_int LAPACKE_zhetri_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
const lapack_int* ipiv,
lapack_complex_double* work );
lapack_int LAPACKE_chetrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zhetrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_chfrk_work( int matrix_order, char transr, char uplo,
char trans, lapack_int n, lapack_int k,
float alpha, const lapack_complex_float* a,
lapack_int lda, float beta,
lapack_complex_float* c );
lapack_int LAPACKE_zhfrk_work( int matrix_order, char transr, char uplo,
char trans, lapack_int n, lapack_int k,
double alpha, const lapack_complex_double* a,
lapack_int lda, double beta,
lapack_complex_double* c );
lapack_int LAPACKE_shgeqz_work( int matrix_order, char job, char compq,
char compz, lapack_int n, lapack_int ilo,
lapack_int ihi, float* h, lapack_int ldh,
float* t, lapack_int ldt, float* alphar,
float* alphai, float* beta, float* q,
lapack_int ldq, float* z, lapack_int ldz,
float* work, lapack_int lwork );
lapack_int LAPACKE_dhgeqz_work( int matrix_order, char job, char compq,
char compz, lapack_int n, lapack_int ilo,
lapack_int ihi, double* h, lapack_int ldh,
double* t, lapack_int ldt, double* alphar,
double* alphai, double* beta, double* q,
lapack_int ldq, double* z, lapack_int ldz,
double* work, lapack_int lwork );
lapack_int LAPACKE_chgeqz_work( int matrix_order, char job, char compq,
char compz, lapack_int n, lapack_int ilo,
lapack_int ihi, lapack_complex_float* h,
lapack_int ldh, lapack_complex_float* t,
lapack_int ldt, lapack_complex_float* alpha,
lapack_complex_float* beta,
lapack_complex_float* q, lapack_int ldq,
lapack_complex_float* z, lapack_int ldz,
lapack_complex_float* work, lapack_int lwork,
float* rwork );
lapack_int LAPACKE_zhgeqz_work( int matrix_order, char job, char compq,
char compz, lapack_int n, lapack_int ilo,
lapack_int ihi, lapack_complex_double* h,
lapack_int ldh, lapack_complex_double* t,
lapack_int ldt, lapack_complex_double* alpha,
lapack_complex_double* beta,
lapack_complex_double* q, lapack_int ldq,
lapack_complex_double* z, lapack_int ldz,
lapack_complex_double* work, lapack_int lwork,
double* rwork );
lapack_int LAPACKE_chpcon_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* ap,
const lapack_int* ipiv, float anorm,
float* rcond, lapack_complex_float* work );
lapack_int LAPACKE_zhpcon_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* ap,
const lapack_int* ipiv, double anorm,
double* rcond, lapack_complex_double* work );
lapack_int LAPACKE_chpev_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_complex_float* ap, float* w,
lapack_complex_float* z, lapack_int ldz,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zhpev_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_complex_double* ap,
double* w, lapack_complex_double* z,
lapack_int ldz, lapack_complex_double* work,
double* rwork );
lapack_int LAPACKE_chpevd_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_complex_float* ap,
float* w, lapack_complex_float* z,
lapack_int ldz, lapack_complex_float* work,
lapack_int lwork, float* rwork,
lapack_int lrwork, lapack_int* iwork,
lapack_int liwork );
lapack_int LAPACKE_zhpevd_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_complex_double* ap,
double* w, lapack_complex_double* z,
lapack_int ldz, lapack_complex_double* work,
lapack_int lwork, double* rwork,
lapack_int lrwork, lapack_int* iwork,
lapack_int liwork );
lapack_int LAPACKE_chpevx_work( int matrix_order, char jobz, char range,
char uplo, lapack_int n,
lapack_complex_float* ap, float vl, float vu,
lapack_int il, lapack_int iu, float abstol,
lapack_int* m, float* w,
lapack_complex_float* z, lapack_int ldz,
lapack_complex_float* work, float* rwork,
lapack_int* iwork, lapack_int* ifail );
lapack_int LAPACKE_zhpevx_work( int matrix_order, char jobz, char range,
char uplo, lapack_int n,
lapack_complex_double* ap, double vl, double vu,
lapack_int il, lapack_int iu, double abstol,
lapack_int* m, double* w,
lapack_complex_double* z, lapack_int ldz,
lapack_complex_double* work, double* rwork,
lapack_int* iwork, lapack_int* ifail );
lapack_int LAPACKE_chpgst_work( int matrix_order, lapack_int itype, char uplo,
lapack_int n, lapack_complex_float* ap,
const lapack_complex_float* bp );
lapack_int LAPACKE_zhpgst_work( int matrix_order, lapack_int itype, char uplo,
lapack_int n, lapack_complex_double* ap,
const lapack_complex_double* bp );
lapack_int LAPACKE_chpgv_work( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n,
lapack_complex_float* ap,
lapack_complex_float* bp, float* w,
lapack_complex_float* z, lapack_int ldz,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zhpgv_work( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n,
lapack_complex_double* ap,
lapack_complex_double* bp, double* w,
lapack_complex_double* z, lapack_int ldz,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_chpgvd_work( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n,
lapack_complex_float* ap,
lapack_complex_float* bp, float* w,
lapack_complex_float* z, lapack_int ldz,
lapack_complex_float* work, lapack_int lwork,
float* rwork, lapack_int lrwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_zhpgvd_work( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n,
lapack_complex_double* ap,
lapack_complex_double* bp, double* w,
lapack_complex_double* z, lapack_int ldz,
lapack_complex_double* work, lapack_int lwork,
double* rwork, lapack_int lrwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_chpgvx_work( int matrix_order, lapack_int itype, char jobz,
char range, char uplo, lapack_int n,
lapack_complex_float* ap,
lapack_complex_float* bp, float vl, float vu,
lapack_int il, lapack_int iu, float abstol,
lapack_int* m, float* w,
lapack_complex_float* z, lapack_int ldz,
lapack_complex_float* work, float* rwork,
lapack_int* iwork, lapack_int* ifail );
lapack_int LAPACKE_zhpgvx_work( int matrix_order, lapack_int itype, char jobz,
char range, char uplo, lapack_int n,
lapack_complex_double* ap,
lapack_complex_double* bp, double vl, double vu,
lapack_int il, lapack_int iu, double abstol,
lapack_int* m, double* w,
lapack_complex_double* z, lapack_int ldz,
lapack_complex_double* work, double* rwork,
lapack_int* iwork, lapack_int* ifail );
lapack_int LAPACKE_chprfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* ap,
const lapack_complex_float* afp,
const lapack_int* ipiv,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* ferr, float* berr,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zhprfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs,
const lapack_complex_double* ap,
const lapack_complex_double* afp,
const lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_chpsv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_float* ap,
lapack_int* ipiv, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zhpsv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_double* ap,
lapack_int* ipiv, lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_chpsvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
const lapack_complex_float* ap,
lapack_complex_float* afp, lapack_int* ipiv,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* ferr, float* berr,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zhpsvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
const lapack_complex_double* ap,
lapack_complex_double* afp, lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_chptrd_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* ap, float* d, float* e,
lapack_complex_float* tau );
lapack_int LAPACKE_zhptrd_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* ap, double* d, double* e,
lapack_complex_double* tau );
lapack_int LAPACKE_chptrf_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* ap, lapack_int* ipiv );
lapack_int LAPACKE_zhptrf_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* ap, lapack_int* ipiv );
lapack_int LAPACKE_chptri_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* ap,
const lapack_int* ipiv,
lapack_complex_float* work );
lapack_int LAPACKE_zhptri_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* ap,
const lapack_int* ipiv,
lapack_complex_double* work );
lapack_int LAPACKE_chptrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* ap,
const lapack_int* ipiv, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zhptrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs,
const lapack_complex_double* ap,
const lapack_int* ipiv,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_shsein_work( int matrix_order, char job, char eigsrc,
char initv, lapack_logical* select,
lapack_int n, const float* h, lapack_int ldh,
float* wr, const float* wi, float* vl,
lapack_int ldvl, float* vr, lapack_int ldvr,
lapack_int mm, lapack_int* m, float* work,
lapack_int* ifaill, lapack_int* ifailr );
lapack_int LAPACKE_dhsein_work( int matrix_order, char job, char eigsrc,
char initv, lapack_logical* select,
lapack_int n, const double* h, lapack_int ldh,
double* wr, const double* wi, double* vl,
lapack_int ldvl, double* vr, lapack_int ldvr,
lapack_int mm, lapack_int* m, double* work,
lapack_int* ifaill, lapack_int* ifailr );
lapack_int LAPACKE_chsein_work( int matrix_order, char job, char eigsrc,
char initv, const lapack_logical* select,
lapack_int n, const lapack_complex_float* h,
lapack_int ldh, lapack_complex_float* w,
lapack_complex_float* vl, lapack_int ldvl,
lapack_complex_float* vr, lapack_int ldvr,
lapack_int mm, lapack_int* m,
lapack_complex_float* work, float* rwork,
lapack_int* ifaill, lapack_int* ifailr );
lapack_int LAPACKE_zhsein_work( int matrix_order, char job, char eigsrc,
char initv, const lapack_logical* select,
lapack_int n, const lapack_complex_double* h,
lapack_int ldh, lapack_complex_double* w,
lapack_complex_double* vl, lapack_int ldvl,
lapack_complex_double* vr, lapack_int ldvr,
lapack_int mm, lapack_int* m,
lapack_complex_double* work, double* rwork,
lapack_int* ifaill, lapack_int* ifailr );
lapack_int LAPACKE_shseqr_work( int matrix_order, char job, char compz,
lapack_int n, lapack_int ilo, lapack_int ihi,
float* h, lapack_int ldh, float* wr, float* wi,
float* z, lapack_int ldz, float* work,
lapack_int lwork );
lapack_int LAPACKE_dhseqr_work( int matrix_order, char job, char compz,
lapack_int n, lapack_int ilo, lapack_int ihi,
double* h, lapack_int ldh, double* wr,
double* wi, double* z, lapack_int ldz,
double* work, lapack_int lwork );
lapack_int LAPACKE_chseqr_work( int matrix_order, char job, char compz,
lapack_int n, lapack_int ilo, lapack_int ihi,
lapack_complex_float* h, lapack_int ldh,
lapack_complex_float* w,
lapack_complex_float* z, lapack_int ldz,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zhseqr_work( int matrix_order, char job, char compz,
lapack_int n, lapack_int ilo, lapack_int ihi,
lapack_complex_double* h, lapack_int ldh,
lapack_complex_double* w,
lapack_complex_double* z, lapack_int ldz,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_clacgv_work( lapack_int n, lapack_complex_float* x,
lapack_int incx );
lapack_int LAPACKE_zlacgv_work( lapack_int n, lapack_complex_double* x,
lapack_int incx );
lapack_int LAPACKE_slacpy_work( int matrix_order, char uplo, lapack_int m,
lapack_int n, const float* a, lapack_int lda,
float* b, lapack_int ldb );
lapack_int LAPACKE_dlacpy_work( int matrix_order, char uplo, lapack_int m,
lapack_int n, const double* a, lapack_int lda,
double* b, lapack_int ldb );
lapack_int LAPACKE_clacpy_work( int matrix_order, char uplo, lapack_int m,
lapack_int n, const lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zlacpy_work( int matrix_order, char uplo, lapack_int m,
lapack_int n, const lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_zlag2c_work( int matrix_order, lapack_int m, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
lapack_complex_float* sa, lapack_int ldsa );
lapack_int LAPACKE_slag2d_work( int matrix_order, lapack_int m, lapack_int n,
const float* sa, lapack_int ldsa, double* a,
lapack_int lda );
lapack_int LAPACKE_dlag2s_work( int matrix_order, lapack_int m, lapack_int n,
const double* a, lapack_int lda, float* sa,
lapack_int ldsa );
lapack_int LAPACKE_clag2z_work( int matrix_order, lapack_int m, lapack_int n,
const lapack_complex_float* sa, lapack_int ldsa,
lapack_complex_double* a, lapack_int lda );
lapack_int LAPACKE_slagge_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku, const float* d,
float* a, lapack_int lda, lapack_int* iseed,
float* work );
lapack_int LAPACKE_dlagge_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku, const double* d,
double* a, lapack_int lda, lapack_int* iseed,
double* work );
lapack_int LAPACKE_clagge_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku, const float* d,
lapack_complex_float* a, lapack_int lda,
lapack_int* iseed, lapack_complex_float* work );
lapack_int LAPACKE_zlagge_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int kl, lapack_int ku, const double* d,
lapack_complex_double* a, lapack_int lda,
lapack_int* iseed,
lapack_complex_double* work );
lapack_int LAPACKE_claghe_work( int matrix_order, lapack_int n, lapack_int k,
const float* d, lapack_complex_float* a,
lapack_int lda, lapack_int* iseed,
lapack_complex_float* work );
lapack_int LAPACKE_zlaghe_work( int matrix_order, lapack_int n, lapack_int k,
const double* d, lapack_complex_double* a,
lapack_int lda, lapack_int* iseed,
lapack_complex_double* work );
lapack_int LAPACKE_slagsy_work( int matrix_order, lapack_int n, lapack_int k,
const float* d, float* a, lapack_int lda,
lapack_int* iseed, float* work );
lapack_int LAPACKE_dlagsy_work( int matrix_order, lapack_int n, lapack_int k,
const double* d, double* a, lapack_int lda,
lapack_int* iseed, double* work );
lapack_int LAPACKE_clagsy_work( int matrix_order, lapack_int n, lapack_int k,
const float* d, lapack_complex_float* a,
lapack_int lda, lapack_int* iseed,
lapack_complex_float* work );
lapack_int LAPACKE_zlagsy_work( int matrix_order, lapack_int n, lapack_int k,
const double* d, lapack_complex_double* a,
lapack_int lda, lapack_int* iseed,
lapack_complex_double* work );
lapack_int LAPACKE_slapmr_work( int matrix_order, lapack_logical forwrd,
lapack_int m, lapack_int n, float* x,
lapack_int ldx, lapack_int* k );
lapack_int LAPACKE_dlapmr_work( int matrix_order, lapack_logical forwrd,
lapack_int m, lapack_int n, double* x,
lapack_int ldx, lapack_int* k );
lapack_int LAPACKE_clapmr_work( int matrix_order, lapack_logical forwrd,
lapack_int m, lapack_int n,
lapack_complex_float* x, lapack_int ldx,
lapack_int* k );
lapack_int LAPACKE_zlapmr_work( int matrix_order, lapack_logical forwrd,
lapack_int m, lapack_int n,
lapack_complex_double* x, lapack_int ldx,
lapack_int* k );
lapack_int LAPACKE_slartgp_work( float f, float g, float* cs, float* sn,
float* r );
lapack_int LAPACKE_dlartgp_work( double f, double g, double* cs, double* sn,
double* r );
lapack_int LAPACKE_slartgs_work( float x, float y, float sigma, float* cs,
float* sn );
lapack_int LAPACKE_dlartgs_work( double x, double y, double sigma, double* cs,
double* sn );
float LAPACKE_slapy2_work( float x, float y );
double LAPACKE_dlapy2_work( double x, double y );
float LAPACKE_slapy3_work( float x, float y, float z );
double LAPACKE_dlapy3_work( double x, double y, double z );
float LAPACKE_slamch_work( char cmach );
double LAPACKE_dlamch_work( char cmach );
float LAPACKE_slange_work( int matrix_order, char norm, lapack_int m,
lapack_int n, const float* a, lapack_int lda,
float* work );
double LAPACKE_dlange_work( int matrix_order, char norm, lapack_int m,
lapack_int n, const double* a, lapack_int lda,
double* work );
float LAPACKE_clange_work( int matrix_order, char norm, lapack_int m,
lapack_int n, const lapack_complex_float* a,
lapack_int lda, float* work );
double LAPACKE_zlange_work( int matrix_order, char norm, lapack_int m,
lapack_int n, const lapack_complex_double* a,
lapack_int lda, double* work );
float LAPACKE_clanhe_work( int matrix_order, char norm, char uplo,
lapack_int n, const lapack_complex_float* a,
lapack_int lda, float* work );
double LAPACKE_zlanhe_work( int matrix_order, char norm, char uplo,
lapack_int n, const lapack_complex_double* a,
lapack_int lda, double* work );
float LAPACKE_slansy_work( int matrix_order, char norm, char uplo,
lapack_int n, const float* a, lapack_int lda,
float* work );
double LAPACKE_dlansy_work( int matrix_order, char norm, char uplo,
lapack_int n, const double* a, lapack_int lda,
double* work );
float LAPACKE_clansy_work( int matrix_order, char norm, char uplo,
lapack_int n, const lapack_complex_float* a,
lapack_int lda, float* work );
double LAPACKE_zlansy_work( int matrix_order, char norm, char uplo,
lapack_int n, const lapack_complex_double* a,
lapack_int lda, double* work );
float LAPACKE_slantr_work( int matrix_order, char norm, char uplo,
char diag, lapack_int m, lapack_int n, const float* a,
lapack_int lda, float* work );
double LAPACKE_dlantr_work( int matrix_order, char norm, char uplo,
char diag, lapack_int m, lapack_int n,
const double* a, lapack_int lda, double* work );
float LAPACKE_clantr_work( int matrix_order, char norm, char uplo,
char diag, lapack_int m, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
float* work );
double LAPACKE_zlantr_work( int matrix_order, char norm, char uplo,
char diag, lapack_int m, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
double* work );
lapack_int LAPACKE_slarfb_work( int matrix_order, char side, char trans,
char direct, char storev, lapack_int m,
lapack_int n, lapack_int k, const float* v,
lapack_int ldv, const float* t, lapack_int ldt,
float* c, lapack_int ldc, float* work,
lapack_int ldwork );
lapack_int LAPACKE_dlarfb_work( int matrix_order, char side, char trans,
char direct, char storev, lapack_int m,
lapack_int n, lapack_int k, const double* v,
lapack_int ldv, const double* t, lapack_int ldt,
double* c, lapack_int ldc, double* work,
lapack_int ldwork );
lapack_int LAPACKE_clarfb_work( int matrix_order, char side, char trans,
char direct, char storev, lapack_int m,
lapack_int n, lapack_int k,
const lapack_complex_float* v, lapack_int ldv,
const lapack_complex_float* t, lapack_int ldt,
lapack_complex_float* c, lapack_int ldc,
lapack_complex_float* work, lapack_int ldwork );
lapack_int LAPACKE_zlarfb_work( int matrix_order, char side, char trans,
char direct, char storev, lapack_int m,
lapack_int n, lapack_int k,
const lapack_complex_double* v, lapack_int ldv,
const lapack_complex_double* t, lapack_int ldt,
lapack_complex_double* c, lapack_int ldc,
lapack_complex_double* work,
lapack_int ldwork );
lapack_int LAPACKE_slarfg_work( lapack_int n, float* alpha, float* x,
lapack_int incx, float* tau );
lapack_int LAPACKE_dlarfg_work( lapack_int n, double* alpha, double* x,
lapack_int incx, double* tau );
lapack_int LAPACKE_clarfg_work( lapack_int n, lapack_complex_float* alpha,
lapack_complex_float* x, lapack_int incx,
lapack_complex_float* tau );
lapack_int LAPACKE_zlarfg_work( lapack_int n, lapack_complex_double* alpha,
lapack_complex_double* x, lapack_int incx,
lapack_complex_double* tau );
lapack_int LAPACKE_slarft_work( int matrix_order, char direct, char storev,
lapack_int n, lapack_int k, const float* v,
lapack_int ldv, const float* tau, float* t,
lapack_int ldt );
lapack_int LAPACKE_dlarft_work( int matrix_order, char direct, char storev,
lapack_int n, lapack_int k, const double* v,
lapack_int ldv, const double* tau, double* t,
lapack_int ldt );
lapack_int LAPACKE_clarft_work( int matrix_order, char direct, char storev,
lapack_int n, lapack_int k,
const lapack_complex_float* v, lapack_int ldv,
const lapack_complex_float* tau,
lapack_complex_float* t, lapack_int ldt );
lapack_int LAPACKE_zlarft_work( int matrix_order, char direct, char storev,
lapack_int n, lapack_int k,
const lapack_complex_double* v, lapack_int ldv,
const lapack_complex_double* tau,
lapack_complex_double* t, lapack_int ldt );
lapack_int LAPACKE_slarfx_work( int matrix_order, char side, lapack_int m,
lapack_int n, const float* v, float tau,
float* c, lapack_int ldc, float* work );
lapack_int LAPACKE_dlarfx_work( int matrix_order, char side, lapack_int m,
lapack_int n, const double* v, double tau,
double* c, lapack_int ldc, double* work );
lapack_int LAPACKE_clarfx_work( int matrix_order, char side, lapack_int m,
lapack_int n, const lapack_complex_float* v,
lapack_complex_float tau,
lapack_complex_float* c, lapack_int ldc,
lapack_complex_float* work );
lapack_int LAPACKE_zlarfx_work( int matrix_order, char side, lapack_int m,
lapack_int n, const lapack_complex_double* v,
lapack_complex_double tau,
lapack_complex_double* c, lapack_int ldc,
lapack_complex_double* work );
lapack_int LAPACKE_slarnv_work( lapack_int idist, lapack_int* iseed,
lapack_int n, float* x );
lapack_int LAPACKE_dlarnv_work( lapack_int idist, lapack_int* iseed,
lapack_int n, double* x );
lapack_int LAPACKE_clarnv_work( lapack_int idist, lapack_int* iseed,
lapack_int n, lapack_complex_float* x );
lapack_int LAPACKE_zlarnv_work( lapack_int idist, lapack_int* iseed,
lapack_int n, lapack_complex_double* x );
lapack_int LAPACKE_slaset_work( int matrix_order, char uplo, lapack_int m,
lapack_int n, float alpha, float beta, float* a,
lapack_int lda );
lapack_int LAPACKE_dlaset_work( int matrix_order, char uplo, lapack_int m,
lapack_int n, double alpha, double beta,
double* a, lapack_int lda );
lapack_int LAPACKE_claset_work( int matrix_order, char uplo, lapack_int m,
lapack_int n, lapack_complex_float alpha,
lapack_complex_float beta,
lapack_complex_float* a, lapack_int lda );
lapack_int LAPACKE_zlaset_work( int matrix_order, char uplo, lapack_int m,
lapack_int n, lapack_complex_double alpha,
lapack_complex_double beta,
lapack_complex_double* a, lapack_int lda );
lapack_int LAPACKE_slasrt_work( char id, lapack_int n, float* d );
lapack_int LAPACKE_dlasrt_work( char id, lapack_int n, double* d );
lapack_int LAPACKE_slaswp_work( int matrix_order, lapack_int n, float* a,
lapack_int lda, lapack_int k1, lapack_int k2,
const lapack_int* ipiv, lapack_int incx );
lapack_int LAPACKE_dlaswp_work( int matrix_order, lapack_int n, double* a,
lapack_int lda, lapack_int k1, lapack_int k2,
const lapack_int* ipiv, lapack_int incx );
lapack_int LAPACKE_claswp_work( int matrix_order, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_int k1, lapack_int k2,
const lapack_int* ipiv, lapack_int incx );
lapack_int LAPACKE_zlaswp_work( int matrix_order, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_int k1, lapack_int k2,
const lapack_int* ipiv, lapack_int incx );
lapack_int LAPACKE_slatms_work( int matrix_order, lapack_int m, lapack_int n,
char dist, lapack_int* iseed, char sym,
float* d, lapack_int mode, float cond,
float dmax, lapack_int kl, lapack_int ku,
char pack, float* a, lapack_int lda,
float* work );
lapack_int LAPACKE_dlatms_work( int matrix_order, lapack_int m, lapack_int n,
char dist, lapack_int* iseed, char sym,
double* d, lapack_int mode, double cond,
double dmax, lapack_int kl, lapack_int ku,
char pack, double* a, lapack_int lda,
double* work );
lapack_int LAPACKE_clatms_work( int matrix_order, lapack_int m, lapack_int n,
char dist, lapack_int* iseed, char sym,
float* d, lapack_int mode, float cond,
float dmax, lapack_int kl, lapack_int ku,
char pack, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* work );
lapack_int LAPACKE_zlatms_work( int matrix_order, lapack_int m, lapack_int n,
char dist, lapack_int* iseed, char sym,
double* d, lapack_int mode, double cond,
double dmax, lapack_int kl, lapack_int ku,
char pack, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* work );
lapack_int LAPACKE_slauum_work( int matrix_order, char uplo, lapack_int n,
float* a, lapack_int lda );
lapack_int LAPACKE_dlauum_work( int matrix_order, char uplo, lapack_int n,
double* a, lapack_int lda );
lapack_int LAPACKE_clauum_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda );
lapack_int LAPACKE_zlauum_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda );
lapack_int LAPACKE_sopgtr_work( int matrix_order, char uplo, lapack_int n,
const float* ap, const float* tau, float* q,
lapack_int ldq, float* work );
lapack_int LAPACKE_dopgtr_work( int matrix_order, char uplo, lapack_int n,
const double* ap, const double* tau, double* q,
lapack_int ldq, double* work );
lapack_int LAPACKE_sopmtr_work( int matrix_order, char side, char uplo,
char trans, lapack_int m, lapack_int n,
const float* ap, const float* tau, float* c,
lapack_int ldc, float* work );
lapack_int LAPACKE_dopmtr_work( int matrix_order, char side, char uplo,
char trans, lapack_int m, lapack_int n,
const double* ap, const double* tau, double* c,
lapack_int ldc, double* work );
lapack_int LAPACKE_sorgbr_work( int matrix_order, char vect, lapack_int m,
lapack_int n, lapack_int k, float* a,
lapack_int lda, const float* tau, float* work,
lapack_int lwork );
lapack_int LAPACKE_dorgbr_work( int matrix_order, char vect, lapack_int m,
lapack_int n, lapack_int k, double* a,
lapack_int lda, const double* tau, double* work,
lapack_int lwork );
lapack_int LAPACKE_sorghr_work( int matrix_order, lapack_int n, lapack_int ilo,
lapack_int ihi, float* a, lapack_int lda,
const float* tau, float* work,
lapack_int lwork );
lapack_int LAPACKE_dorghr_work( int matrix_order, lapack_int n, lapack_int ilo,
lapack_int ihi, double* a, lapack_int lda,
const double* tau, double* work,
lapack_int lwork );
lapack_int LAPACKE_sorglq_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, float* a, lapack_int lda,
const float* tau, float* work,
lapack_int lwork );
lapack_int LAPACKE_dorglq_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, double* a, lapack_int lda,
const double* tau, double* work,
lapack_int lwork );
lapack_int LAPACKE_sorgql_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, float* a, lapack_int lda,
const float* tau, float* work,
lapack_int lwork );
lapack_int LAPACKE_dorgql_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, double* a, lapack_int lda,
const double* tau, double* work,
lapack_int lwork );
lapack_int LAPACKE_sorgqr_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, float* a, lapack_int lda,
const float* tau, float* work,
lapack_int lwork );
lapack_int LAPACKE_dorgqr_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, double* a, lapack_int lda,
const double* tau, double* work,
lapack_int lwork );
lapack_int LAPACKE_sorgrq_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, float* a, lapack_int lda,
const float* tau, float* work,
lapack_int lwork );
lapack_int LAPACKE_dorgrq_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, double* a, lapack_int lda,
const double* tau, double* work,
lapack_int lwork );
lapack_int LAPACKE_sorgtr_work( int matrix_order, char uplo, lapack_int n,
float* a, lapack_int lda, const float* tau,
float* work, lapack_int lwork );
lapack_int LAPACKE_dorgtr_work( int matrix_order, char uplo, lapack_int n,
double* a, lapack_int lda, const double* tau,
double* work, lapack_int lwork );
lapack_int LAPACKE_sormbr_work( int matrix_order, char vect, char side,
char trans, lapack_int m, lapack_int n,
lapack_int k, const float* a, lapack_int lda,
const float* tau, float* c, lapack_int ldc,
float* work, lapack_int lwork );
lapack_int LAPACKE_dormbr_work( int matrix_order, char vect, char side,
char trans, lapack_int m, lapack_int n,
lapack_int k, const double* a, lapack_int lda,
const double* tau, double* c, lapack_int ldc,
double* work, lapack_int lwork );
lapack_int LAPACKE_sormhr_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int ilo,
lapack_int ihi, const float* a, lapack_int lda,
const float* tau, float* c, lapack_int ldc,
float* work, lapack_int lwork );
lapack_int LAPACKE_dormhr_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int ilo,
lapack_int ihi, const double* a, lapack_int lda,
const double* tau, double* c, lapack_int ldc,
double* work, lapack_int lwork );
lapack_int LAPACKE_sormlq_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const float* a, lapack_int lda,
const float* tau, float* c, lapack_int ldc,
float* work, lapack_int lwork );
lapack_int LAPACKE_dormlq_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const double* a, lapack_int lda,
const double* tau, double* c, lapack_int ldc,
double* work, lapack_int lwork );
lapack_int LAPACKE_sormql_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const float* a, lapack_int lda,
const float* tau, float* c, lapack_int ldc,
float* work, lapack_int lwork );
lapack_int LAPACKE_dormql_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const double* a, lapack_int lda,
const double* tau, double* c, lapack_int ldc,
double* work, lapack_int lwork );
lapack_int LAPACKE_sormqr_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const float* a, lapack_int lda,
const float* tau, float* c, lapack_int ldc,
float* work, lapack_int lwork );
lapack_int LAPACKE_dormqr_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const double* a, lapack_int lda,
const double* tau, double* c, lapack_int ldc,
double* work, lapack_int lwork );
lapack_int LAPACKE_sormrq_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const float* a, lapack_int lda,
const float* tau, float* c, lapack_int ldc,
float* work, lapack_int lwork );
lapack_int LAPACKE_dormrq_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const double* a, lapack_int lda,
const double* tau, double* c, lapack_int ldc,
double* work, lapack_int lwork );
lapack_int LAPACKE_sormrz_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int l, const float* a, lapack_int lda,
const float* tau, float* c, lapack_int ldc,
float* work, lapack_int lwork );
lapack_int LAPACKE_dormrz_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int l, const double* a, lapack_int lda,
const double* tau, double* c, lapack_int ldc,
double* work, lapack_int lwork );
lapack_int LAPACKE_sormtr_work( int matrix_order, char side, char uplo,
char trans, lapack_int m, lapack_int n,
const float* a, lapack_int lda,
const float* tau, float* c, lapack_int ldc,
float* work, lapack_int lwork );
lapack_int LAPACKE_dormtr_work( int matrix_order, char side, char uplo,
char trans, lapack_int m, lapack_int n,
const double* a, lapack_int lda,
const double* tau, double* c, lapack_int ldc,
double* work, lapack_int lwork );
lapack_int LAPACKE_spbcon_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, const float* ab, lapack_int ldab,
float anorm, float* rcond, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dpbcon_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, const double* ab,
lapack_int ldab, double anorm, double* rcond,
double* work, lapack_int* iwork );
lapack_int LAPACKE_cpbcon_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, const lapack_complex_float* ab,
lapack_int ldab, float anorm, float* rcond,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zpbcon_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, const lapack_complex_double* ab,
lapack_int ldab, double anorm, double* rcond,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_spbequ_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, const float* ab, lapack_int ldab,
float* s, float* scond, float* amax );
lapack_int LAPACKE_dpbequ_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, const double* ab,
lapack_int ldab, double* s, double* scond,
double* amax );
lapack_int LAPACKE_cpbequ_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, const lapack_complex_float* ab,
lapack_int ldab, float* s, float* scond,
float* amax );
lapack_int LAPACKE_zpbequ_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, const lapack_complex_double* ab,
lapack_int ldab, double* s, double* scond,
double* amax );
lapack_int LAPACKE_spbrfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs, const float* ab,
lapack_int ldab, const float* afb,
lapack_int ldafb, const float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* ferr, float* berr, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dpbrfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs,
const double* ab, lapack_int ldab,
const double* afb, lapack_int ldafb,
const double* b, lapack_int ldb, double* x,
lapack_int ldx, double* ferr, double* berr,
double* work, lapack_int* iwork );
lapack_int LAPACKE_cpbrfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs,
const lapack_complex_float* ab, lapack_int ldab,
const lapack_complex_float* afb,
lapack_int ldafb, const lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* x,
lapack_int ldx, float* ferr, float* berr,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zpbrfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs,
const lapack_complex_double* ab,
lapack_int ldab,
const lapack_complex_double* afb,
lapack_int ldafb,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_spbstf_work( int matrix_order, char uplo, lapack_int n,
lapack_int kb, float* bb, lapack_int ldbb );
lapack_int LAPACKE_dpbstf_work( int matrix_order, char uplo, lapack_int n,
lapack_int kb, double* bb, lapack_int ldbb );
lapack_int LAPACKE_cpbstf_work( int matrix_order, char uplo, lapack_int n,
lapack_int kb, lapack_complex_float* bb,
lapack_int ldbb );
lapack_int LAPACKE_zpbstf_work( int matrix_order, char uplo, lapack_int n,
lapack_int kb, lapack_complex_double* bb,
lapack_int ldbb );
lapack_int LAPACKE_spbsv_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs, float* ab,
lapack_int ldab, float* b, lapack_int ldb );
lapack_int LAPACKE_dpbsv_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs, double* ab,
lapack_int ldab, double* b, lapack_int ldb );
lapack_int LAPACKE_cpbsv_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs,
lapack_complex_float* ab, lapack_int ldab,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zpbsv_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs,
lapack_complex_double* ab, lapack_int ldab,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_spbsvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int kd, lapack_int nrhs,
float* ab, lapack_int ldab, float* afb,
lapack_int ldafb, char* equed, float* s,
float* b, lapack_int ldb, float* x,
lapack_int ldx, float* rcond, float* ferr,
float* berr, float* work, lapack_int* iwork );
lapack_int LAPACKE_dpbsvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int kd, lapack_int nrhs,
double* ab, lapack_int ldab, double* afb,
lapack_int ldafb, char* equed, double* s,
double* b, lapack_int ldb, double* x,
lapack_int ldx, double* rcond, double* ferr,
double* berr, double* work, lapack_int* iwork );
lapack_int LAPACKE_cpbsvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int kd, lapack_int nrhs,
lapack_complex_float* ab, lapack_int ldab,
lapack_complex_float* afb, lapack_int ldafb,
char* equed, float* s, lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* x,
lapack_int ldx, float* rcond, float* ferr,
float* berr, lapack_complex_float* work,
float* rwork );
lapack_int LAPACKE_zpbsvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int kd, lapack_int nrhs,
lapack_complex_double* ab, lapack_int ldab,
lapack_complex_double* afb, lapack_int ldafb,
char* equed, double* s,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_spbtrf_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, float* ab, lapack_int ldab );
lapack_int LAPACKE_dpbtrf_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, double* ab, lapack_int ldab );
lapack_int LAPACKE_cpbtrf_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_complex_float* ab,
lapack_int ldab );
lapack_int LAPACKE_zpbtrf_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_complex_double* ab,
lapack_int ldab );
lapack_int LAPACKE_spbtrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs, const float* ab,
lapack_int ldab, float* b, lapack_int ldb );
lapack_int LAPACKE_dpbtrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs,
const double* ab, lapack_int ldab, double* b,
lapack_int ldb );
lapack_int LAPACKE_cpbtrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs,
const lapack_complex_float* ab, lapack_int ldab,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zpbtrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int kd, lapack_int nrhs,
const lapack_complex_double* ab,
lapack_int ldab, lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_spftrf_work( int matrix_order, char transr, char uplo,
lapack_int n, float* a );
lapack_int LAPACKE_dpftrf_work( int matrix_order, char transr, char uplo,
lapack_int n, double* a );
lapack_int LAPACKE_cpftrf_work( int matrix_order, char transr, char uplo,
lapack_int n, lapack_complex_float* a );
lapack_int LAPACKE_zpftrf_work( int matrix_order, char transr, char uplo,
lapack_int n, lapack_complex_double* a );
lapack_int LAPACKE_spftri_work( int matrix_order, char transr, char uplo,
lapack_int n, float* a );
lapack_int LAPACKE_dpftri_work( int matrix_order, char transr, char uplo,
lapack_int n, double* a );
lapack_int LAPACKE_cpftri_work( int matrix_order, char transr, char uplo,
lapack_int n, lapack_complex_float* a );
lapack_int LAPACKE_zpftri_work( int matrix_order, char transr, char uplo,
lapack_int n, lapack_complex_double* a );
lapack_int LAPACKE_spftrs_work( int matrix_order, char transr, char uplo,
lapack_int n, lapack_int nrhs, const float* a,
float* b, lapack_int ldb );
lapack_int LAPACKE_dpftrs_work( int matrix_order, char transr, char uplo,
lapack_int n, lapack_int nrhs, const double* a,
double* b, lapack_int ldb );
lapack_int LAPACKE_cpftrs_work( int matrix_order, char transr, char uplo,
lapack_int n, lapack_int nrhs,
const lapack_complex_float* a,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zpftrs_work( int matrix_order, char transr, char uplo,
lapack_int n, lapack_int nrhs,
const lapack_complex_double* a,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_spocon_work( int matrix_order, char uplo, lapack_int n,
const float* a, lapack_int lda, float anorm,
float* rcond, float* work, lapack_int* iwork );
lapack_int LAPACKE_dpocon_work( int matrix_order, char uplo, lapack_int n,
const double* a, lapack_int lda, double anorm,
double* rcond, double* work,
lapack_int* iwork );
lapack_int LAPACKE_cpocon_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
float anorm, float* rcond,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zpocon_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
double anorm, double* rcond,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_spoequ_work( int matrix_order, lapack_int n, const float* a,
lapack_int lda, float* s, float* scond,
float* amax );
lapack_int LAPACKE_dpoequ_work( int matrix_order, lapack_int n, const double* a,
lapack_int lda, double* s, double* scond,
double* amax );
lapack_int LAPACKE_cpoequ_work( int matrix_order, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
float* s, float* scond, float* amax );
lapack_int LAPACKE_zpoequ_work( int matrix_order, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
double* s, double* scond, double* amax );
lapack_int LAPACKE_spoequb_work( int matrix_order, lapack_int n, const float* a,
lapack_int lda, float* s, float* scond,
float* amax );
lapack_int LAPACKE_dpoequb_work( int matrix_order, lapack_int n,
const double* a, lapack_int lda, double* s,
double* scond, double* amax );
lapack_int LAPACKE_cpoequb_work( int matrix_order, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
float* s, float* scond, float* amax );
lapack_int LAPACKE_zpoequb_work( int matrix_order, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
double* s, double* scond, double* amax );
lapack_int LAPACKE_sporfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* a, lapack_int lda,
const float* af, lapack_int ldaf,
const float* b, lapack_int ldb, float* x,
lapack_int ldx, float* ferr, float* berr,
float* work, lapack_int* iwork );
lapack_int LAPACKE_dporfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* a,
lapack_int lda, const double* af,
lapack_int ldaf, const double* b,
lapack_int ldb, double* x, lapack_int ldx,
double* ferr, double* berr, double* work,
lapack_int* iwork );
lapack_int LAPACKE_cporfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* af,
lapack_int ldaf, const lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* x,
lapack_int ldx, float* ferr, float* berr,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zporfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, const lapack_complex_double* af,
lapack_int ldaf, const lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* x,
lapack_int ldx, double* ferr, double* berr,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_sporfsx_work( int matrix_order, char uplo, char equed,
lapack_int n, lapack_int nrhs, const float* a,
lapack_int lda, const float* af,
lapack_int ldaf, const float* s,
const float* b, lapack_int ldb, float* x,
lapack_int ldx, float* rcond, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dporfsx_work( int matrix_order, char uplo, char equed,
lapack_int n, lapack_int nrhs, const double* a,
lapack_int lda, const double* af,
lapack_int ldaf, const double* s,
const double* b, lapack_int ldb, double* x,
lapack_int ldx, double* rcond, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params, double* work,
lapack_int* iwork );
lapack_int LAPACKE_cporfsx_work( int matrix_order, char uplo, char equed,
lapack_int n, lapack_int nrhs,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* af,
lapack_int ldaf, const float* s,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params, lapack_complex_float* work,
float* rwork );
lapack_int LAPACKE_zporfsx_work( int matrix_order, char uplo, char equed,
lapack_int n, lapack_int nrhs,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* af,
lapack_int ldaf, const double* s,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params, lapack_complex_double* work,
double* rwork );
lapack_int LAPACKE_sposv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, float* a, lapack_int lda,
float* b, lapack_int ldb );
lapack_int LAPACKE_dposv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, double* a, lapack_int lda,
double* b, lapack_int ldb );
lapack_int LAPACKE_cposv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zposv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_dsposv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, double* a, lapack_int lda,
double* b, lapack_int ldb, double* x,
lapack_int ldx, double* work, float* swork,
lapack_int* iter );
lapack_int LAPACKE_zcposv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* x,
lapack_int ldx, lapack_complex_double* work,
lapack_complex_float* swork, double* rwork,
lapack_int* iter );
lapack_int LAPACKE_sposvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs, float* a,
lapack_int lda, float* af, lapack_int ldaf,
char* equed, float* s, float* b, lapack_int ldb,
float* x, lapack_int ldx, float* rcond,
float* ferr, float* berr, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dposvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs, double* a,
lapack_int lda, double* af, lapack_int ldaf,
char* equed, double* s, double* b,
lapack_int ldb, double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr,
double* work, lapack_int* iwork );
lapack_int LAPACKE_cposvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* af, lapack_int ldaf,
char* equed, float* s, lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* x,
lapack_int ldx, float* rcond, float* ferr,
float* berr, lapack_complex_float* work,
float* rwork );
lapack_int LAPACKE_zposvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* af, lapack_int ldaf,
char* equed, double* s,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_sposvxx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs, float* a,
lapack_int lda, float* af, lapack_int ldaf,
char* equed, float* s, float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* rcond, float* rpvgrw, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dposvxx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs, double* a,
lapack_int lda, double* af, lapack_int ldaf,
char* equed, double* s, double* b,
lapack_int ldb, double* x, lapack_int ldx,
double* rcond, double* rpvgrw, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params, double* work,
lapack_int* iwork );
lapack_int LAPACKE_cposvxx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* af, lapack_int ldaf,
char* equed, float* s, lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* x,
lapack_int ldx, float* rcond, float* rpvgrw,
float* berr, lapack_int n_err_bnds,
float* err_bnds_norm, float* err_bnds_comp,
lapack_int nparams, float* params,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zposvxx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* af, lapack_int ldaf,
char* equed, double* s,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* rpvgrw, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params, lapack_complex_double* work,
double* rwork );
lapack_int LAPACKE_spotrf_work( int matrix_order, char uplo, lapack_int n,
float* a, lapack_int lda );
lapack_int LAPACKE_dpotrf_work( int matrix_order, char uplo, lapack_int n,
double* a, lapack_int lda );
lapack_int LAPACKE_cpotrf_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda );
lapack_int LAPACKE_zpotrf_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda );
lapack_int LAPACKE_spotri_work( int matrix_order, char uplo, lapack_int n,
float* a, lapack_int lda );
lapack_int LAPACKE_dpotri_work( int matrix_order, char uplo, lapack_int n,
double* a, lapack_int lda );
lapack_int LAPACKE_cpotri_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda );
lapack_int LAPACKE_zpotri_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda );
lapack_int LAPACKE_spotrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* a, lapack_int lda,
float* b, lapack_int ldb );
lapack_int LAPACKE_dpotrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* a,
lapack_int lda, double* b, lapack_int ldb );
lapack_int LAPACKE_cpotrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zpotrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_sppcon_work( int matrix_order, char uplo, lapack_int n,
const float* ap, float anorm, float* rcond,
float* work, lapack_int* iwork );
lapack_int LAPACKE_dppcon_work( int matrix_order, char uplo, lapack_int n,
const double* ap, double anorm, double* rcond,
double* work, lapack_int* iwork );
lapack_int LAPACKE_cppcon_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* ap, float anorm,
float* rcond, lapack_complex_float* work,
float* rwork );
lapack_int LAPACKE_zppcon_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* ap, double anorm,
double* rcond, lapack_complex_double* work,
double* rwork );
lapack_int LAPACKE_sppequ_work( int matrix_order, char uplo, lapack_int n,
const float* ap, float* s, float* scond,
float* amax );
lapack_int LAPACKE_dppequ_work( int matrix_order, char uplo, lapack_int n,
const double* ap, double* s, double* scond,
double* amax );
lapack_int LAPACKE_cppequ_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* ap, float* s,
float* scond, float* amax );
lapack_int LAPACKE_zppequ_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* ap, double* s,
double* scond, double* amax );
lapack_int LAPACKE_spprfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* ap,
const float* afp, const float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* ferr, float* berr, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dpprfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* ap,
const double* afp, const double* b,
lapack_int ldb, double* x, lapack_int ldx,
double* ferr, double* berr, double* work,
lapack_int* iwork );
lapack_int LAPACKE_cpprfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* ap,
const lapack_complex_float* afp,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* ferr, float* berr,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zpprfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs,
const lapack_complex_double* ap,
const lapack_complex_double* afp,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_sppsv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, float* ap, float* b,
lapack_int ldb );
lapack_int LAPACKE_dppsv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, double* ap, double* b,
lapack_int ldb );
lapack_int LAPACKE_cppsv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_float* ap,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zppsv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_double* ap,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_sppsvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs, float* ap,
float* afp, char* equed, float* s, float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* rcond, float* ferr, float* berr,
float* work, lapack_int* iwork );
lapack_int LAPACKE_dppsvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs, double* ap,
double* afp, char* equed, double* s, double* b,
lapack_int ldb, double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr,
double* work, lapack_int* iwork );
lapack_int LAPACKE_cppsvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
lapack_complex_float* ap,
lapack_complex_float* afp, char* equed,
float* s, lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* x,
lapack_int ldx, float* rcond, float* ferr,
float* berr, lapack_complex_float* work,
float* rwork );
lapack_int LAPACKE_zppsvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
lapack_complex_double* ap,
lapack_complex_double* afp, char* equed,
double* s, lapack_complex_double* b,
lapack_int ldb, lapack_complex_double* x,
lapack_int ldx, double* rcond, double* ferr,
double* berr, lapack_complex_double* work,
double* rwork );
lapack_int LAPACKE_spptrf_work( int matrix_order, char uplo, lapack_int n,
float* ap );
lapack_int LAPACKE_dpptrf_work( int matrix_order, char uplo, lapack_int n,
double* ap );
lapack_int LAPACKE_cpptrf_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* ap );
lapack_int LAPACKE_zpptrf_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* ap );
lapack_int LAPACKE_spptri_work( int matrix_order, char uplo, lapack_int n,
float* ap );
lapack_int LAPACKE_dpptri_work( int matrix_order, char uplo, lapack_int n,
double* ap );
lapack_int LAPACKE_cpptri_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* ap );
lapack_int LAPACKE_zpptri_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* ap );
lapack_int LAPACKE_spptrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* ap, float* b,
lapack_int ldb );
lapack_int LAPACKE_dpptrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* ap, double* b,
lapack_int ldb );
lapack_int LAPACKE_cpptrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* ap,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zpptrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs,
const lapack_complex_double* ap,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_spstrf_work( int matrix_order, char uplo, lapack_int n,
float* a, lapack_int lda, lapack_int* piv,
lapack_int* rank, float tol, float* work );
lapack_int LAPACKE_dpstrf_work( int matrix_order, char uplo, lapack_int n,
double* a, lapack_int lda, lapack_int* piv,
lapack_int* rank, double tol, double* work );
lapack_int LAPACKE_cpstrf_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_int* piv, lapack_int* rank, float tol,
float* work );
lapack_int LAPACKE_zpstrf_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_int* piv, lapack_int* rank, double tol,
double* work );
lapack_int LAPACKE_sptcon_work( lapack_int n, const float* d, const float* e,
float anorm, float* rcond, float* work );
lapack_int LAPACKE_dptcon_work( lapack_int n, const double* d, const double* e,
double anorm, double* rcond, double* work );
lapack_int LAPACKE_cptcon_work( lapack_int n, const float* d,
const lapack_complex_float* e, float anorm,
float* rcond, float* work );
lapack_int LAPACKE_zptcon_work( lapack_int n, const double* d,
const lapack_complex_double* e, double anorm,
double* rcond, double* work );
lapack_int LAPACKE_spteqr_work( int matrix_order, char compz, lapack_int n,
float* d, float* e, float* z, lapack_int ldz,
float* work );
lapack_int LAPACKE_dpteqr_work( int matrix_order, char compz, lapack_int n,
double* d, double* e, double* z, lapack_int ldz,
double* work );
lapack_int LAPACKE_cpteqr_work( int matrix_order, char compz, lapack_int n,
float* d, float* e, lapack_complex_float* z,
lapack_int ldz, float* work );
lapack_int LAPACKE_zpteqr_work( int matrix_order, char compz, lapack_int n,
double* d, double* e, lapack_complex_double* z,
lapack_int ldz, double* work );
lapack_int LAPACKE_sptrfs_work( int matrix_order, lapack_int n, lapack_int nrhs,
const float* d, const float* e, const float* df,
const float* ef, const float* b, lapack_int ldb,
float* x, lapack_int ldx, float* ferr,
float* berr, float* work );
lapack_int LAPACKE_dptrfs_work( int matrix_order, lapack_int n, lapack_int nrhs,
const double* d, const double* e,
const double* df, const double* ef,
const double* b, lapack_int ldb, double* x,
lapack_int ldx, double* ferr, double* berr,
double* work );
lapack_int LAPACKE_cptrfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* d,
const lapack_complex_float* e, const float* df,
const lapack_complex_float* ef,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* ferr, float* berr,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zptrfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* d,
const lapack_complex_double* e,
const double* df,
const lapack_complex_double* ef,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_sptsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
float* d, float* e, float* b, lapack_int ldb );
lapack_int LAPACKE_dptsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
double* d, double* e, double* b,
lapack_int ldb );
lapack_int LAPACKE_cptsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
float* d, lapack_complex_float* e,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zptsv_work( int matrix_order, lapack_int n, lapack_int nrhs,
double* d, lapack_complex_double* e,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_sptsvx_work( int matrix_order, char fact, lapack_int n,
lapack_int nrhs, const float* d, const float* e,
float* df, float* ef, const float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* rcond, float* ferr, float* berr,
float* work );
lapack_int LAPACKE_dptsvx_work( int matrix_order, char fact, lapack_int n,
lapack_int nrhs, const double* d,
const double* e, double* df, double* ef,
const double* b, lapack_int ldb, double* x,
lapack_int ldx, double* rcond, double* ferr,
double* berr, double* work );
lapack_int LAPACKE_cptsvx_work( int matrix_order, char fact, lapack_int n,
lapack_int nrhs, const float* d,
const lapack_complex_float* e, float* df,
lapack_complex_float* ef,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* ferr, float* berr,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zptsvx_work( int matrix_order, char fact, lapack_int n,
lapack_int nrhs, const double* d,
const lapack_complex_double* e, double* df,
lapack_complex_double* ef,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_spttrf_work( lapack_int n, float* d, float* e );
lapack_int LAPACKE_dpttrf_work( lapack_int n, double* d, double* e );
lapack_int LAPACKE_cpttrf_work( lapack_int n, float* d,
lapack_complex_float* e );
lapack_int LAPACKE_zpttrf_work( lapack_int n, double* d,
lapack_complex_double* e );
lapack_int LAPACKE_spttrs_work( int matrix_order, lapack_int n, lapack_int nrhs,
const float* d, const float* e, float* b,
lapack_int ldb );
lapack_int LAPACKE_dpttrs_work( int matrix_order, lapack_int n, lapack_int nrhs,
const double* d, const double* e, double* b,
lapack_int ldb );
lapack_int LAPACKE_cpttrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* d,
const lapack_complex_float* e,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zpttrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* d,
const lapack_complex_double* e,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_ssbev_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_int kd, float* ab,
lapack_int ldab, float* w, float* z,
lapack_int ldz, float* work );
lapack_int LAPACKE_dsbev_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_int kd, double* ab,
lapack_int ldab, double* w, double* z,
lapack_int ldz, double* work );
lapack_int LAPACKE_ssbevd_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_int kd, float* ab,
lapack_int ldab, float* w, float* z,
lapack_int ldz, float* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_dsbevd_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_int kd, double* ab,
lapack_int ldab, double* w, double* z,
lapack_int ldz, double* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_ssbevx_work( int matrix_order, char jobz, char range,
char uplo, lapack_int n, lapack_int kd,
float* ab, lapack_int ldab, float* q,
lapack_int ldq, float vl, float vu,
lapack_int il, lapack_int iu, float abstol,
lapack_int* m, float* w, float* z,
lapack_int ldz, float* work, lapack_int* iwork,
lapack_int* ifail );
lapack_int LAPACKE_dsbevx_work( int matrix_order, char jobz, char range,
char uplo, lapack_int n, lapack_int kd,
double* ab, lapack_int ldab, double* q,
lapack_int ldq, double vl, double vu,
lapack_int il, lapack_int iu, double abstol,
lapack_int* m, double* w, double* z,
lapack_int ldz, double* work, lapack_int* iwork,
lapack_int* ifail );
lapack_int LAPACKE_ssbgst_work( int matrix_order, char vect, char uplo,
lapack_int n, lapack_int ka, lapack_int kb,
float* ab, lapack_int ldab, const float* bb,
lapack_int ldbb, float* x, lapack_int ldx,
float* work );
lapack_int LAPACKE_dsbgst_work( int matrix_order, char vect, char uplo,
lapack_int n, lapack_int ka, lapack_int kb,
double* ab, lapack_int ldab, const double* bb,
lapack_int ldbb, double* x, lapack_int ldx,
double* work );
lapack_int LAPACKE_ssbgv_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_int ka, lapack_int kb,
float* ab, lapack_int ldab, float* bb,
lapack_int ldbb, float* w, float* z,
lapack_int ldz, float* work );
lapack_int LAPACKE_dsbgv_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_int ka, lapack_int kb,
double* ab, lapack_int ldab, double* bb,
lapack_int ldbb, double* w, double* z,
lapack_int ldz, double* work );
lapack_int LAPACKE_ssbgvd_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_int ka, lapack_int kb,
float* ab, lapack_int ldab, float* bb,
lapack_int ldbb, float* w, float* z,
lapack_int ldz, float* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_dsbgvd_work( int matrix_order, char jobz, char uplo,
lapack_int n, lapack_int ka, lapack_int kb,
double* ab, lapack_int ldab, double* bb,
lapack_int ldbb, double* w, double* z,
lapack_int ldz, double* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_ssbgvx_work( int matrix_order, char jobz, char range,
char uplo, lapack_int n, lapack_int ka,
lapack_int kb, float* ab, lapack_int ldab,
float* bb, lapack_int ldbb, float* q,
lapack_int ldq, float vl, float vu,
lapack_int il, lapack_int iu, float abstol,
lapack_int* m, float* w, float* z,
lapack_int ldz, float* work, lapack_int* iwork,
lapack_int* ifail );
lapack_int LAPACKE_dsbgvx_work( int matrix_order, char jobz, char range,
char uplo, lapack_int n, lapack_int ka,
lapack_int kb, double* ab, lapack_int ldab,
double* bb, lapack_int ldbb, double* q,
lapack_int ldq, double vl, double vu,
lapack_int il, lapack_int iu, double abstol,
lapack_int* m, double* w, double* z,
lapack_int ldz, double* work, lapack_int* iwork,
lapack_int* ifail );
lapack_int LAPACKE_ssbtrd_work( int matrix_order, char vect, char uplo,
lapack_int n, lapack_int kd, float* ab,
lapack_int ldab, float* d, float* e, float* q,
lapack_int ldq, float* work );
lapack_int LAPACKE_dsbtrd_work( int matrix_order, char vect, char uplo,
lapack_int n, lapack_int kd, double* ab,
lapack_int ldab, double* d, double* e,
double* q, lapack_int ldq, double* work );
lapack_int LAPACKE_ssfrk_work( int matrix_order, char transr, char uplo,
char trans, lapack_int n, lapack_int k,
float alpha, const float* a, lapack_int lda,
float beta, float* c );
lapack_int LAPACKE_dsfrk_work( int matrix_order, char transr, char uplo,
char trans, lapack_int n, lapack_int k,
double alpha, const double* a, lapack_int lda,
double beta, double* c );
lapack_int LAPACKE_sspcon_work( int matrix_order, char uplo, lapack_int n,
const float* ap, const lapack_int* ipiv,
float anorm, float* rcond, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dspcon_work( int matrix_order, char uplo, lapack_int n,
const double* ap, const lapack_int* ipiv,
double anorm, double* rcond, double* work,
lapack_int* iwork );
lapack_int LAPACKE_cspcon_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* ap,
const lapack_int* ipiv, float anorm,
float* rcond, lapack_complex_float* work );
lapack_int LAPACKE_zspcon_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* ap,
const lapack_int* ipiv, double anorm,
double* rcond, lapack_complex_double* work );
lapack_int LAPACKE_sspev_work( int matrix_order, char jobz, char uplo,
lapack_int n, float* ap, float* w, float* z,
lapack_int ldz, float* work );
lapack_int LAPACKE_dspev_work( int matrix_order, char jobz, char uplo,
lapack_int n, double* ap, double* w, double* z,
lapack_int ldz, double* work );
lapack_int LAPACKE_sspevd_work( int matrix_order, char jobz, char uplo,
lapack_int n, float* ap, float* w, float* z,
lapack_int ldz, float* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_dspevd_work( int matrix_order, char jobz, char uplo,
lapack_int n, double* ap, double* w, double* z,
lapack_int ldz, double* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_sspevx_work( int matrix_order, char jobz, char range,
char uplo, lapack_int n, float* ap, float vl,
float vu, lapack_int il, lapack_int iu,
float abstol, lapack_int* m, float* w, float* z,
lapack_int ldz, float* work, lapack_int* iwork,
lapack_int* ifail );
lapack_int LAPACKE_dspevx_work( int matrix_order, char jobz, char range,
char uplo, lapack_int n, double* ap, double vl,
double vu, lapack_int il, lapack_int iu,
double abstol, lapack_int* m, double* w,
double* z, lapack_int ldz, double* work,
lapack_int* iwork, lapack_int* ifail );
lapack_int LAPACKE_sspgst_work( int matrix_order, lapack_int itype, char uplo,
lapack_int n, float* ap, const float* bp );
lapack_int LAPACKE_dspgst_work( int matrix_order, lapack_int itype, char uplo,
lapack_int n, double* ap, const double* bp );
lapack_int LAPACKE_sspgv_work( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, float* ap, float* bp,
float* w, float* z, lapack_int ldz,
float* work );
lapack_int LAPACKE_dspgv_work( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, double* ap, double* bp,
double* w, double* z, lapack_int ldz,
double* work );
lapack_int LAPACKE_sspgvd_work( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, float* ap, float* bp,
float* w, float* z, lapack_int ldz, float* work,
lapack_int lwork, lapack_int* iwork,
lapack_int liwork );
lapack_int LAPACKE_dspgvd_work( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, double* ap, double* bp,
double* w, double* z, lapack_int ldz,
double* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_sspgvx_work( int matrix_order, lapack_int itype, char jobz,
char range, char uplo, lapack_int n, float* ap,
float* bp, float vl, float vu, lapack_int il,
lapack_int iu, float abstol, lapack_int* m,
float* w, float* z, lapack_int ldz, float* work,
lapack_int* iwork, lapack_int* ifail );
lapack_int LAPACKE_dspgvx_work( int matrix_order, lapack_int itype, char jobz,
char range, char uplo, lapack_int n, double* ap,
double* bp, double vl, double vu, lapack_int il,
lapack_int iu, double abstol, lapack_int* m,
double* w, double* z, lapack_int ldz,
double* work, lapack_int* iwork,
lapack_int* ifail );
lapack_int LAPACKE_ssprfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* ap,
const float* afp, const lapack_int* ipiv,
const float* b, lapack_int ldb, float* x,
lapack_int ldx, float* ferr, float* berr,
float* work, lapack_int* iwork );
lapack_int LAPACKE_dsprfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* ap,
const double* afp, const lapack_int* ipiv,
const double* b, lapack_int ldb, double* x,
lapack_int ldx, double* ferr, double* berr,
double* work, lapack_int* iwork );
lapack_int LAPACKE_csprfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* ap,
const lapack_complex_float* afp,
const lapack_int* ipiv,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* ferr, float* berr,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zsprfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs,
const lapack_complex_double* ap,
const lapack_complex_double* afp,
const lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_sspsv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, float* ap, lapack_int* ipiv,
float* b, lapack_int ldb );
lapack_int LAPACKE_dspsv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, double* ap, lapack_int* ipiv,
double* b, lapack_int ldb );
lapack_int LAPACKE_cspsv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_float* ap,
lapack_int* ipiv, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zspsv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_double* ap,
lapack_int* ipiv, lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_sspsvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs, const float* ap,
float* afp, lapack_int* ipiv, const float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* rcond, float* ferr, float* berr,
float* work, lapack_int* iwork );
lapack_int LAPACKE_dspsvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs, const double* ap,
double* afp, lapack_int* ipiv, const double* b,
lapack_int ldb, double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr,
double* work, lapack_int* iwork );
lapack_int LAPACKE_cspsvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
const lapack_complex_float* ap,
lapack_complex_float* afp, lapack_int* ipiv,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* ferr, float* berr,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zspsvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
const lapack_complex_double* ap,
lapack_complex_double* afp, lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_ssptrd_work( int matrix_order, char uplo, lapack_int n,
float* ap, float* d, float* e, float* tau );
lapack_int LAPACKE_dsptrd_work( int matrix_order, char uplo, lapack_int n,
double* ap, double* d, double* e, double* tau );
lapack_int LAPACKE_ssptrf_work( int matrix_order, char uplo, lapack_int n,
float* ap, lapack_int* ipiv );
lapack_int LAPACKE_dsptrf_work( int matrix_order, char uplo, lapack_int n,
double* ap, lapack_int* ipiv );
lapack_int LAPACKE_csptrf_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* ap, lapack_int* ipiv );
lapack_int LAPACKE_zsptrf_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* ap, lapack_int* ipiv );
lapack_int LAPACKE_ssptri_work( int matrix_order, char uplo, lapack_int n,
float* ap, const lapack_int* ipiv,
float* work );
lapack_int LAPACKE_dsptri_work( int matrix_order, char uplo, lapack_int n,
double* ap, const lapack_int* ipiv,
double* work );
lapack_int LAPACKE_csptri_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* ap,
const lapack_int* ipiv,
lapack_complex_float* work );
lapack_int LAPACKE_zsptri_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* ap,
const lapack_int* ipiv,
lapack_complex_double* work );
lapack_int LAPACKE_ssptrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* ap,
const lapack_int* ipiv, float* b,
lapack_int ldb );
lapack_int LAPACKE_dsptrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* ap,
const lapack_int* ipiv, double* b,
lapack_int ldb );
lapack_int LAPACKE_csptrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* ap,
const lapack_int* ipiv, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_zsptrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs,
const lapack_complex_double* ap,
const lapack_int* ipiv,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_sstebz_work( char range, char order, lapack_int n, float vl,
float vu, lapack_int il, lapack_int iu,
float abstol, const float* d, const float* e,
lapack_int* m, lapack_int* nsplit, float* w,
lapack_int* iblock, lapack_int* isplit,
float* work, lapack_int* iwork );
lapack_int LAPACKE_dstebz_work( char range, char order, lapack_int n, double vl,
double vu, lapack_int il, lapack_int iu,
double abstol, const double* d, const double* e,
lapack_int* m, lapack_int* nsplit, double* w,
lapack_int* iblock, lapack_int* isplit,
double* work, lapack_int* iwork );
lapack_int LAPACKE_sstedc_work( int matrix_order, char compz, lapack_int n,
float* d, float* e, float* z, lapack_int ldz,
float* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_dstedc_work( int matrix_order, char compz, lapack_int n,
double* d, double* e, double* z, lapack_int ldz,
double* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_cstedc_work( int matrix_order, char compz, lapack_int n,
float* d, float* e, lapack_complex_float* z,
lapack_int ldz, lapack_complex_float* work,
lapack_int lwork, float* rwork,
lapack_int lrwork, lapack_int* iwork,
lapack_int liwork );
lapack_int LAPACKE_zstedc_work( int matrix_order, char compz, lapack_int n,
double* d, double* e, lapack_complex_double* z,
lapack_int ldz, lapack_complex_double* work,
lapack_int lwork, double* rwork,
lapack_int lrwork, lapack_int* iwork,
lapack_int liwork );
lapack_int LAPACKE_sstegr_work( int matrix_order, char jobz, char range,
lapack_int n, float* d, float* e, float vl,
float vu, lapack_int il, lapack_int iu,
float abstol, lapack_int* m, float* w, float* z,
lapack_int ldz, lapack_int* isuppz, float* work,
lapack_int lwork, lapack_int* iwork,
lapack_int liwork );
lapack_int LAPACKE_dstegr_work( int matrix_order, char jobz, char range,
lapack_int n, double* d, double* e, double vl,
double vu, lapack_int il, lapack_int iu,
double abstol, lapack_int* m, double* w,
double* z, lapack_int ldz, lapack_int* isuppz,
double* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_cstegr_work( int matrix_order, char jobz, char range,
lapack_int n, float* d, float* e, float vl,
float vu, lapack_int il, lapack_int iu,
float abstol, lapack_int* m, float* w,
lapack_complex_float* z, lapack_int ldz,
lapack_int* isuppz, float* work,
lapack_int lwork, lapack_int* iwork,
lapack_int liwork );
lapack_int LAPACKE_zstegr_work( int matrix_order, char jobz, char range,
lapack_int n, double* d, double* e, double vl,
double vu, lapack_int il, lapack_int iu,
double abstol, lapack_int* m, double* w,
lapack_complex_double* z, lapack_int ldz,
lapack_int* isuppz, double* work,
lapack_int lwork, lapack_int* iwork,
lapack_int liwork );
lapack_int LAPACKE_sstein_work( int matrix_order, lapack_int n, const float* d,
const float* e, lapack_int m, const float* w,
const lapack_int* iblock,
const lapack_int* isplit, float* z,
lapack_int ldz, float* work, lapack_int* iwork,
lapack_int* ifailv );
lapack_int LAPACKE_dstein_work( int matrix_order, lapack_int n, const double* d,
const double* e, lapack_int m, const double* w,
const lapack_int* iblock,
const lapack_int* isplit, double* z,
lapack_int ldz, double* work, lapack_int* iwork,
lapack_int* ifailv );
lapack_int LAPACKE_cstein_work( int matrix_order, lapack_int n, const float* d,
const float* e, lapack_int m, const float* w,
const lapack_int* iblock,
const lapack_int* isplit,
lapack_complex_float* z, lapack_int ldz,
float* work, lapack_int* iwork,
lapack_int* ifailv );
lapack_int LAPACKE_zstein_work( int matrix_order, lapack_int n, const double* d,
const double* e, lapack_int m, const double* w,
const lapack_int* iblock,
const lapack_int* isplit,
lapack_complex_double* z, lapack_int ldz,
double* work, lapack_int* iwork,
lapack_int* ifailv );
lapack_int LAPACKE_sstemr_work( int matrix_order, char jobz, char range,
lapack_int n, float* d, float* e, float vl,
float vu, lapack_int il, lapack_int iu,
lapack_int* m, float* w, float* z,
lapack_int ldz, lapack_int nzc,
lapack_int* isuppz, lapack_logical* tryrac,
float* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_dstemr_work( int matrix_order, char jobz, char range,
lapack_int n, double* d, double* e, double vl,
double vu, lapack_int il, lapack_int iu,
lapack_int* m, double* w, double* z,
lapack_int ldz, lapack_int nzc,
lapack_int* isuppz, lapack_logical* tryrac,
double* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_cstemr_work( int matrix_order, char jobz, char range,
lapack_int n, float* d, float* e, float vl,
float vu, lapack_int il, lapack_int iu,
lapack_int* m, float* w,
lapack_complex_float* z, lapack_int ldz,
lapack_int nzc, lapack_int* isuppz,
lapack_logical* tryrac, float* work,
lapack_int lwork, lapack_int* iwork,
lapack_int liwork );
lapack_int LAPACKE_zstemr_work( int matrix_order, char jobz, char range,
lapack_int n, double* d, double* e, double vl,
double vu, lapack_int il, lapack_int iu,
lapack_int* m, double* w,
lapack_complex_double* z, lapack_int ldz,
lapack_int nzc, lapack_int* isuppz,
lapack_logical* tryrac, double* work,
lapack_int lwork, lapack_int* iwork,
lapack_int liwork );
lapack_int LAPACKE_ssteqr_work( int matrix_order, char compz, lapack_int n,
float* d, float* e, float* z, lapack_int ldz,
float* work );
lapack_int LAPACKE_dsteqr_work( int matrix_order, char compz, lapack_int n,
double* d, double* e, double* z, lapack_int ldz,
double* work );
lapack_int LAPACKE_csteqr_work( int matrix_order, char compz, lapack_int n,
float* d, float* e, lapack_complex_float* z,
lapack_int ldz, float* work );
lapack_int LAPACKE_zsteqr_work( int matrix_order, char compz, lapack_int n,
double* d, double* e, lapack_complex_double* z,
lapack_int ldz, double* work );
lapack_int LAPACKE_ssterf_work( lapack_int n, float* d, float* e );
lapack_int LAPACKE_dsterf_work( lapack_int n, double* d, double* e );
lapack_int LAPACKE_sstev_work( int matrix_order, char jobz, lapack_int n,
float* d, float* e, float* z, lapack_int ldz,
float* work );
lapack_int LAPACKE_dstev_work( int matrix_order, char jobz, lapack_int n,
double* d, double* e, double* z, lapack_int ldz,
double* work );
lapack_int LAPACKE_sstevd_work( int matrix_order, char jobz, lapack_int n,
float* d, float* e, float* z, lapack_int ldz,
float* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_dstevd_work( int matrix_order, char jobz, lapack_int n,
double* d, double* e, double* z, lapack_int ldz,
double* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_sstevr_work( int matrix_order, char jobz, char range,
lapack_int n, float* d, float* e, float vl,
float vu, lapack_int il, lapack_int iu,
float abstol, lapack_int* m, float* w, float* z,
lapack_int ldz, lapack_int* isuppz, float* work,
lapack_int lwork, lapack_int* iwork,
lapack_int liwork );
lapack_int LAPACKE_dstevr_work( int matrix_order, char jobz, char range,
lapack_int n, double* d, double* e, double vl,
double vu, lapack_int il, lapack_int iu,
double abstol, lapack_int* m, double* w,
double* z, lapack_int ldz, lapack_int* isuppz,
double* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_sstevx_work( int matrix_order, char jobz, char range,
lapack_int n, float* d, float* e, float vl,
float vu, lapack_int il, lapack_int iu,
float abstol, lapack_int* m, float* w, float* z,
lapack_int ldz, float* work, lapack_int* iwork,
lapack_int* ifail );
lapack_int LAPACKE_dstevx_work( int matrix_order, char jobz, char range,
lapack_int n, double* d, double* e, double vl,
double vu, lapack_int il, lapack_int iu,
double abstol, lapack_int* m, double* w,
double* z, lapack_int ldz, double* work,
lapack_int* iwork, lapack_int* ifail );
lapack_int LAPACKE_ssycon_work( int matrix_order, char uplo, lapack_int n,
const float* a, lapack_int lda,
const lapack_int* ipiv, float anorm,
float* rcond, float* work, lapack_int* iwork );
lapack_int LAPACKE_dsycon_work( int matrix_order, char uplo, lapack_int n,
const double* a, lapack_int lda,
const lapack_int* ipiv, double anorm,
double* rcond, double* work,
lapack_int* iwork );
lapack_int LAPACKE_csycon_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
const lapack_int* ipiv, float anorm,
float* rcond, lapack_complex_float* work );
lapack_int LAPACKE_zsycon_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
const lapack_int* ipiv, double anorm,
double* rcond, lapack_complex_double* work );
lapack_int LAPACKE_ssyequb_work( int matrix_order, char uplo, lapack_int n,
const float* a, lapack_int lda, float* s,
float* scond, float* amax, float* work );
lapack_int LAPACKE_dsyequb_work( int matrix_order, char uplo, lapack_int n,
const double* a, lapack_int lda, double* s,
double* scond, double* amax, double* work );
lapack_int LAPACKE_csyequb_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
float* s, float* scond, float* amax,
lapack_complex_float* work );
lapack_int LAPACKE_zsyequb_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
double* s, double* scond, double* amax,
lapack_complex_double* work );
lapack_int LAPACKE_ssyev_work( int matrix_order, char jobz, char uplo,
lapack_int n, float* a, lapack_int lda, float* w,
float* work, lapack_int lwork );
lapack_int LAPACKE_dsyev_work( int matrix_order, char jobz, char uplo,
lapack_int n, double* a, lapack_int lda,
double* w, double* work, lapack_int lwork );
lapack_int LAPACKE_ssyevd_work( int matrix_order, char jobz, char uplo,
lapack_int n, float* a, lapack_int lda,
float* w, float* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_dsyevd_work( int matrix_order, char jobz, char uplo,
lapack_int n, double* a, lapack_int lda,
double* w, double* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_ssyevr_work( int matrix_order, char jobz, char range,
char uplo, lapack_int n, float* a,
lapack_int lda, float vl, float vu,
lapack_int il, lapack_int iu, float abstol,
lapack_int* m, float* w, float* z,
lapack_int ldz, lapack_int* isuppz, float* work,
lapack_int lwork, lapack_int* iwork,
lapack_int liwork );
lapack_int LAPACKE_dsyevr_work( int matrix_order, char jobz, char range,
char uplo, lapack_int n, double* a,
lapack_int lda, double vl, double vu,
lapack_int il, lapack_int iu, double abstol,
lapack_int* m, double* w, double* z,
lapack_int ldz, lapack_int* isuppz,
double* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_ssyevx_work( int matrix_order, char jobz, char range,
char uplo, lapack_int n, float* a,
lapack_int lda, float vl, float vu,
lapack_int il, lapack_int iu, float abstol,
lapack_int* m, float* w, float* z,
lapack_int ldz, float* work, lapack_int lwork,
lapack_int* iwork, lapack_int* ifail );
lapack_int LAPACKE_dsyevx_work( int matrix_order, char jobz, char range,
char uplo, lapack_int n, double* a,
lapack_int lda, double vl, double vu,
lapack_int il, lapack_int iu, double abstol,
lapack_int* m, double* w, double* z,
lapack_int ldz, double* work, lapack_int lwork,
lapack_int* iwork, lapack_int* ifail );
lapack_int LAPACKE_ssygst_work( int matrix_order, lapack_int itype, char uplo,
lapack_int n, float* a, lapack_int lda,
const float* b, lapack_int ldb );
lapack_int LAPACKE_dsygst_work( int matrix_order, lapack_int itype, char uplo,
lapack_int n, double* a, lapack_int lda,
const double* b, lapack_int ldb );
lapack_int LAPACKE_ssygv_work( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, float* a,
lapack_int lda, float* b, lapack_int ldb,
float* w, float* work, lapack_int lwork );
lapack_int LAPACKE_dsygv_work( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, double* a,
lapack_int lda, double* b, lapack_int ldb,
double* w, double* work, lapack_int lwork );
lapack_int LAPACKE_ssygvd_work( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, float* a,
lapack_int lda, float* b, lapack_int ldb,
float* w, float* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_dsygvd_work( int matrix_order, lapack_int itype, char jobz,
char uplo, lapack_int n, double* a,
lapack_int lda, double* b, lapack_int ldb,
double* w, double* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_ssygvx_work( int matrix_order, lapack_int itype, char jobz,
char range, char uplo, lapack_int n, float* a,
lapack_int lda, float* b, lapack_int ldb,
float vl, float vu, lapack_int il,
lapack_int iu, float abstol, lapack_int* m,
float* w, float* z, lapack_int ldz, float* work,
lapack_int lwork, lapack_int* iwork,
lapack_int* ifail );
lapack_int LAPACKE_dsygvx_work( int matrix_order, lapack_int itype, char jobz,
char range, char uplo, lapack_int n, double* a,
lapack_int lda, double* b, lapack_int ldb,
double vl, double vu, lapack_int il,
lapack_int iu, double abstol, lapack_int* m,
double* w, double* z, lapack_int ldz,
double* work, lapack_int lwork,
lapack_int* iwork, lapack_int* ifail );
lapack_int LAPACKE_ssyrfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* a, lapack_int lda,
const float* af, lapack_int ldaf,
const lapack_int* ipiv, const float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* ferr, float* berr, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dsyrfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* a,
lapack_int lda, const double* af,
lapack_int ldaf, const lapack_int* ipiv,
const double* b, lapack_int ldb, double* x,
lapack_int ldx, double* ferr, double* berr,
double* work, lapack_int* iwork );
lapack_int LAPACKE_csyrfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* af,
lapack_int ldaf, const lapack_int* ipiv,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* ferr, float* berr,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_zsyrfs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, const lapack_complex_double* af,
lapack_int ldaf, const lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_ssyrfsx_work( int matrix_order, char uplo, char equed,
lapack_int n, lapack_int nrhs, const float* a,
lapack_int lda, const float* af,
lapack_int ldaf, const lapack_int* ipiv,
const float* s, const float* b, lapack_int ldb,
float* x, lapack_int ldx, float* rcond,
float* berr, lapack_int n_err_bnds,
float* err_bnds_norm, float* err_bnds_comp,
lapack_int nparams, float* params, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dsyrfsx_work( int matrix_order, char uplo, char equed,
lapack_int n, lapack_int nrhs, const double* a,
lapack_int lda, const double* af,
lapack_int ldaf, const lapack_int* ipiv,
const double* s, const double* b,
lapack_int ldb, double* x, lapack_int ldx,
double* rcond, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params, double* work,
lapack_int* iwork );
lapack_int LAPACKE_csyrfsx_work( int matrix_order, char uplo, char equed,
lapack_int n, lapack_int nrhs,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* af,
lapack_int ldaf, const lapack_int* ipiv,
const float* s, const lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* x,
lapack_int ldx, float* rcond, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params, lapack_complex_float* work,
float* rwork );
lapack_int LAPACKE_zsyrfsx_work( int matrix_order, char uplo, char equed,
lapack_int n, lapack_int nrhs,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* af,
lapack_int ldaf, const lapack_int* ipiv,
const double* s,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params, lapack_complex_double* work,
double* rwork );
lapack_int LAPACKE_ssysv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, float* a, lapack_int lda,
lapack_int* ipiv, float* b, lapack_int ldb,
float* work, lapack_int lwork );
lapack_int LAPACKE_dsysv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, double* a, lapack_int lda,
lapack_int* ipiv, double* b, lapack_int ldb,
double* work, lapack_int lwork );
lapack_int LAPACKE_csysv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_float* a,
lapack_int lda, lapack_int* ipiv,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zsysv_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, lapack_complex_double* a,
lapack_int lda, lapack_int* ipiv,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_ssysvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs, const float* a,
lapack_int lda, float* af, lapack_int ldaf,
lapack_int* ipiv, const float* b,
lapack_int ldb, float* x, lapack_int ldx,
float* rcond, float* ferr, float* berr,
float* work, lapack_int lwork,
lapack_int* iwork );
lapack_int LAPACKE_dsysvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs, const double* a,
lapack_int lda, double* af, lapack_int ldaf,
lapack_int* ipiv, const double* b,
lapack_int ldb, double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr,
double* work, lapack_int lwork,
lapack_int* iwork );
lapack_int LAPACKE_csysvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
const lapack_complex_float* a, lapack_int lda,
lapack_complex_float* af, lapack_int ldaf,
lapack_int* ipiv, const lapack_complex_float* b,
lapack_int ldb, lapack_complex_float* x,
lapack_int ldx, float* rcond, float* ferr,
float* berr, lapack_complex_float* work,
lapack_int lwork, float* rwork );
lapack_int LAPACKE_zsysvx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
const lapack_complex_double* a, lapack_int lda,
lapack_complex_double* af, lapack_int ldaf,
lapack_int* ipiv,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* ferr, double* berr,
lapack_complex_double* work, lapack_int lwork,
double* rwork );
lapack_int LAPACKE_ssysvxx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs, float* a,
lapack_int lda, float* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, float* s,
float* b, lapack_int ldb, float* x,
lapack_int ldx, float* rcond, float* rpvgrw,
float* berr, lapack_int n_err_bnds,
float* err_bnds_norm, float* err_bnds_comp,
lapack_int nparams, float* params, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dsysvxx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs, double* a,
lapack_int lda, double* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, double* s,
double* b, lapack_int ldb, double* x,
lapack_int ldx, double* rcond, double* rpvgrw,
double* berr, lapack_int n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int nparams, double* params,
double* work, lapack_int* iwork );
lapack_int LAPACKE_csysvxx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, float* s,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* x, lapack_int ldx,
float* rcond, float* rpvgrw, float* berr,
lapack_int n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int nparams,
float* params, lapack_complex_float* work,
float* rwork );
lapack_int LAPACKE_zsysvxx_work( int matrix_order, char fact, char uplo,
lapack_int n, lapack_int nrhs,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* af, lapack_int ldaf,
lapack_int* ipiv, char* equed, double* s,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* x, lapack_int ldx,
double* rcond, double* rpvgrw, double* berr,
lapack_int n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int nparams,
double* params, lapack_complex_double* work,
double* rwork );
lapack_int LAPACKE_ssytrd_work( int matrix_order, char uplo, lapack_int n,
float* a, lapack_int lda, float* d, float* e,
float* tau, float* work, lapack_int lwork );
lapack_int LAPACKE_dsytrd_work( int matrix_order, char uplo, lapack_int n,
double* a, lapack_int lda, double* d, double* e,
double* tau, double* work, lapack_int lwork );
lapack_int LAPACKE_ssytrf_work( int matrix_order, char uplo, lapack_int n,
float* a, lapack_int lda, lapack_int* ipiv,
float* work, lapack_int lwork );
lapack_int LAPACKE_dsytrf_work( int matrix_order, char uplo, lapack_int n,
double* a, lapack_int lda, lapack_int* ipiv,
double* work, lapack_int lwork );
lapack_int LAPACKE_csytrf_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_int* ipiv, lapack_complex_float* work,
lapack_int lwork );
lapack_int LAPACKE_zsytrf_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_int* ipiv, lapack_complex_double* work,
lapack_int lwork );
lapack_int LAPACKE_ssytri_work( int matrix_order, char uplo, lapack_int n,
float* a, lapack_int lda,
const lapack_int* ipiv, float* work );
lapack_int LAPACKE_dsytri_work( int matrix_order, char uplo, lapack_int n,
double* a, lapack_int lda,
const lapack_int* ipiv, double* work );
lapack_int LAPACKE_csytri_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
const lapack_int* ipiv,
lapack_complex_float* work );
lapack_int LAPACKE_zsytri_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
const lapack_int* ipiv,
lapack_complex_double* work );
lapack_int LAPACKE_ssytrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* a, lapack_int lda,
const lapack_int* ipiv, float* b,
lapack_int ldb );
lapack_int LAPACKE_dsytrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* a,
lapack_int lda, const lapack_int* ipiv,
double* b, lapack_int ldb );
lapack_int LAPACKE_csytrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_zsytrs_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_stbcon_work( int matrix_order, char norm, char uplo,
char diag, lapack_int n, lapack_int kd,
const float* ab, lapack_int ldab, float* rcond,
float* work, lapack_int* iwork );
lapack_int LAPACKE_dtbcon_work( int matrix_order, char norm, char uplo,
char diag, lapack_int n, lapack_int kd,
const double* ab, lapack_int ldab,
double* rcond, double* work,
lapack_int* iwork );
lapack_int LAPACKE_ctbcon_work( int matrix_order, char norm, char uplo,
char diag, lapack_int n, lapack_int kd,
const lapack_complex_float* ab, lapack_int ldab,
float* rcond, lapack_complex_float* work,
float* rwork );
lapack_int LAPACKE_ztbcon_work( int matrix_order, char norm, char uplo,
char diag, lapack_int n, lapack_int kd,
const lapack_complex_double* ab,
lapack_int ldab, double* rcond,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_stbrfs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int kd,
lapack_int nrhs, const float* ab,
lapack_int ldab, const float* b, lapack_int ldb,
const float* x, lapack_int ldx, float* ferr,
float* berr, float* work, lapack_int* iwork );
lapack_int LAPACKE_dtbrfs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int kd,
lapack_int nrhs, const double* ab,
lapack_int ldab, const double* b,
lapack_int ldb, const double* x, lapack_int ldx,
double* ferr, double* berr, double* work,
lapack_int* iwork );
lapack_int LAPACKE_ctbrfs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int kd,
lapack_int nrhs, const lapack_complex_float* ab,
lapack_int ldab, const lapack_complex_float* b,
lapack_int ldb, const lapack_complex_float* x,
lapack_int ldx, float* ferr, float* berr,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_ztbrfs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int kd,
lapack_int nrhs,
const lapack_complex_double* ab,
lapack_int ldab, const lapack_complex_double* b,
lapack_int ldb, const lapack_complex_double* x,
lapack_int ldx, double* ferr, double* berr,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_stbtrs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int kd,
lapack_int nrhs, const float* ab,
lapack_int ldab, float* b, lapack_int ldb );
lapack_int LAPACKE_dtbtrs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int kd,
lapack_int nrhs, const double* ab,
lapack_int ldab, double* b, lapack_int ldb );
lapack_int LAPACKE_ctbtrs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int kd,
lapack_int nrhs, const lapack_complex_float* ab,
lapack_int ldab, lapack_complex_float* b,
lapack_int ldb );
lapack_int LAPACKE_ztbtrs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int kd,
lapack_int nrhs,
const lapack_complex_double* ab,
lapack_int ldab, lapack_complex_double* b,
lapack_int ldb );
lapack_int LAPACKE_stfsm_work( int matrix_order, char transr, char side,
char uplo, char trans, char diag, lapack_int m,
lapack_int n, float alpha, const float* a,
float* b, lapack_int ldb );
lapack_int LAPACKE_dtfsm_work( int matrix_order, char transr, char side,
char uplo, char trans, char diag, lapack_int m,
lapack_int n, double alpha, const double* a,
double* b, lapack_int ldb );
lapack_int LAPACKE_ctfsm_work( int matrix_order, char transr, char side,
char uplo, char trans, char diag, lapack_int m,
lapack_int n, lapack_complex_float alpha,
const lapack_complex_float* a,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_ztfsm_work( int matrix_order, char transr, char side,
char uplo, char trans, char diag, lapack_int m,
lapack_int n, lapack_complex_double alpha,
const lapack_complex_double* a,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_stftri_work( int matrix_order, char transr, char uplo,
char diag, lapack_int n, float* a );
lapack_int LAPACKE_dtftri_work( int matrix_order, char transr, char uplo,
char diag, lapack_int n, double* a );
lapack_int LAPACKE_ctftri_work( int matrix_order, char transr, char uplo,
char diag, lapack_int n,
lapack_complex_float* a );
lapack_int LAPACKE_ztftri_work( int matrix_order, char transr, char uplo,
char diag, lapack_int n,
lapack_complex_double* a );
lapack_int LAPACKE_stfttp_work( int matrix_order, char transr, char uplo,
lapack_int n, const float* arf, float* ap );
lapack_int LAPACKE_dtfttp_work( int matrix_order, char transr, char uplo,
lapack_int n, const double* arf, double* ap );
lapack_int LAPACKE_ctfttp_work( int matrix_order, char transr, char uplo,
lapack_int n, const lapack_complex_float* arf,
lapack_complex_float* ap );
lapack_int LAPACKE_ztfttp_work( int matrix_order, char transr, char uplo,
lapack_int n, const lapack_complex_double* arf,
lapack_complex_double* ap );
lapack_int LAPACKE_stfttr_work( int matrix_order, char transr, char uplo,
lapack_int n, const float* arf, float* a,
lapack_int lda );
lapack_int LAPACKE_dtfttr_work( int matrix_order, char transr, char uplo,
lapack_int n, const double* arf, double* a,
lapack_int lda );
lapack_int LAPACKE_ctfttr_work( int matrix_order, char transr, char uplo,
lapack_int n, const lapack_complex_float* arf,
lapack_complex_float* a, lapack_int lda );
lapack_int LAPACKE_ztfttr_work( int matrix_order, char transr, char uplo,
lapack_int n, const lapack_complex_double* arf,
lapack_complex_double* a, lapack_int lda );
lapack_int LAPACKE_stgevc_work( int matrix_order, char side, char howmny,
const lapack_logical* select, lapack_int n,
const float* s, lapack_int lds, const float* p,
lapack_int ldp, float* vl, lapack_int ldvl,
float* vr, lapack_int ldvr, lapack_int mm,
lapack_int* m, float* work );
lapack_int LAPACKE_dtgevc_work( int matrix_order, char side, char howmny,
const lapack_logical* select, lapack_int n,
const double* s, lapack_int lds,
const double* p, lapack_int ldp, double* vl,
lapack_int ldvl, double* vr, lapack_int ldvr,
lapack_int mm, lapack_int* m, double* work );
lapack_int LAPACKE_ctgevc_work( int matrix_order, char side, char howmny,
const lapack_logical* select, lapack_int n,
const lapack_complex_float* s, lapack_int lds,
const lapack_complex_float* p, lapack_int ldp,
lapack_complex_float* vl, lapack_int ldvl,
lapack_complex_float* vr, lapack_int ldvr,
lapack_int mm, lapack_int* m,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_ztgevc_work( int matrix_order, char side, char howmny,
const lapack_logical* select, lapack_int n,
const lapack_complex_double* s, lapack_int lds,
const lapack_complex_double* p, lapack_int ldp,
lapack_complex_double* vl, lapack_int ldvl,
lapack_complex_double* vr, lapack_int ldvr,
lapack_int mm, lapack_int* m,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_stgexc_work( int matrix_order, lapack_logical wantq,
lapack_logical wantz, lapack_int n, float* a,
lapack_int lda, float* b, lapack_int ldb,
float* q, lapack_int ldq, float* z,
lapack_int ldz, lapack_int* ifst,
lapack_int* ilst, float* work,
lapack_int lwork );
lapack_int LAPACKE_dtgexc_work( int matrix_order, lapack_logical wantq,
lapack_logical wantz, lapack_int n, double* a,
lapack_int lda, double* b, lapack_int ldb,
double* q, lapack_int ldq, double* z,
lapack_int ldz, lapack_int* ifst,
lapack_int* ilst, double* work,
lapack_int lwork );
lapack_int LAPACKE_ctgexc_work( int matrix_order, lapack_logical wantq,
lapack_logical wantz, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* q, lapack_int ldq,
lapack_complex_float* z, lapack_int ldz,
lapack_int ifst, lapack_int ilst );
lapack_int LAPACKE_ztgexc_work( int matrix_order, lapack_logical wantq,
lapack_logical wantz, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* q, lapack_int ldq,
lapack_complex_double* z, lapack_int ldz,
lapack_int ifst, lapack_int ilst );
lapack_int LAPACKE_stgsen_work( int matrix_order, lapack_int ijob,
lapack_logical wantq, lapack_logical wantz,
const lapack_logical* select, lapack_int n,
float* a, lapack_int lda, float* b,
lapack_int ldb, float* alphar, float* alphai,
float* beta, float* q, lapack_int ldq, float* z,
lapack_int ldz, lapack_int* m, float* pl,
float* pr, float* dif, float* work,
lapack_int lwork, lapack_int* iwork,
lapack_int liwork );
lapack_int LAPACKE_dtgsen_work( int matrix_order, lapack_int ijob,
lapack_logical wantq, lapack_logical wantz,
const lapack_logical* select, lapack_int n,
double* a, lapack_int lda, double* b,
lapack_int ldb, double* alphar, double* alphai,
double* beta, double* q, lapack_int ldq,
double* z, lapack_int ldz, lapack_int* m,
double* pl, double* pr, double* dif,
double* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_ctgsen_work( int matrix_order, lapack_int ijob,
lapack_logical wantq, lapack_logical wantz,
const lapack_logical* select, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* alpha,
lapack_complex_float* beta,
lapack_complex_float* q, lapack_int ldq,
lapack_complex_float* z, lapack_int ldz,
lapack_int* m, float* pl, float* pr, float* dif,
lapack_complex_float* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_ztgsen_work( int matrix_order, lapack_int ijob,
lapack_logical wantq, lapack_logical wantz,
const lapack_logical* select, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* alpha,
lapack_complex_double* beta,
lapack_complex_double* q, lapack_int ldq,
lapack_complex_double* z, lapack_int ldz,
lapack_int* m, double* pl, double* pr,
double* dif, lapack_complex_double* work,
lapack_int lwork, lapack_int* iwork,
lapack_int liwork );
lapack_int LAPACKE_stgsja_work( int matrix_order, char jobu, char jobv,
char jobq, lapack_int m, lapack_int p,
lapack_int n, lapack_int k, lapack_int l,
float* a, lapack_int lda, float* b,
lapack_int ldb, float tola, float tolb,
float* alpha, float* beta, float* u,
lapack_int ldu, float* v, lapack_int ldv,
float* q, lapack_int ldq, float* work,
lapack_int* ncycle );
lapack_int LAPACKE_dtgsja_work( int matrix_order, char jobu, char jobv,
char jobq, lapack_int m, lapack_int p,
lapack_int n, lapack_int k, lapack_int l,
double* a, lapack_int lda, double* b,
lapack_int ldb, double tola, double tolb,
double* alpha, double* beta, double* u,
lapack_int ldu, double* v, lapack_int ldv,
double* q, lapack_int ldq, double* work,
lapack_int* ncycle );
lapack_int LAPACKE_ctgsja_work( int matrix_order, char jobu, char jobv,
char jobq, lapack_int m, lapack_int p,
lapack_int n, lapack_int k, lapack_int l,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
float tola, float tolb, float* alpha,
float* beta, lapack_complex_float* u,
lapack_int ldu, lapack_complex_float* v,
lapack_int ldv, lapack_complex_float* q,
lapack_int ldq, lapack_complex_float* work,
lapack_int* ncycle );
lapack_int LAPACKE_ztgsja_work( int matrix_order, char jobu, char jobv,
char jobq, lapack_int m, lapack_int p,
lapack_int n, lapack_int k, lapack_int l,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
double tola, double tolb, double* alpha,
double* beta, lapack_complex_double* u,
lapack_int ldu, lapack_complex_double* v,
lapack_int ldv, lapack_complex_double* q,
lapack_int ldq, lapack_complex_double* work,
lapack_int* ncycle );
lapack_int LAPACKE_stgsna_work( int matrix_order, char job, char howmny,
const lapack_logical* select, lapack_int n,
const float* a, lapack_int lda, const float* b,
lapack_int ldb, const float* vl,
lapack_int ldvl, const float* vr,
lapack_int ldvr, float* s, float* dif,
lapack_int mm, lapack_int* m, float* work,
lapack_int lwork, lapack_int* iwork );
lapack_int LAPACKE_dtgsna_work( int matrix_order, char job, char howmny,
const lapack_logical* select, lapack_int n,
const double* a, lapack_int lda,
const double* b, lapack_int ldb,
const double* vl, lapack_int ldvl,
const double* vr, lapack_int ldvr, double* s,
double* dif, lapack_int mm, lapack_int* m,
double* work, lapack_int lwork,
lapack_int* iwork );
lapack_int LAPACKE_ctgsna_work( int matrix_order, char job, char howmny,
const lapack_logical* select, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* b, lapack_int ldb,
const lapack_complex_float* vl, lapack_int ldvl,
const lapack_complex_float* vr, lapack_int ldvr,
float* s, float* dif, lapack_int mm,
lapack_int* m, lapack_complex_float* work,
lapack_int lwork, lapack_int* iwork );
lapack_int LAPACKE_ztgsna_work( int matrix_order, char job, char howmny,
const lapack_logical* select, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* b, lapack_int ldb,
const lapack_complex_double* vl,
lapack_int ldvl,
const lapack_complex_double* vr,
lapack_int ldvr, double* s, double* dif,
lapack_int mm, lapack_int* m,
lapack_complex_double* work, lapack_int lwork,
lapack_int* iwork );
lapack_int LAPACKE_stgsyl_work( int matrix_order, char trans, lapack_int ijob,
lapack_int m, lapack_int n, const float* a,
lapack_int lda, const float* b, lapack_int ldb,
float* c, lapack_int ldc, const float* d,
lapack_int ldd, const float* e, lapack_int lde,
float* f, lapack_int ldf, float* scale,
float* dif, float* work, lapack_int lwork,
lapack_int* iwork );
lapack_int LAPACKE_dtgsyl_work( int matrix_order, char trans, lapack_int ijob,
lapack_int m, lapack_int n, const double* a,
lapack_int lda, const double* b, lapack_int ldb,
double* c, lapack_int ldc, const double* d,
lapack_int ldd, const double* e, lapack_int lde,
double* f, lapack_int ldf, double* scale,
double* dif, double* work, lapack_int lwork,
lapack_int* iwork );
lapack_int LAPACKE_ctgsyl_work( int matrix_order, char trans, lapack_int ijob,
lapack_int m, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* c, lapack_int ldc,
const lapack_complex_float* d, lapack_int ldd,
const lapack_complex_float* e, lapack_int lde,
lapack_complex_float* f, lapack_int ldf,
float* scale, float* dif,
lapack_complex_float* work, lapack_int lwork,
lapack_int* iwork );
lapack_int LAPACKE_ztgsyl_work( int matrix_order, char trans, lapack_int ijob,
lapack_int m, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* c, lapack_int ldc,
const lapack_complex_double* d, lapack_int ldd,
const lapack_complex_double* e, lapack_int lde,
lapack_complex_double* f, lapack_int ldf,
double* scale, double* dif,
lapack_complex_double* work, lapack_int lwork,
lapack_int* iwork );
lapack_int LAPACKE_stpcon_work( int matrix_order, char norm, char uplo,
char diag, lapack_int n, const float* ap,
float* rcond, float* work, lapack_int* iwork );
lapack_int LAPACKE_dtpcon_work( int matrix_order, char norm, char uplo,
char diag, lapack_int n, const double* ap,
double* rcond, double* work,
lapack_int* iwork );
lapack_int LAPACKE_ctpcon_work( int matrix_order, char norm, char uplo,
char diag, lapack_int n,
const lapack_complex_float* ap, float* rcond,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_ztpcon_work( int matrix_order, char norm, char uplo,
char diag, lapack_int n,
const lapack_complex_double* ap, double* rcond,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_stprfs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int nrhs,
const float* ap, const float* b, lapack_int ldb,
const float* x, lapack_int ldx, float* ferr,
float* berr, float* work, lapack_int* iwork );
lapack_int LAPACKE_dtprfs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int nrhs,
const double* ap, const double* b,
lapack_int ldb, const double* x, lapack_int ldx,
double* ferr, double* berr, double* work,
lapack_int* iwork );
lapack_int LAPACKE_ctprfs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int nrhs,
const lapack_complex_float* ap,
const lapack_complex_float* b, lapack_int ldb,
const lapack_complex_float* x, lapack_int ldx,
float* ferr, float* berr,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_ztprfs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int nrhs,
const lapack_complex_double* ap,
const lapack_complex_double* b, lapack_int ldb,
const lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_stptri_work( int matrix_order, char uplo, char diag,
lapack_int n, float* ap );
lapack_int LAPACKE_dtptri_work( int matrix_order, char uplo, char diag,
lapack_int n, double* ap );
lapack_int LAPACKE_ctptri_work( int matrix_order, char uplo, char diag,
lapack_int n, lapack_complex_float* ap );
lapack_int LAPACKE_ztptri_work( int matrix_order, char uplo, char diag,
lapack_int n, lapack_complex_double* ap );
lapack_int LAPACKE_stptrs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int nrhs,
const float* ap, float* b, lapack_int ldb );
lapack_int LAPACKE_dtptrs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int nrhs,
const double* ap, double* b, lapack_int ldb );
lapack_int LAPACKE_ctptrs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int nrhs,
const lapack_complex_float* ap,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_ztptrs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int nrhs,
const lapack_complex_double* ap,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_stpttf_work( int matrix_order, char transr, char uplo,
lapack_int n, const float* ap, float* arf );
lapack_int LAPACKE_dtpttf_work( int matrix_order, char transr, char uplo,
lapack_int n, const double* ap, double* arf );
lapack_int LAPACKE_ctpttf_work( int matrix_order, char transr, char uplo,
lapack_int n, const lapack_complex_float* ap,
lapack_complex_float* arf );
lapack_int LAPACKE_ztpttf_work( int matrix_order, char transr, char uplo,
lapack_int n, const lapack_complex_double* ap,
lapack_complex_double* arf );
lapack_int LAPACKE_stpttr_work( int matrix_order, char uplo, lapack_int n,
const float* ap, float* a, lapack_int lda );
lapack_int LAPACKE_dtpttr_work( int matrix_order, char uplo, lapack_int n,
const double* ap, double* a, lapack_int lda );
lapack_int LAPACKE_ctpttr_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* ap,
lapack_complex_float* a, lapack_int lda );
lapack_int LAPACKE_ztpttr_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* ap,
lapack_complex_double* a, lapack_int lda );
lapack_int LAPACKE_strcon_work( int matrix_order, char norm, char uplo,
char diag, lapack_int n, const float* a,
lapack_int lda, float* rcond, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dtrcon_work( int matrix_order, char norm, char uplo,
char diag, lapack_int n, const double* a,
lapack_int lda, double* rcond, double* work,
lapack_int* iwork );
lapack_int LAPACKE_ctrcon_work( int matrix_order, char norm, char uplo,
char diag, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
float* rcond, lapack_complex_float* work,
float* rwork );
lapack_int LAPACKE_ztrcon_work( int matrix_order, char norm, char uplo,
char diag, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
double* rcond, lapack_complex_double* work,
double* rwork );
lapack_int LAPACKE_strevc_work( int matrix_order, char side, char howmny,
lapack_logical* select, lapack_int n,
const float* t, lapack_int ldt, float* vl,
lapack_int ldvl, float* vr, lapack_int ldvr,
lapack_int mm, lapack_int* m, float* work );
lapack_int LAPACKE_dtrevc_work( int matrix_order, char side, char howmny,
lapack_logical* select, lapack_int n,
const double* t, lapack_int ldt, double* vl,
lapack_int ldvl, double* vr, lapack_int ldvr,
lapack_int mm, lapack_int* m, double* work );
lapack_int LAPACKE_ctrevc_work( int matrix_order, char side, char howmny,
const lapack_logical* select, lapack_int n,
lapack_complex_float* t, lapack_int ldt,
lapack_complex_float* vl, lapack_int ldvl,
lapack_complex_float* vr, lapack_int ldvr,
lapack_int mm, lapack_int* m,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_ztrevc_work( int matrix_order, char side, char howmny,
const lapack_logical* select, lapack_int n,
lapack_complex_double* t, lapack_int ldt,
lapack_complex_double* vl, lapack_int ldvl,
lapack_complex_double* vr, lapack_int ldvr,
lapack_int mm, lapack_int* m,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_strexc_work( int matrix_order, char compq, lapack_int n,
float* t, lapack_int ldt, float* q,
lapack_int ldq, lapack_int* ifst,
lapack_int* ilst, float* work );
lapack_int LAPACKE_dtrexc_work( int matrix_order, char compq, lapack_int n,
double* t, lapack_int ldt, double* q,
lapack_int ldq, lapack_int* ifst,
lapack_int* ilst, double* work );
lapack_int LAPACKE_ctrexc_work( int matrix_order, char compq, lapack_int n,
lapack_complex_float* t, lapack_int ldt,
lapack_complex_float* q, lapack_int ldq,
lapack_int ifst, lapack_int ilst );
lapack_int LAPACKE_ztrexc_work( int matrix_order, char compq, lapack_int n,
lapack_complex_double* t, lapack_int ldt,
lapack_complex_double* q, lapack_int ldq,
lapack_int ifst, lapack_int ilst );
lapack_int LAPACKE_strrfs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int nrhs,
const float* a, lapack_int lda, const float* b,
lapack_int ldb, const float* x, lapack_int ldx,
float* ferr, float* berr, float* work,
lapack_int* iwork );
lapack_int LAPACKE_dtrrfs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int nrhs,
const double* a, lapack_int lda,
const double* b, lapack_int ldb,
const double* x, lapack_int ldx, double* ferr,
double* berr, double* work, lapack_int* iwork );
lapack_int LAPACKE_ctrrfs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int nrhs,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* b, lapack_int ldb,
const lapack_complex_float* x, lapack_int ldx,
float* ferr, float* berr,
lapack_complex_float* work, float* rwork );
lapack_int LAPACKE_ztrrfs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int nrhs,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* b, lapack_int ldb,
const lapack_complex_double* x, lapack_int ldx,
double* ferr, double* berr,
lapack_complex_double* work, double* rwork );
lapack_int LAPACKE_strsen_work( int matrix_order, char job, char compq,
const lapack_logical* select, lapack_int n,
float* t, lapack_int ldt, float* q,
lapack_int ldq, float* wr, float* wi,
lapack_int* m, float* s, float* sep,
float* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_dtrsen_work( int matrix_order, char job, char compq,
const lapack_logical* select, lapack_int n,
double* t, lapack_int ldt, double* q,
lapack_int ldq, double* wr, double* wi,
lapack_int* m, double* s, double* sep,
double* work, lapack_int lwork,
lapack_int* iwork, lapack_int liwork );
lapack_int LAPACKE_ctrsen_work( int matrix_order, char job, char compq,
const lapack_logical* select, lapack_int n,
lapack_complex_float* t, lapack_int ldt,
lapack_complex_float* q, lapack_int ldq,
lapack_complex_float* w, lapack_int* m,
float* s, float* sep,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_ztrsen_work( int matrix_order, char job, char compq,
const lapack_logical* select, lapack_int n,
lapack_complex_double* t, lapack_int ldt,
lapack_complex_double* q, lapack_int ldq,
lapack_complex_double* w, lapack_int* m,
double* s, double* sep,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_strsna_work( int matrix_order, char job, char howmny,
const lapack_logical* select, lapack_int n,
const float* t, lapack_int ldt, const float* vl,
lapack_int ldvl, const float* vr,
lapack_int ldvr, float* s, float* sep,
lapack_int mm, lapack_int* m, float* work,
lapack_int ldwork, lapack_int* iwork );
lapack_int LAPACKE_dtrsna_work( int matrix_order, char job, char howmny,
const lapack_logical* select, lapack_int n,
const double* t, lapack_int ldt,
const double* vl, lapack_int ldvl,
const double* vr, lapack_int ldvr, double* s,
double* sep, lapack_int mm, lapack_int* m,
double* work, lapack_int ldwork,
lapack_int* iwork );
lapack_int LAPACKE_ctrsna_work( int matrix_order, char job, char howmny,
const lapack_logical* select, lapack_int n,
const lapack_complex_float* t, lapack_int ldt,
const lapack_complex_float* vl, lapack_int ldvl,
const lapack_complex_float* vr, lapack_int ldvr,
float* s, float* sep, lapack_int mm,
lapack_int* m, lapack_complex_float* work,
lapack_int ldwork, float* rwork );
lapack_int LAPACKE_ztrsna_work( int matrix_order, char job, char howmny,
const lapack_logical* select, lapack_int n,
const lapack_complex_double* t, lapack_int ldt,
const lapack_complex_double* vl,
lapack_int ldvl,
const lapack_complex_double* vr,
lapack_int ldvr, double* s, double* sep,
lapack_int mm, lapack_int* m,
lapack_complex_double* work, lapack_int ldwork,
double* rwork );
lapack_int LAPACKE_strsyl_work( int matrix_order, char trana, char tranb,
lapack_int isgn, lapack_int m, lapack_int n,
const float* a, lapack_int lda, const float* b,
lapack_int ldb, float* c, lapack_int ldc,
float* scale );
lapack_int LAPACKE_dtrsyl_work( int matrix_order, char trana, char tranb,
lapack_int isgn, lapack_int m, lapack_int n,
const double* a, lapack_int lda,
const double* b, lapack_int ldb, double* c,
lapack_int ldc, double* scale );
lapack_int LAPACKE_ctrsyl_work( int matrix_order, char trana, char tranb,
lapack_int isgn, lapack_int m, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* c, lapack_int ldc,
float* scale );
lapack_int LAPACKE_ztrsyl_work( int matrix_order, char trana, char tranb,
lapack_int isgn, lapack_int m, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* c, lapack_int ldc,
double* scale );
lapack_int LAPACKE_strtri_work( int matrix_order, char uplo, char diag,
lapack_int n, float* a, lapack_int lda );
lapack_int LAPACKE_dtrtri_work( int matrix_order, char uplo, char diag,
lapack_int n, double* a, lapack_int lda );
lapack_int LAPACKE_ctrtri_work( int matrix_order, char uplo, char diag,
lapack_int n, lapack_complex_float* a,
lapack_int lda );
lapack_int LAPACKE_ztrtri_work( int matrix_order, char uplo, char diag,
lapack_int n, lapack_complex_double* a,
lapack_int lda );
lapack_int LAPACKE_strtrs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int nrhs,
const float* a, lapack_int lda, float* b,
lapack_int ldb );
lapack_int LAPACKE_dtrtrs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int nrhs,
const double* a, lapack_int lda, double* b,
lapack_int ldb );
lapack_int LAPACKE_ctrtrs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int nrhs,
const lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_ztrtrs_work( int matrix_order, char uplo, char trans,
char diag, lapack_int n, lapack_int nrhs,
const lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_strttf_work( int matrix_order, char transr, char uplo,
lapack_int n, const float* a, lapack_int lda,
float* arf );
lapack_int LAPACKE_dtrttf_work( int matrix_order, char transr, char uplo,
lapack_int n, const double* a, lapack_int lda,
double* arf );
lapack_int LAPACKE_ctrttf_work( int matrix_order, char transr, char uplo,
lapack_int n, const lapack_complex_float* a,
lapack_int lda, lapack_complex_float* arf );
lapack_int LAPACKE_ztrttf_work( int matrix_order, char transr, char uplo,
lapack_int n, const lapack_complex_double* a,
lapack_int lda, lapack_complex_double* arf );
lapack_int LAPACKE_strttp_work( int matrix_order, char uplo, lapack_int n,
const float* a, lapack_int lda, float* ap );
lapack_int LAPACKE_dtrttp_work( int matrix_order, char uplo, lapack_int n,
const double* a, lapack_int lda, double* ap );
lapack_int LAPACKE_ctrttp_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
lapack_complex_float* ap );
lapack_int LAPACKE_ztrttp_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
lapack_complex_double* ap );
lapack_int LAPACKE_stzrzf_work( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* tau,
float* work, lapack_int lwork );
lapack_int LAPACKE_dtzrzf_work( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* tau,
double* work, lapack_int lwork );
lapack_int LAPACKE_ctzrzf_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* tau,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_ztzrzf_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* tau,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_cungbr_work( int matrix_order, char vect, lapack_int m,
lapack_int n, lapack_int k,
lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* tau,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zungbr_work( int matrix_order, char vect, lapack_int m,
lapack_int n, lapack_int k,
lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* tau,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_cunghr_work( int matrix_order, lapack_int n, lapack_int ilo,
lapack_int ihi, lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* tau,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zunghr_work( int matrix_order, lapack_int n, lapack_int ilo,
lapack_int ihi, lapack_complex_double* a,
lapack_int lda,
const lapack_complex_double* tau,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_cunglq_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* tau,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zunglq_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, lapack_complex_double* a,
lapack_int lda,
const lapack_complex_double* tau,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_cungql_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* tau,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zungql_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, lapack_complex_double* a,
lapack_int lda,
const lapack_complex_double* tau,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_cungqr_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* tau,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zungqr_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, lapack_complex_double* a,
lapack_int lda,
const lapack_complex_double* tau,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_cungrq_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* tau,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zungrq_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int k, lapack_complex_double* a,
lapack_int lda,
const lapack_complex_double* tau,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_cungtr_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* tau,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zungtr_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* tau,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_cunmbr_work( int matrix_order, char vect, char side,
char trans, lapack_int m, lapack_int n,
lapack_int k, const lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int ldc,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zunmbr_work( int matrix_order, char vect, char side,
char trans, lapack_int m, lapack_int n,
lapack_int k, const lapack_complex_double* a,
lapack_int lda,
const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int ldc,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_cunmhr_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int ilo,
lapack_int ihi, const lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int ldc,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zunmhr_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int ilo,
lapack_int ihi, const lapack_complex_double* a,
lapack_int lda,
const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int ldc,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_cunmlq_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int ldc,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zunmlq_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int ldc,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_cunmql_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int ldc,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zunmql_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int ldc,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_cunmqr_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int ldc,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zunmqr_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int ldc,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_cunmrq_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int ldc,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zunmrq_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int ldc,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_cunmrz_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int l, const lapack_complex_float* a,
lapack_int lda, const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int ldc,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zunmrz_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int l, const lapack_complex_double* a,
lapack_int lda,
const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int ldc,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_cunmtr_work( int matrix_order, char side, char uplo,
char trans, lapack_int m, lapack_int n,
const lapack_complex_float* a, lapack_int lda,
const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int ldc,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_zunmtr_work( int matrix_order, char side, char uplo,
char trans, lapack_int m, lapack_int n,
const lapack_complex_double* a, lapack_int lda,
const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int ldc,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_cupgtr_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_float* ap,
const lapack_complex_float* tau,
lapack_complex_float* q, lapack_int ldq,
lapack_complex_float* work );
lapack_int LAPACKE_zupgtr_work( int matrix_order, char uplo, lapack_int n,
const lapack_complex_double* ap,
const lapack_complex_double* tau,
lapack_complex_double* q, lapack_int ldq,
lapack_complex_double* work );
lapack_int LAPACKE_cupmtr_work( int matrix_order, char side, char uplo,
char trans, lapack_int m, lapack_int n,
const lapack_complex_float* ap,
const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int ldc,
lapack_complex_float* work );
lapack_int LAPACKE_zupmtr_work( int matrix_order, char side, char uplo,
char trans, lapack_int m, lapack_int n,
const lapack_complex_double* ap,
const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int ldc,
lapack_complex_double* work );
lapack_int LAPACKE_claghe( int matrix_order, lapack_int n, lapack_int k,
const float* d, lapack_complex_float* a,
lapack_int lda, lapack_int* iseed );
lapack_int LAPACKE_zlaghe( int matrix_order, lapack_int n, lapack_int k,
const double* d, lapack_complex_double* a,
lapack_int lda, lapack_int* iseed );
lapack_int LAPACKE_slagsy( int matrix_order, lapack_int n, lapack_int k,
const float* d, float* a, lapack_int lda,
lapack_int* iseed );
lapack_int LAPACKE_dlagsy( int matrix_order, lapack_int n, lapack_int k,
const double* d, double* a, lapack_int lda,
lapack_int* iseed );
lapack_int LAPACKE_clagsy( int matrix_order, lapack_int n, lapack_int k,
const float* d, lapack_complex_float* a,
lapack_int lda, lapack_int* iseed );
lapack_int LAPACKE_zlagsy( int matrix_order, lapack_int n, lapack_int k,
const double* d, lapack_complex_double* a,
lapack_int lda, lapack_int* iseed );
lapack_int LAPACKE_slapmr( int matrix_order, lapack_logical forwrd,
lapack_int m, lapack_int n, float* x, lapack_int ldx,
lapack_int* k );
lapack_int LAPACKE_dlapmr( int matrix_order, lapack_logical forwrd,
lapack_int m, lapack_int n, double* x,
lapack_int ldx, lapack_int* k );
lapack_int LAPACKE_clapmr( int matrix_order, lapack_logical forwrd,
lapack_int m, lapack_int n, lapack_complex_float* x,
lapack_int ldx, lapack_int* k );
lapack_int LAPACKE_zlapmr( int matrix_order, lapack_logical forwrd,
lapack_int m, lapack_int n, lapack_complex_double* x,
lapack_int ldx, lapack_int* k );
float LAPACKE_slapy2( float x, float y );
double LAPACKE_dlapy2( double x, double y );
float LAPACKE_slapy3( float x, float y, float z );
double LAPACKE_dlapy3( double x, double y, double z );
lapack_int LAPACKE_slartgp( float f, float g, float* cs, float* sn, float* r );
lapack_int LAPACKE_dlartgp( double f, double g, double* cs, double* sn,
double* r );
lapack_int LAPACKE_slartgs( float x, float y, float sigma, float* cs,
float* sn );
lapack_int LAPACKE_dlartgs( double x, double y, double sigma, double* cs,
double* sn );
//LAPACK 3.3.0
lapack_int LAPACKE_cbbcsd( int matrix_order, char jobu1, char jobu2,
char jobv1t, char jobv2t, char trans, lapack_int m,
lapack_int p, lapack_int q, float* theta, float* phi,
lapack_complex_float* u1, lapack_int ldu1,
lapack_complex_float* u2, lapack_int ldu2,
lapack_complex_float* v1t, lapack_int ldv1t,
lapack_complex_float* v2t, lapack_int ldv2t,
float* b11d, float* b11e, float* b12d, float* b12e,
float* b21d, float* b21e, float* b22d, float* b22e );
lapack_int LAPACKE_cbbcsd_work( int matrix_order, char jobu1, char jobu2,
char jobv1t, char jobv2t, char trans,
lapack_int m, lapack_int p, lapack_int q,
float* theta, float* phi,
lapack_complex_float* u1, lapack_int ldu1,
lapack_complex_float* u2, lapack_int ldu2,
lapack_complex_float* v1t, lapack_int ldv1t,
lapack_complex_float* v2t, lapack_int ldv2t,
float* b11d, float* b11e, float* b12d,
float* b12e, float* b21d, float* b21e,
float* b22d, float* b22e, float* rwork,
lapack_int lrwork );
lapack_int LAPACKE_cheswapr( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int i1,
lapack_int i2 );
lapack_int LAPACKE_cheswapr_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int i1,
lapack_int i2 );
lapack_int LAPACKE_chetri2( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
const lapack_int* ipiv );
lapack_int LAPACKE_chetri2_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
const lapack_int* ipiv,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_chetri2x( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
const lapack_int* ipiv, lapack_int nb );
lapack_int LAPACKE_chetri2x_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
const lapack_int* ipiv,
lapack_complex_float* work, lapack_int nb );
lapack_int LAPACKE_chetrs2( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_chetrs2_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* work );
lapack_int LAPACKE_csyconv( int matrix_order, char uplo, char way, lapack_int n,
lapack_complex_float* a, lapack_int lda,
const lapack_int* ipiv );
lapack_int LAPACKE_csyconv_work( int matrix_order, char uplo, char way,
lapack_int n, lapack_complex_float* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_float* work );
lapack_int LAPACKE_csyswapr( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int i1,
lapack_int i2 );
lapack_int LAPACKE_csyswapr_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int i1,
lapack_int i2 );
lapack_int LAPACKE_csytri2( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
const lapack_int* ipiv );
lapack_int LAPACKE_csytri2_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
const lapack_int* ipiv,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_csytri2x( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
const lapack_int* ipiv, lapack_int nb );
lapack_int LAPACKE_csytri2x_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float* a, lapack_int lda,
const lapack_int* ipiv,
lapack_complex_float* work, lapack_int nb );
lapack_int LAPACKE_csytrs2( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_csytrs2_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_float* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* work );
lapack_int LAPACKE_cunbdb( int matrix_order, char trans, char signs,
lapack_int m, lapack_int p, lapack_int q,
lapack_complex_float* x11, lapack_int ldx11,
lapack_complex_float* x12, lapack_int ldx12,
lapack_complex_float* x21, lapack_int ldx21,
lapack_complex_float* x22, lapack_int ldx22,
float* theta, float* phi,
lapack_complex_float* taup1,
lapack_complex_float* taup2,
lapack_complex_float* tauq1,
lapack_complex_float* tauq2 );
lapack_int LAPACKE_cunbdb_work( int matrix_order, char trans, char signs,
lapack_int m, lapack_int p, lapack_int q,
lapack_complex_float* x11, lapack_int ldx11,
lapack_complex_float* x12, lapack_int ldx12,
lapack_complex_float* x21, lapack_int ldx21,
lapack_complex_float* x22, lapack_int ldx22,
float* theta, float* phi,
lapack_complex_float* taup1,
lapack_complex_float* taup2,
lapack_complex_float* tauq1,
lapack_complex_float* tauq2,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_cuncsd( int matrix_order, char jobu1, char jobu2,
char jobv1t, char jobv2t, char trans, char signs,
lapack_int m, lapack_int p, lapack_int q,
lapack_complex_float* x11, lapack_int ldx11,
lapack_complex_float* x12, lapack_int ldx12,
lapack_complex_float* x21, lapack_int ldx21,
lapack_complex_float* x22, lapack_int ldx22,
float* theta, lapack_complex_float* u1,
lapack_int ldu1, lapack_complex_float* u2,
lapack_int ldu2, lapack_complex_float* v1t,
lapack_int ldv1t, lapack_complex_float* v2t,
lapack_int ldv2t );
lapack_int LAPACKE_cuncsd_work( int matrix_order, char jobu1, char jobu2,
char jobv1t, char jobv2t, char trans,
char signs, lapack_int m, lapack_int p,
lapack_int q, lapack_complex_float* x11,
lapack_int ldx11, lapack_complex_float* x12,
lapack_int ldx12, lapack_complex_float* x21,
lapack_int ldx21, lapack_complex_float* x22,
lapack_int ldx22, float* theta,
lapack_complex_float* u1, lapack_int ldu1,
lapack_complex_float* u2, lapack_int ldu2,
lapack_complex_float* v1t, lapack_int ldv1t,
lapack_complex_float* v2t, lapack_int ldv2t,
lapack_complex_float* work, lapack_int lwork,
float* rwork, lapack_int lrwork,
lapack_int* iwork );
lapack_int LAPACKE_dbbcsd( int matrix_order, char jobu1, char jobu2,
char jobv1t, char jobv2t, char trans, lapack_int m,
lapack_int p, lapack_int q, double* theta,
double* phi, double* u1, lapack_int ldu1, double* u2,
lapack_int ldu2, double* v1t, lapack_int ldv1t,
double* v2t, lapack_int ldv2t, double* b11d,
double* b11e, double* b12d, double* b12e,
double* b21d, double* b21e, double* b22d,
double* b22e );
lapack_int LAPACKE_dbbcsd_work( int matrix_order, char jobu1, char jobu2,
char jobv1t, char jobv2t, char trans,
lapack_int m, lapack_int p, lapack_int q,
double* theta, double* phi, double* u1,
lapack_int ldu1, double* u2, lapack_int ldu2,
double* v1t, lapack_int ldv1t, double* v2t,
lapack_int ldv2t, double* b11d, double* b11e,
double* b12d, double* b12e, double* b21d,
double* b21e, double* b22d, double* b22e,
double* work, lapack_int lwork );
lapack_int LAPACKE_dorbdb( int matrix_order, char trans, char signs,
lapack_int m, lapack_int p, lapack_int q,
double* x11, lapack_int ldx11, double* x12,
lapack_int ldx12, double* x21, lapack_int ldx21,
double* x22, lapack_int ldx22, double* theta,
double* phi, double* taup1, double* taup2,
double* tauq1, double* tauq2 );
lapack_int LAPACKE_dorbdb_work( int matrix_order, char trans, char signs,
lapack_int m, lapack_int p, lapack_int q,
double* x11, lapack_int ldx11, double* x12,
lapack_int ldx12, double* x21, lapack_int ldx21,
double* x22, lapack_int ldx22, double* theta,
double* phi, double* taup1, double* taup2,
double* tauq1, double* tauq2, double* work,
lapack_int lwork );
lapack_int LAPACKE_dorcsd( int matrix_order, char jobu1, char jobu2,
char jobv1t, char jobv2t, char trans, char signs,
lapack_int m, lapack_int p, lapack_int q,
double* x11, lapack_int ldx11, double* x12,
lapack_int ldx12, double* x21, lapack_int ldx21,
double* x22, lapack_int ldx22, double* theta,
double* u1, lapack_int ldu1, double* u2,
lapack_int ldu2, double* v1t, lapack_int ldv1t,
double* v2t, lapack_int ldv2t );
lapack_int LAPACKE_dorcsd_work( int matrix_order, char jobu1, char jobu2,
char jobv1t, char jobv2t, char trans,
char signs, lapack_int m, lapack_int p,
lapack_int q, double* x11, lapack_int ldx11,
double* x12, lapack_int ldx12, double* x21,
lapack_int ldx21, double* x22, lapack_int ldx22,
double* theta, double* u1, lapack_int ldu1,
double* u2, lapack_int ldu2, double* v1t,
lapack_int ldv1t, double* v2t, lapack_int ldv2t,
double* work, lapack_int lwork,
lapack_int* iwork );
lapack_int LAPACKE_dsyconv( int matrix_order, char uplo, char way, lapack_int n,
double* a, lapack_int lda, const lapack_int* ipiv );
lapack_int LAPACKE_dsyconv_work( int matrix_order, char uplo, char way,
lapack_int n, double* a, lapack_int lda,
const lapack_int* ipiv, double* work );
lapack_int LAPACKE_dsyswapr( int matrix_order, char uplo, lapack_int n,
double* a, lapack_int i1, lapack_int i2 );
lapack_int LAPACKE_dsyswapr_work( int matrix_order, char uplo, lapack_int n,
double* a, lapack_int i1, lapack_int i2 );
lapack_int LAPACKE_dsytri2( int matrix_order, char uplo, lapack_int n,
double* a, lapack_int lda, const lapack_int* ipiv );
lapack_int LAPACKE_dsytri2_work( int matrix_order, char uplo, lapack_int n,
double* a, lapack_int lda,
const lapack_int* ipiv,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_dsytri2x( int matrix_order, char uplo, lapack_int n,
double* a, lapack_int lda, const lapack_int* ipiv,
lapack_int nb );
lapack_int LAPACKE_dsytri2x_work( int matrix_order, char uplo, lapack_int n,
double* a, lapack_int lda,
const lapack_int* ipiv, double* work,
lapack_int nb );
lapack_int LAPACKE_dsytrs2( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* a, lapack_int lda,
const lapack_int* ipiv, double* b, lapack_int ldb );
lapack_int LAPACKE_dsytrs2_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const double* a,
lapack_int lda, const lapack_int* ipiv,
double* b, lapack_int ldb, double* work );
lapack_int LAPACKE_sbbcsd( int matrix_order, char jobu1, char jobu2,
char jobv1t, char jobv2t, char trans, lapack_int m,
lapack_int p, lapack_int q, float* theta, float* phi,
float* u1, lapack_int ldu1, float* u2,
lapack_int ldu2, float* v1t, lapack_int ldv1t,
float* v2t, lapack_int ldv2t, float* b11d,
float* b11e, float* b12d, float* b12e, float* b21d,
float* b21e, float* b22d, float* b22e );
lapack_int LAPACKE_sbbcsd_work( int matrix_order, char jobu1, char jobu2,
char jobv1t, char jobv2t, char trans,
lapack_int m, lapack_int p, lapack_int q,
float* theta, float* phi, float* u1,
lapack_int ldu1, float* u2, lapack_int ldu2,
float* v1t, lapack_int ldv1t, float* v2t,
lapack_int ldv2t, float* b11d, float* b11e,
float* b12d, float* b12e, float* b21d,
float* b21e, float* b22d, float* b22e,
float* work, lapack_int lwork );
lapack_int LAPACKE_sorbdb( int matrix_order, char trans, char signs,
lapack_int m, lapack_int p, lapack_int q, float* x11,
lapack_int ldx11, float* x12, lapack_int ldx12,
float* x21, lapack_int ldx21, float* x22,
lapack_int ldx22, float* theta, float* phi,
float* taup1, float* taup2, float* tauq1,
float* tauq2 );
lapack_int LAPACKE_sorbdb_work( int matrix_order, char trans, char signs,
lapack_int m, lapack_int p, lapack_int q,
float* x11, lapack_int ldx11, float* x12,
lapack_int ldx12, float* x21, lapack_int ldx21,
float* x22, lapack_int ldx22, float* theta,
float* phi, float* taup1, float* taup2,
float* tauq1, float* tauq2, float* work,
lapack_int lwork );
lapack_int LAPACKE_sorcsd( int matrix_order, char jobu1, char jobu2,
char jobv1t, char jobv2t, char trans, char signs,
lapack_int m, lapack_int p, lapack_int q, float* x11,
lapack_int ldx11, float* x12, lapack_int ldx12,
float* x21, lapack_int ldx21, float* x22,
lapack_int ldx22, float* theta, float* u1,
lapack_int ldu1, float* u2, lapack_int ldu2,
float* v1t, lapack_int ldv1t, float* v2t,
lapack_int ldv2t );
lapack_int LAPACKE_sorcsd_work( int matrix_order, char jobu1, char jobu2,
char jobv1t, char jobv2t, char trans,
char signs, lapack_int m, lapack_int p,
lapack_int q, float* x11, lapack_int ldx11,
float* x12, lapack_int ldx12, float* x21,
lapack_int ldx21, float* x22, lapack_int ldx22,
float* theta, float* u1, lapack_int ldu1,
float* u2, lapack_int ldu2, float* v1t,
lapack_int ldv1t, float* v2t, lapack_int ldv2t,
float* work, lapack_int lwork,
lapack_int* iwork );
lapack_int LAPACKE_ssyconv( int matrix_order, char uplo, char way, lapack_int n,
float* a, lapack_int lda, const lapack_int* ipiv );
lapack_int LAPACKE_ssyconv_work( int matrix_order, char uplo, char way,
lapack_int n, float* a, lapack_int lda,
const lapack_int* ipiv, float* work );
lapack_int LAPACKE_ssyswapr( int matrix_order, char uplo, lapack_int n,
float* a, lapack_int i1, lapack_int i2 );
lapack_int LAPACKE_ssyswapr_work( int matrix_order, char uplo, lapack_int n,
float* a, lapack_int i1, lapack_int i2 );
lapack_int LAPACKE_ssytri2( int matrix_order, char uplo, lapack_int n, float* a,
lapack_int lda, const lapack_int* ipiv );
lapack_int LAPACKE_ssytri2_work( int matrix_order, char uplo, lapack_int n,
float* a, lapack_int lda,
const lapack_int* ipiv,
lapack_complex_float* work, lapack_int lwork );
lapack_int LAPACKE_ssytri2x( int matrix_order, char uplo, lapack_int n,
float* a, lapack_int lda, const lapack_int* ipiv,
lapack_int nb );
lapack_int LAPACKE_ssytri2x_work( int matrix_order, char uplo, lapack_int n,
float* a, lapack_int lda,
const lapack_int* ipiv, float* work,
lapack_int nb );
lapack_int LAPACKE_ssytrs2( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* a, lapack_int lda,
const lapack_int* ipiv, float* b, lapack_int ldb );
lapack_int LAPACKE_ssytrs2_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const float* a,
lapack_int lda, const lapack_int* ipiv,
float* b, lapack_int ldb, float* work );
lapack_int LAPACKE_zbbcsd( int matrix_order, char jobu1, char jobu2,
char jobv1t, char jobv2t, char trans, lapack_int m,
lapack_int p, lapack_int q, double* theta,
double* phi, lapack_complex_double* u1,
lapack_int ldu1, lapack_complex_double* u2,
lapack_int ldu2, lapack_complex_double* v1t,
lapack_int ldv1t, lapack_complex_double* v2t,
lapack_int ldv2t, double* b11d, double* b11e,
double* b12d, double* b12e, double* b21d,
double* b21e, double* b22d, double* b22e );
lapack_int LAPACKE_zbbcsd_work( int matrix_order, char jobu1, char jobu2,
char jobv1t, char jobv2t, char trans,
lapack_int m, lapack_int p, lapack_int q,
double* theta, double* phi,
lapack_complex_double* u1, lapack_int ldu1,
lapack_complex_double* u2, lapack_int ldu2,
lapack_complex_double* v1t, lapack_int ldv1t,
lapack_complex_double* v2t, lapack_int ldv2t,
double* b11d, double* b11e, double* b12d,
double* b12e, double* b21d, double* b21e,
double* b22d, double* b22e, double* rwork,
lapack_int lrwork );
lapack_int LAPACKE_zheswapr( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int i1,
lapack_int i2 );
lapack_int LAPACKE_zheswapr_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int i1,
lapack_int i2 );
lapack_int LAPACKE_zhetri2( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
const lapack_int* ipiv );
lapack_int LAPACKE_zhetri2_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
const lapack_int* ipiv,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_zhetri2x( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
const lapack_int* ipiv, lapack_int nb );
lapack_int LAPACKE_zhetri2x_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
const lapack_int* ipiv,
lapack_complex_double* work, lapack_int nb );
lapack_int LAPACKE_zhetrs2( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_zhetrs2_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* work );
lapack_int LAPACKE_zsyconv( int matrix_order, char uplo, char way, lapack_int n,
lapack_complex_double* a, lapack_int lda,
const lapack_int* ipiv );
lapack_int LAPACKE_zsyconv_work( int matrix_order, char uplo, char way,
lapack_int n, lapack_complex_double* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_double* work );
lapack_int LAPACKE_zsyswapr( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int i1,
lapack_int i2 );
lapack_int LAPACKE_zsyswapr_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int i1,
lapack_int i2 );
lapack_int LAPACKE_zsytri2( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
const lapack_int* ipiv );
lapack_int LAPACKE_zsytri2_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
const lapack_int* ipiv,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_zsytri2x( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
const lapack_int* ipiv, lapack_int nb );
lapack_int LAPACKE_zsytri2x_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double* a, lapack_int lda,
const lapack_int* ipiv,
lapack_complex_double* work, lapack_int nb );
lapack_int LAPACKE_zsytrs2( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_zsytrs2_work( int matrix_order, char uplo, lapack_int n,
lapack_int nrhs, const lapack_complex_double* a,
lapack_int lda, const lapack_int* ipiv,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* work );
lapack_int LAPACKE_zunbdb( int matrix_order, char trans, char signs,
lapack_int m, lapack_int p, lapack_int q,
lapack_complex_double* x11, lapack_int ldx11,
lapack_complex_double* x12, lapack_int ldx12,
lapack_complex_double* x21, lapack_int ldx21,
lapack_complex_double* x22, lapack_int ldx22,
double* theta, double* phi,
lapack_complex_double* taup1,
lapack_complex_double* taup2,
lapack_complex_double* tauq1,
lapack_complex_double* tauq2 );
lapack_int LAPACKE_zunbdb_work( int matrix_order, char trans, char signs,
lapack_int m, lapack_int p, lapack_int q,
lapack_complex_double* x11, lapack_int ldx11,
lapack_complex_double* x12, lapack_int ldx12,
lapack_complex_double* x21, lapack_int ldx21,
lapack_complex_double* x22, lapack_int ldx22,
double* theta, double* phi,
lapack_complex_double* taup1,
lapack_complex_double* taup2,
lapack_complex_double* tauq1,
lapack_complex_double* tauq2,
lapack_complex_double* work, lapack_int lwork );
lapack_int LAPACKE_zuncsd( int matrix_order, char jobu1, char jobu2,
char jobv1t, char jobv2t, char trans, char signs,
lapack_int m, lapack_int p, lapack_int q,
lapack_complex_double* x11, lapack_int ldx11,
lapack_complex_double* x12, lapack_int ldx12,
lapack_complex_double* x21, lapack_int ldx21,
lapack_complex_double* x22, lapack_int ldx22,
double* theta, lapack_complex_double* u1,
lapack_int ldu1, lapack_complex_double* u2,
lapack_int ldu2, lapack_complex_double* v1t,
lapack_int ldv1t, lapack_complex_double* v2t,
lapack_int ldv2t );
lapack_int LAPACKE_zuncsd_work( int matrix_order, char jobu1, char jobu2,
char jobv1t, char jobv2t, char trans,
char signs, lapack_int m, lapack_int p,
lapack_int q, lapack_complex_double* x11,
lapack_int ldx11, lapack_complex_double* x12,
lapack_int ldx12, lapack_complex_double* x21,
lapack_int ldx21, lapack_complex_double* x22,
lapack_int ldx22, double* theta,
lapack_complex_double* u1, lapack_int ldu1,
lapack_complex_double* u2, lapack_int ldu2,
lapack_complex_double* v1t, lapack_int ldv1t,
lapack_complex_double* v2t, lapack_int ldv2t,
lapack_complex_double* work, lapack_int lwork,
double* rwork, lapack_int lrwork,
lapack_int* iwork );
//LAPACK 3.4.0
lapack_int LAPACKE_sgemqrt( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int nb, const float* v, lapack_int ldv,
const float* t, lapack_int ldt, float* c,
lapack_int ldc );
lapack_int LAPACKE_dgemqrt( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int nb, const double* v, lapack_int ldv,
const double* t, lapack_int ldt, double* c,
lapack_int ldc );
lapack_int LAPACKE_cgemqrt( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int nb, const lapack_complex_float* v,
lapack_int ldv, const lapack_complex_float* t,
lapack_int ldt, lapack_complex_float* c,
lapack_int ldc );
lapack_int LAPACKE_zgemqrt( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int nb, const lapack_complex_double* v,
lapack_int ldv, const lapack_complex_double* t,
lapack_int ldt, lapack_complex_double* c,
lapack_int ldc );
lapack_int LAPACKE_sgeqrt( int matrix_order, lapack_int m, lapack_int n,
lapack_int nb, float* a, lapack_int lda, float* t,
lapack_int ldt );
lapack_int LAPACKE_dgeqrt( int matrix_order, lapack_int m, lapack_int n,
lapack_int nb, double* a, lapack_int lda, double* t,
lapack_int ldt );
lapack_int LAPACKE_cgeqrt( int matrix_order, lapack_int m, lapack_int n,
lapack_int nb, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* t,
lapack_int ldt );
lapack_int LAPACKE_zgeqrt( int matrix_order, lapack_int m, lapack_int n,
lapack_int nb, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* t,
lapack_int ldt );
lapack_int LAPACKE_sgeqrt2( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* t,
lapack_int ldt );
lapack_int LAPACKE_dgeqrt2( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* t,
lapack_int ldt );
lapack_int LAPACKE_cgeqrt2( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* t, lapack_int ldt );
lapack_int LAPACKE_zgeqrt2( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* t, lapack_int ldt );
lapack_int LAPACKE_sgeqrt3( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* t,
lapack_int ldt );
lapack_int LAPACKE_dgeqrt3( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* t,
lapack_int ldt );
lapack_int LAPACKE_cgeqrt3( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* t, lapack_int ldt );
lapack_int LAPACKE_zgeqrt3( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* t, lapack_int ldt );
lapack_int LAPACKE_stpmqrt( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int l, lapack_int nb, const float* v,
lapack_int ldv, const float* t, lapack_int ldt,
float* a, lapack_int lda, float* b,
lapack_int ldb );
lapack_int LAPACKE_dtpmqrt( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int l, lapack_int nb, const double* v,
lapack_int ldv, const double* t, lapack_int ldt,
double* a, lapack_int lda, double* b,
lapack_int ldb );
lapack_int LAPACKE_ctpmqrt( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int l, lapack_int nb,
const lapack_complex_float* v, lapack_int ldv,
const lapack_complex_float* t, lapack_int ldt,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb );
lapack_int LAPACKE_ztpmqrt( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int l, lapack_int nb,
const lapack_complex_double* v, lapack_int ldv,
const lapack_complex_double* t, lapack_int ldt,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb );
lapack_int LAPACKE_dtpqrt( int matrix_order, lapack_int m, lapack_int n,
lapack_int l, lapack_int nb, double* a,
lapack_int lda, double* b, lapack_int ldb, double* t,
lapack_int ldt );
lapack_int LAPACKE_ctpqrt( int matrix_order, lapack_int m, lapack_int n,
lapack_int l, lapack_int nb, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* t,
lapack_complex_float* b, lapack_int ldb,
lapack_int ldt );
lapack_int LAPACKE_ztpqrt( int matrix_order, lapack_int m, lapack_int n,
lapack_int l, lapack_int nb,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* t, lapack_int ldt );
lapack_int LAPACKE_stpqrt2( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* b, lapack_int ldb,
float* t, lapack_int ldt );
lapack_int LAPACKE_dtpqrt2( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* b,
lapack_int ldb, double* t, lapack_int ldt );
lapack_int LAPACKE_ctpqrt2( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* t, lapack_int ldt );
lapack_int LAPACKE_ztpqrt2( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* t, lapack_int ldt );
lapack_int LAPACKE_stprfb( int matrix_order, char side, char trans, char direct,
char storev, lapack_int m, lapack_int n,
lapack_int k, lapack_int l, const float* v,
lapack_int ldv, const float* t, lapack_int ldt,
float* a, lapack_int lda, float* b, lapack_int ldb,
lapack_int myldwork );
lapack_int LAPACKE_dtprfb( int matrix_order, char side, char trans, char direct,
char storev, lapack_int m, lapack_int n,
lapack_int k, lapack_int l, const double* v,
lapack_int ldv, const double* t, lapack_int ldt,
double* a, lapack_int lda, double* b, lapack_int ldb,
lapack_int myldwork );
lapack_int LAPACKE_ctprfb( int matrix_order, char side, char trans, char direct,
char storev, lapack_int m, lapack_int n,
lapack_int k, lapack_int l,
const lapack_complex_float* v, lapack_int ldv,
const lapack_complex_float* t, lapack_int ldt,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
lapack_int myldwork );
lapack_int LAPACKE_ztprfb( int matrix_order, char side, char trans, char direct,
char storev, lapack_int m, lapack_int n,
lapack_int k, lapack_int l,
const lapack_complex_double* v, lapack_int ldv,
const lapack_complex_double* t, lapack_int ldt,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
lapack_int myldwork );
lapack_int LAPACKE_sgemqrt_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int nb, const float* v, lapack_int ldv,
const float* t, lapack_int ldt, float* c,
lapack_int ldc, float* work );
lapack_int LAPACKE_dgemqrt_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int nb, const double* v, lapack_int ldv,
const double* t, lapack_int ldt, double* c,
lapack_int ldc, double* work );
lapack_int LAPACKE_cgemqrt_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int nb, const lapack_complex_float* v,
lapack_int ldv, const lapack_complex_float* t,
lapack_int ldt, lapack_complex_float* c,
lapack_int ldc, lapack_complex_float* work );
lapack_int LAPACKE_zgemqrt_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int nb, const lapack_complex_double* v,
lapack_int ldv, const lapack_complex_double* t,
lapack_int ldt, lapack_complex_double* c,
lapack_int ldc, lapack_complex_double* work );
lapack_int LAPACKE_sgeqrt_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int nb, float* a, lapack_int lda,
float* t, lapack_int ldt, float* work );
lapack_int LAPACKE_dgeqrt_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int nb, double* a, lapack_int lda,
double* t, lapack_int ldt, double* work );
lapack_int LAPACKE_cgeqrt_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int nb, lapack_complex_float* a,
lapack_int lda, lapack_complex_float* t,
lapack_int ldt, lapack_complex_float* work );
lapack_int LAPACKE_zgeqrt_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int nb, lapack_complex_double* a,
lapack_int lda, lapack_complex_double* t,
lapack_int ldt, lapack_complex_double* work );
lapack_int LAPACKE_sgeqrt2_work( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* t,
lapack_int ldt );
lapack_int LAPACKE_dgeqrt2_work( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* t,
lapack_int ldt );
lapack_int LAPACKE_cgeqrt2_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* t, lapack_int ldt );
lapack_int LAPACKE_zgeqrt2_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* t, lapack_int ldt );
lapack_int LAPACKE_sgeqrt3_work( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* t,
lapack_int ldt );
lapack_int LAPACKE_dgeqrt3_work( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* t,
lapack_int ldt );
lapack_int LAPACKE_cgeqrt3_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* t, lapack_int ldt );
lapack_int LAPACKE_zgeqrt3_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* t, lapack_int ldt );
lapack_int LAPACKE_stpmqrt_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int l, lapack_int nb, const float* v,
lapack_int ldv, const float* t, lapack_int ldt,
float* a, lapack_int lda, float* b,
lapack_int ldb, float* work );
lapack_int LAPACKE_dtpmqrt_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int l, lapack_int nb, const double* v,
lapack_int ldv, const double* t,
lapack_int ldt, double* a, lapack_int lda,
double* b, lapack_int ldb, double* work );
lapack_int LAPACKE_ctpmqrt_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int l, lapack_int nb,
const lapack_complex_float* v, lapack_int ldv,
const lapack_complex_float* t, lapack_int ldt,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* work );
lapack_int LAPACKE_ztpmqrt_work( int matrix_order, char side, char trans,
lapack_int m, lapack_int n, lapack_int k,
lapack_int l, lapack_int nb,
const lapack_complex_double* v, lapack_int ldv,
const lapack_complex_double* t, lapack_int ldt,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* work );
lapack_int LAPACKE_dtpqrt_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int l, lapack_int nb, double* a,
lapack_int lda, double* b, lapack_int ldb,
double* t, lapack_int ldt, double* work );
lapack_int LAPACKE_ctpqrt_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int l, lapack_int nb,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* t,
lapack_complex_float* b, lapack_int ldb,
lapack_int ldt, lapack_complex_float* work );
lapack_int LAPACKE_ztpqrt_work( int matrix_order, lapack_int m, lapack_int n,
lapack_int l, lapack_int nb,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* t, lapack_int ldt,
lapack_complex_double* work );
lapack_int LAPACKE_stpqrt2_work( int matrix_order, lapack_int m, lapack_int n,
float* a, lapack_int lda, float* b,
lapack_int ldb, float* t, lapack_int ldt );
lapack_int LAPACKE_dtpqrt2_work( int matrix_order, lapack_int m, lapack_int n,
double* a, lapack_int lda, double* b,
lapack_int ldb, double* t, lapack_int ldt );
lapack_int LAPACKE_ctpqrt2_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
lapack_complex_float* t, lapack_int ldt );
lapack_int LAPACKE_ztpqrt2_work( int matrix_order, lapack_int m, lapack_int n,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
lapack_complex_double* t, lapack_int ldt );
lapack_int LAPACKE_stprfb_work( int matrix_order, char side, char trans,
char direct, char storev, lapack_int m,
lapack_int n, lapack_int k, lapack_int l,
const float* v, lapack_int ldv, const float* t,
lapack_int ldt, float* a, lapack_int lda,
float* b, lapack_int ldb, const float* mywork,
lapack_int myldwork );
lapack_int LAPACKE_dtprfb_work( int matrix_order, char side, char trans,
char direct, char storev, lapack_int m,
lapack_int n, lapack_int k, lapack_int l,
const double* v, lapack_int ldv,
const double* t, lapack_int ldt, double* a,
lapack_int lda, double* b, lapack_int ldb,
const double* mywork, lapack_int myldwork );
lapack_int LAPACKE_ctprfb_work( int matrix_order, char side, char trans,
char direct, char storev, lapack_int m,
lapack_int n, lapack_int k, lapack_int l,
const lapack_complex_float* v, lapack_int ldv,
const lapack_complex_float* t, lapack_int ldt,
lapack_complex_float* a, lapack_int lda,
lapack_complex_float* b, lapack_int ldb,
const float* mywork, lapack_int myldwork );
lapack_int LAPACKE_ztprfb_work( int matrix_order, char side, char trans,
char direct, char storev, lapack_int m,
lapack_int n, lapack_int k, lapack_int l,
const lapack_complex_double* v, lapack_int ldv,
const lapack_complex_double* t, lapack_int ldt,
lapack_complex_double* a, lapack_int lda,
lapack_complex_double* b, lapack_int ldb,
const double* mywork, lapack_int myldwork );
//LAPACK 3.X.X
lapack_int LAPACKE_csyr( int matrix_order, char uplo, lapack_int n,
lapack_complex_float alpha,
const lapack_complex_float* x, lapack_int incx,
lapack_complex_float* a, lapack_int lda );
lapack_int LAPACKE_zsyr( int matrix_order, char uplo, lapack_int n,
lapack_complex_double alpha,
const lapack_complex_double* x, lapack_int incx,
lapack_complex_double* a, lapack_int lda );
lapack_int LAPACKE_csyr_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_float alpha,
const lapack_complex_float* x,
lapack_int incx, lapack_complex_float* a,
lapack_int lda );
lapack_int LAPACKE_zsyr_work( int matrix_order, char uplo, lapack_int n,
lapack_complex_double alpha,
const lapack_complex_double* x,
lapack_int incx, lapack_complex_double* a,
lapack_int lda );
#define LAPACK_sgetrf LAPACK_GLOBAL(sgetrf,SGETRF)
#define LAPACK_dgetrf LAPACK_GLOBAL(dgetrf,DGETRF)
#define LAPACK_cgetrf LAPACK_GLOBAL(cgetrf,CGETRF)
#define LAPACK_zgetrf LAPACK_GLOBAL(zgetrf,ZGETRF)
#define LAPACK_sgbtrf LAPACK_GLOBAL(sgbtrf,SGBTRF)
#define LAPACK_dgbtrf LAPACK_GLOBAL(dgbtrf,DGBTRF)
#define LAPACK_cgbtrf LAPACK_GLOBAL(cgbtrf,CGBTRF)
#define LAPACK_zgbtrf LAPACK_GLOBAL(zgbtrf,ZGBTRF)
#define LAPACK_sgttrf LAPACK_GLOBAL(sgttrf,SGTTRF)
#define LAPACK_dgttrf LAPACK_GLOBAL(dgttrf,DGTTRF)
#define LAPACK_cgttrf LAPACK_GLOBAL(cgttrf,CGTTRF)
#define LAPACK_zgttrf LAPACK_GLOBAL(zgttrf,ZGTTRF)
#define LAPACK_spotrf LAPACK_GLOBAL(spotrf,SPOTRF)
#define LAPACK_dpotrf LAPACK_GLOBAL(dpotrf,DPOTRF)
#define LAPACK_cpotrf LAPACK_GLOBAL(cpotrf,CPOTRF)
#define LAPACK_zpotrf LAPACK_GLOBAL(zpotrf,ZPOTRF)
#define LAPACK_dpstrf LAPACK_GLOBAL(dpstrf,DPSTRF)
#define LAPACK_spstrf LAPACK_GLOBAL(spstrf,SPSTRF)
#define LAPACK_zpstrf LAPACK_GLOBAL(zpstrf,ZPSTRF)
#define LAPACK_cpstrf LAPACK_GLOBAL(cpstrf,CPSTRF)
#define LAPACK_dpftrf LAPACK_GLOBAL(dpftrf,DPFTRF)
#define LAPACK_spftrf LAPACK_GLOBAL(spftrf,SPFTRF)
#define LAPACK_zpftrf LAPACK_GLOBAL(zpftrf,ZPFTRF)
#define LAPACK_cpftrf LAPACK_GLOBAL(cpftrf,CPFTRF)
#define LAPACK_spptrf LAPACK_GLOBAL(spptrf,SPPTRF)
#define LAPACK_dpptrf LAPACK_GLOBAL(dpptrf,DPPTRF)
#define LAPACK_cpptrf LAPACK_GLOBAL(cpptrf,CPPTRF)
#define LAPACK_zpptrf LAPACK_GLOBAL(zpptrf,ZPPTRF)
#define LAPACK_spbtrf LAPACK_GLOBAL(spbtrf,SPBTRF)
#define LAPACK_dpbtrf LAPACK_GLOBAL(dpbtrf,DPBTRF)
#define LAPACK_cpbtrf LAPACK_GLOBAL(cpbtrf,CPBTRF)
#define LAPACK_zpbtrf LAPACK_GLOBAL(zpbtrf,ZPBTRF)
#define LAPACK_spttrf LAPACK_GLOBAL(spttrf,SPTTRF)
#define LAPACK_dpttrf LAPACK_GLOBAL(dpttrf,DPTTRF)
#define LAPACK_cpttrf LAPACK_GLOBAL(cpttrf,CPTTRF)
#define LAPACK_zpttrf LAPACK_GLOBAL(zpttrf,ZPTTRF)
#define LAPACK_ssytrf LAPACK_GLOBAL(ssytrf,SSYTRF)
#define LAPACK_dsytrf LAPACK_GLOBAL(dsytrf,DSYTRF)
#define LAPACK_csytrf LAPACK_GLOBAL(csytrf,CSYTRF)
#define LAPACK_zsytrf LAPACK_GLOBAL(zsytrf,ZSYTRF)
#define LAPACK_chetrf LAPACK_GLOBAL(chetrf,CHETRF)
#define LAPACK_zhetrf LAPACK_GLOBAL(zhetrf,ZHETRF)
#define LAPACK_ssptrf LAPACK_GLOBAL(ssptrf,SSPTRF)
#define LAPACK_dsptrf LAPACK_GLOBAL(dsptrf,DSPTRF)
#define LAPACK_csptrf LAPACK_GLOBAL(csptrf,CSPTRF)
#define LAPACK_zsptrf LAPACK_GLOBAL(zsptrf,ZSPTRF)
#define LAPACK_chptrf LAPACK_GLOBAL(chptrf,CHPTRF)
#define LAPACK_zhptrf LAPACK_GLOBAL(zhptrf,ZHPTRF)
#define LAPACK_sgetrs LAPACK_GLOBAL(sgetrs,SGETRS)
#define LAPACK_dgetrs LAPACK_GLOBAL(dgetrs,DGETRS)
#define LAPACK_cgetrs LAPACK_GLOBAL(cgetrs,CGETRS)
#define LAPACK_zgetrs LAPACK_GLOBAL(zgetrs,ZGETRS)
#define LAPACK_sgbtrs LAPACK_GLOBAL(sgbtrs,SGBTRS)
#define LAPACK_dgbtrs LAPACK_GLOBAL(dgbtrs,DGBTRS)
#define LAPACK_cgbtrs LAPACK_GLOBAL(cgbtrs,CGBTRS)
#define LAPACK_zgbtrs LAPACK_GLOBAL(zgbtrs,ZGBTRS)
#define LAPACK_sgttrs LAPACK_GLOBAL(sgttrs,SGTTRS)
#define LAPACK_dgttrs LAPACK_GLOBAL(dgttrs,DGTTRS)
#define LAPACK_cgttrs LAPACK_GLOBAL(cgttrs,CGTTRS)
#define LAPACK_zgttrs LAPACK_GLOBAL(zgttrs,ZGTTRS)
#define LAPACK_spotrs LAPACK_GLOBAL(spotrs,SPOTRS)
#define LAPACK_dpotrs LAPACK_GLOBAL(dpotrs,DPOTRS)
#define LAPACK_cpotrs LAPACK_GLOBAL(cpotrs,CPOTRS)
#define LAPACK_zpotrs LAPACK_GLOBAL(zpotrs,ZPOTRS)
#define LAPACK_dpftrs LAPACK_GLOBAL(dpftrs,DPFTRS)
#define LAPACK_spftrs LAPACK_GLOBAL(spftrs,SPFTRS)
#define LAPACK_zpftrs LAPACK_GLOBAL(zpftrs,ZPFTRS)
#define LAPACK_cpftrs LAPACK_GLOBAL(cpftrs,CPFTRS)
#define LAPACK_spptrs LAPACK_GLOBAL(spptrs,SPPTRS)
#define LAPACK_dpptrs LAPACK_GLOBAL(dpptrs,DPPTRS)
#define LAPACK_cpptrs LAPACK_GLOBAL(cpptrs,CPPTRS)
#define LAPACK_zpptrs LAPACK_GLOBAL(zpptrs,ZPPTRS)
#define LAPACK_spbtrs LAPACK_GLOBAL(spbtrs,SPBTRS)
#define LAPACK_dpbtrs LAPACK_GLOBAL(dpbtrs,DPBTRS)
#define LAPACK_cpbtrs LAPACK_GLOBAL(cpbtrs,CPBTRS)
#define LAPACK_zpbtrs LAPACK_GLOBAL(zpbtrs,ZPBTRS)
#define LAPACK_spttrs LAPACK_GLOBAL(spttrs,SPTTRS)
#define LAPACK_dpttrs LAPACK_GLOBAL(dpttrs,DPTTRS)
#define LAPACK_cpttrs LAPACK_GLOBAL(cpttrs,CPTTRS)
#define LAPACK_zpttrs LAPACK_GLOBAL(zpttrs,ZPTTRS)
#define LAPACK_ssytrs LAPACK_GLOBAL(ssytrs,SSYTRS)
#define LAPACK_dsytrs LAPACK_GLOBAL(dsytrs,DSYTRS)
#define LAPACK_csytrs LAPACK_GLOBAL(csytrs,CSYTRS)
#define LAPACK_zsytrs LAPACK_GLOBAL(zsytrs,ZSYTRS)
#define LAPACK_chetrs LAPACK_GLOBAL(chetrs,CHETRS)
#define LAPACK_zhetrs LAPACK_GLOBAL(zhetrs,ZHETRS)
#define LAPACK_ssptrs LAPACK_GLOBAL(ssptrs,SSPTRS)
#define LAPACK_dsptrs LAPACK_GLOBAL(dsptrs,DSPTRS)
#define LAPACK_csptrs LAPACK_GLOBAL(csptrs,CSPTRS)
#define LAPACK_zsptrs LAPACK_GLOBAL(zsptrs,ZSPTRS)
#define LAPACK_chptrs LAPACK_GLOBAL(chptrs,CHPTRS)
#define LAPACK_zhptrs LAPACK_GLOBAL(zhptrs,ZHPTRS)
#define LAPACK_strtrs LAPACK_GLOBAL(strtrs,STRTRS)
#define LAPACK_dtrtrs LAPACK_GLOBAL(dtrtrs,DTRTRS)
#define LAPACK_ctrtrs LAPACK_GLOBAL(ctrtrs,CTRTRS)
#define LAPACK_ztrtrs LAPACK_GLOBAL(ztrtrs,ZTRTRS)
#define LAPACK_stptrs LAPACK_GLOBAL(stptrs,STPTRS)
#define LAPACK_dtptrs LAPACK_GLOBAL(dtptrs,DTPTRS)
#define LAPACK_ctptrs LAPACK_GLOBAL(ctptrs,CTPTRS)
#define LAPACK_ztptrs LAPACK_GLOBAL(ztptrs,ZTPTRS)
#define LAPACK_stbtrs LAPACK_GLOBAL(stbtrs,STBTRS)
#define LAPACK_dtbtrs LAPACK_GLOBAL(dtbtrs,DTBTRS)
#define LAPACK_ctbtrs LAPACK_GLOBAL(ctbtrs,CTBTRS)
#define LAPACK_ztbtrs LAPACK_GLOBAL(ztbtrs,ZTBTRS)
#define LAPACK_sgecon LAPACK_GLOBAL(sgecon,SGECON)
#define LAPACK_dgecon LAPACK_GLOBAL(dgecon,DGECON)
#define LAPACK_cgecon LAPACK_GLOBAL(cgecon,CGECON)
#define LAPACK_zgecon LAPACK_GLOBAL(zgecon,ZGECON)
#define LAPACK_sgbcon LAPACK_GLOBAL(sgbcon,SGBCON)
#define LAPACK_dgbcon LAPACK_GLOBAL(dgbcon,DGBCON)
#define LAPACK_cgbcon LAPACK_GLOBAL(cgbcon,CGBCON)
#define LAPACK_zgbcon LAPACK_GLOBAL(zgbcon,ZGBCON)
#define LAPACK_sgtcon LAPACK_GLOBAL(sgtcon,SGTCON)
#define LAPACK_dgtcon LAPACK_GLOBAL(dgtcon,DGTCON)
#define LAPACK_cgtcon LAPACK_GLOBAL(cgtcon,CGTCON)
#define LAPACK_zgtcon LAPACK_GLOBAL(zgtcon,ZGTCON)
#define LAPACK_spocon LAPACK_GLOBAL(spocon,SPOCON)
#define LAPACK_dpocon LAPACK_GLOBAL(dpocon,DPOCON)
#define LAPACK_cpocon LAPACK_GLOBAL(cpocon,CPOCON)
#define LAPACK_zpocon LAPACK_GLOBAL(zpocon,ZPOCON)
#define LAPACK_sppcon LAPACK_GLOBAL(sppcon,SPPCON)
#define LAPACK_dppcon LAPACK_GLOBAL(dppcon,DPPCON)
#define LAPACK_cppcon LAPACK_GLOBAL(cppcon,CPPCON)
#define LAPACK_zppcon LAPACK_GLOBAL(zppcon,ZPPCON)
#define LAPACK_spbcon LAPACK_GLOBAL(spbcon,SPBCON)
#define LAPACK_dpbcon LAPACK_GLOBAL(dpbcon,DPBCON)
#define LAPACK_cpbcon LAPACK_GLOBAL(cpbcon,CPBCON)
#define LAPACK_zpbcon LAPACK_GLOBAL(zpbcon,ZPBCON)
#define LAPACK_sptcon LAPACK_GLOBAL(sptcon,SPTCON)
#define LAPACK_dptcon LAPACK_GLOBAL(dptcon,DPTCON)
#define LAPACK_cptcon LAPACK_GLOBAL(cptcon,CPTCON)
#define LAPACK_zptcon LAPACK_GLOBAL(zptcon,ZPTCON)
#define LAPACK_ssycon LAPACK_GLOBAL(ssycon,SSYCON)
#define LAPACK_dsycon LAPACK_GLOBAL(dsycon,DSYCON)
#define LAPACK_csycon LAPACK_GLOBAL(csycon,CSYCON)
#define LAPACK_zsycon LAPACK_GLOBAL(zsycon,ZSYCON)
#define LAPACK_checon LAPACK_GLOBAL(checon,CHECON)
#define LAPACK_zhecon LAPACK_GLOBAL(zhecon,ZHECON)
#define LAPACK_sspcon LAPACK_GLOBAL(sspcon,SSPCON)
#define LAPACK_dspcon LAPACK_GLOBAL(dspcon,DSPCON)
#define LAPACK_cspcon LAPACK_GLOBAL(cspcon,CSPCON)
#define LAPACK_zspcon LAPACK_GLOBAL(zspcon,ZSPCON)
#define LAPACK_chpcon LAPACK_GLOBAL(chpcon,CHPCON)
#define LAPACK_zhpcon LAPACK_GLOBAL(zhpcon,ZHPCON)
#define LAPACK_strcon LAPACK_GLOBAL(strcon,STRCON)
#define LAPACK_dtrcon LAPACK_GLOBAL(dtrcon,DTRCON)
#define LAPACK_ctrcon LAPACK_GLOBAL(ctrcon,CTRCON)
#define LAPACK_ztrcon LAPACK_GLOBAL(ztrcon,ZTRCON)
#define LAPACK_stpcon LAPACK_GLOBAL(stpcon,STPCON)
#define LAPACK_dtpcon LAPACK_GLOBAL(dtpcon,DTPCON)
#define LAPACK_ctpcon LAPACK_GLOBAL(ctpcon,CTPCON)
#define LAPACK_ztpcon LAPACK_GLOBAL(ztpcon,ZTPCON)
#define LAPACK_stbcon LAPACK_GLOBAL(stbcon,STBCON)
#define LAPACK_dtbcon LAPACK_GLOBAL(dtbcon,DTBCON)
#define LAPACK_ctbcon LAPACK_GLOBAL(ctbcon,CTBCON)
#define LAPACK_ztbcon LAPACK_GLOBAL(ztbcon,ZTBCON)
#define LAPACK_sgerfs LAPACK_GLOBAL(sgerfs,SGERFS)
#define LAPACK_dgerfs LAPACK_GLOBAL(dgerfs,DGERFS)
#define LAPACK_cgerfs LAPACK_GLOBAL(cgerfs,CGERFS)
#define LAPACK_zgerfs LAPACK_GLOBAL(zgerfs,ZGERFS)
#define LAPACK_dgerfsx LAPACK_GLOBAL(dgerfsx,DGERFSX)
#define LAPACK_sgerfsx LAPACK_GLOBAL(sgerfsx,SGERFSX)
#define LAPACK_zgerfsx LAPACK_GLOBAL(zgerfsx,ZGERFSX)
#define LAPACK_cgerfsx LAPACK_GLOBAL(cgerfsx,CGERFSX)
#define LAPACK_sgbrfs LAPACK_GLOBAL(sgbrfs,SGBRFS)
#define LAPACK_dgbrfs LAPACK_GLOBAL(dgbrfs,DGBRFS)
#define LAPACK_cgbrfs LAPACK_GLOBAL(cgbrfs,CGBRFS)
#define LAPACK_zgbrfs LAPACK_GLOBAL(zgbrfs,ZGBRFS)
#define LAPACK_dgbrfsx LAPACK_GLOBAL(dgbrfsx,DGBRFSX)
#define LAPACK_sgbrfsx LAPACK_GLOBAL(sgbrfsx,SGBRFSX)
#define LAPACK_zgbrfsx LAPACK_GLOBAL(zgbrfsx,ZGBRFSX)
#define LAPACK_cgbrfsx LAPACK_GLOBAL(cgbrfsx,CGBRFSX)
#define LAPACK_sgtrfs LAPACK_GLOBAL(sgtrfs,SGTRFS)
#define LAPACK_dgtrfs LAPACK_GLOBAL(dgtrfs,DGTRFS)
#define LAPACK_cgtrfs LAPACK_GLOBAL(cgtrfs,CGTRFS)
#define LAPACK_zgtrfs LAPACK_GLOBAL(zgtrfs,ZGTRFS)
#define LAPACK_sporfs LAPACK_GLOBAL(sporfs,SPORFS)
#define LAPACK_dporfs LAPACK_GLOBAL(dporfs,DPORFS)
#define LAPACK_cporfs LAPACK_GLOBAL(cporfs,CPORFS)
#define LAPACK_zporfs LAPACK_GLOBAL(zporfs,ZPORFS)
#define LAPACK_dporfsx LAPACK_GLOBAL(dporfsx,DPORFSX)
#define LAPACK_sporfsx LAPACK_GLOBAL(sporfsx,SPORFSX)
#define LAPACK_zporfsx LAPACK_GLOBAL(zporfsx,ZPORFSX)
#define LAPACK_cporfsx LAPACK_GLOBAL(cporfsx,CPORFSX)
#define LAPACK_spprfs LAPACK_GLOBAL(spprfs,SPPRFS)
#define LAPACK_dpprfs LAPACK_GLOBAL(dpprfs,DPPRFS)
#define LAPACK_cpprfs LAPACK_GLOBAL(cpprfs,CPPRFS)
#define LAPACK_zpprfs LAPACK_GLOBAL(zpprfs,ZPPRFS)
#define LAPACK_spbrfs LAPACK_GLOBAL(spbrfs,SPBRFS)
#define LAPACK_dpbrfs LAPACK_GLOBAL(dpbrfs,DPBRFS)
#define LAPACK_cpbrfs LAPACK_GLOBAL(cpbrfs,CPBRFS)
#define LAPACK_zpbrfs LAPACK_GLOBAL(zpbrfs,ZPBRFS)
#define LAPACK_sptrfs LAPACK_GLOBAL(sptrfs,SPTRFS)
#define LAPACK_dptrfs LAPACK_GLOBAL(dptrfs,DPTRFS)
#define LAPACK_cptrfs LAPACK_GLOBAL(cptrfs,CPTRFS)
#define LAPACK_zptrfs LAPACK_GLOBAL(zptrfs,ZPTRFS)
#define LAPACK_ssyrfs LAPACK_GLOBAL(ssyrfs,SSYRFS)
#define LAPACK_dsyrfs LAPACK_GLOBAL(dsyrfs,DSYRFS)
#define LAPACK_csyrfs LAPACK_GLOBAL(csyrfs,CSYRFS)
#define LAPACK_zsyrfs LAPACK_GLOBAL(zsyrfs,ZSYRFS)
#define LAPACK_dsyrfsx LAPACK_GLOBAL(dsyrfsx,DSYRFSX)
#define LAPACK_ssyrfsx LAPACK_GLOBAL(ssyrfsx,SSYRFSX)
#define LAPACK_zsyrfsx LAPACK_GLOBAL(zsyrfsx,ZSYRFSX)
#define LAPACK_csyrfsx LAPACK_GLOBAL(csyrfsx,CSYRFSX)
#define LAPACK_cherfs LAPACK_GLOBAL(cherfs,CHERFS)
#define LAPACK_zherfs LAPACK_GLOBAL(zherfs,ZHERFS)
#define LAPACK_zherfsx LAPACK_GLOBAL(zherfsx,ZHERFSX)
#define LAPACK_cherfsx LAPACK_GLOBAL(cherfsx,CHERFSX)
#define LAPACK_ssprfs LAPACK_GLOBAL(ssprfs,SSPRFS)
#define LAPACK_dsprfs LAPACK_GLOBAL(dsprfs,DSPRFS)
#define LAPACK_csprfs LAPACK_GLOBAL(csprfs,CSPRFS)
#define LAPACK_zsprfs LAPACK_GLOBAL(zsprfs,ZSPRFS)
#define LAPACK_chprfs LAPACK_GLOBAL(chprfs,CHPRFS)
#define LAPACK_zhprfs LAPACK_GLOBAL(zhprfs,ZHPRFS)
#define LAPACK_strrfs LAPACK_GLOBAL(strrfs,STRRFS)
#define LAPACK_dtrrfs LAPACK_GLOBAL(dtrrfs,DTRRFS)
#define LAPACK_ctrrfs LAPACK_GLOBAL(ctrrfs,CTRRFS)
#define LAPACK_ztrrfs LAPACK_GLOBAL(ztrrfs,ZTRRFS)
#define LAPACK_stprfs LAPACK_GLOBAL(stprfs,STPRFS)
#define LAPACK_dtprfs LAPACK_GLOBAL(dtprfs,DTPRFS)
#define LAPACK_ctprfs LAPACK_GLOBAL(ctprfs,CTPRFS)
#define LAPACK_ztprfs LAPACK_GLOBAL(ztprfs,ZTPRFS)
#define LAPACK_stbrfs LAPACK_GLOBAL(stbrfs,STBRFS)
#define LAPACK_dtbrfs LAPACK_GLOBAL(dtbrfs,DTBRFS)
#define LAPACK_ctbrfs LAPACK_GLOBAL(ctbrfs,CTBRFS)
#define LAPACK_ztbrfs LAPACK_GLOBAL(ztbrfs,ZTBRFS)
#define LAPACK_sgetri LAPACK_GLOBAL(sgetri,SGETRI)
#define LAPACK_dgetri LAPACK_GLOBAL(dgetri,DGETRI)
#define LAPACK_cgetri LAPACK_GLOBAL(cgetri,CGETRI)
#define LAPACK_zgetri LAPACK_GLOBAL(zgetri,ZGETRI)
#define LAPACK_spotri LAPACK_GLOBAL(spotri,SPOTRI)
#define LAPACK_dpotri LAPACK_GLOBAL(dpotri,DPOTRI)
#define LAPACK_cpotri LAPACK_GLOBAL(cpotri,CPOTRI)
#define LAPACK_zpotri LAPACK_GLOBAL(zpotri,ZPOTRI)
#define LAPACK_dpftri LAPACK_GLOBAL(dpftri,DPFTRI)
#define LAPACK_spftri LAPACK_GLOBAL(spftri,SPFTRI)
#define LAPACK_zpftri LAPACK_GLOBAL(zpftri,ZPFTRI)
#define LAPACK_cpftri LAPACK_GLOBAL(cpftri,CPFTRI)
#define LAPACK_spptri LAPACK_GLOBAL(spptri,SPPTRI)
#define LAPACK_dpptri LAPACK_GLOBAL(dpptri,DPPTRI)
#define LAPACK_cpptri LAPACK_GLOBAL(cpptri,CPPTRI)
#define LAPACK_zpptri LAPACK_GLOBAL(zpptri,ZPPTRI)
#define LAPACK_ssytri LAPACK_GLOBAL(ssytri,SSYTRI)
#define LAPACK_dsytri LAPACK_GLOBAL(dsytri,DSYTRI)
#define LAPACK_csytri LAPACK_GLOBAL(csytri,CSYTRI)
#define LAPACK_zsytri LAPACK_GLOBAL(zsytri,ZSYTRI)
#define LAPACK_chetri LAPACK_GLOBAL(chetri,CHETRI)
#define LAPACK_zhetri LAPACK_GLOBAL(zhetri,ZHETRI)
#define LAPACK_ssptri LAPACK_GLOBAL(ssptri,SSPTRI)
#define LAPACK_dsptri LAPACK_GLOBAL(dsptri,DSPTRI)
#define LAPACK_csptri LAPACK_GLOBAL(csptri,CSPTRI)
#define LAPACK_zsptri LAPACK_GLOBAL(zsptri,ZSPTRI)
#define LAPACK_chptri LAPACK_GLOBAL(chptri,CHPTRI)
#define LAPACK_zhptri LAPACK_GLOBAL(zhptri,ZHPTRI)
#define LAPACK_strtri LAPACK_GLOBAL(strtri,STRTRI)
#define LAPACK_dtrtri LAPACK_GLOBAL(dtrtri,DTRTRI)
#define LAPACK_ctrtri LAPACK_GLOBAL(ctrtri,CTRTRI)
#define LAPACK_ztrtri LAPACK_GLOBAL(ztrtri,ZTRTRI)
#define LAPACK_dtftri LAPACK_GLOBAL(dtftri,DTFTRI)
#define LAPACK_stftri LAPACK_GLOBAL(stftri,STFTRI)
#define LAPACK_ztftri LAPACK_GLOBAL(ztftri,ZTFTRI)
#define LAPACK_ctftri LAPACK_GLOBAL(ctftri,CTFTRI)
#define LAPACK_stptri LAPACK_GLOBAL(stptri,STPTRI)
#define LAPACK_dtptri LAPACK_GLOBAL(dtptri,DTPTRI)
#define LAPACK_ctptri LAPACK_GLOBAL(ctptri,CTPTRI)
#define LAPACK_ztptri LAPACK_GLOBAL(ztptri,ZTPTRI)
#define LAPACK_sgeequ LAPACK_GLOBAL(sgeequ,SGEEQU)
#define LAPACK_dgeequ LAPACK_GLOBAL(dgeequ,DGEEQU)
#define LAPACK_cgeequ LAPACK_GLOBAL(cgeequ,CGEEQU)
#define LAPACK_zgeequ LAPACK_GLOBAL(zgeequ,ZGEEQU)
#define LAPACK_dgeequb LAPACK_GLOBAL(dgeequb,DGEEQUB)
#define LAPACK_sgeequb LAPACK_GLOBAL(sgeequb,SGEEQUB)
#define LAPACK_zgeequb LAPACK_GLOBAL(zgeequb,ZGEEQUB)
#define LAPACK_cgeequb LAPACK_GLOBAL(cgeequb,CGEEQUB)
#define LAPACK_sgbequ LAPACK_GLOBAL(sgbequ,SGBEQU)
#define LAPACK_dgbequ LAPACK_GLOBAL(dgbequ,DGBEQU)
#define LAPACK_cgbequ LAPACK_GLOBAL(cgbequ,CGBEQU)
#define LAPACK_zgbequ LAPACK_GLOBAL(zgbequ,ZGBEQU)
#define LAPACK_dgbequb LAPACK_GLOBAL(dgbequb,DGBEQUB)
#define LAPACK_sgbequb LAPACK_GLOBAL(sgbequb,SGBEQUB)
#define LAPACK_zgbequb LAPACK_GLOBAL(zgbequb,ZGBEQUB)
#define LAPACK_cgbequb LAPACK_GLOBAL(cgbequb,CGBEQUB)
#define LAPACK_spoequ LAPACK_GLOBAL(spoequ,SPOEQU)
#define LAPACK_dpoequ LAPACK_GLOBAL(dpoequ,DPOEQU)
#define LAPACK_cpoequ LAPACK_GLOBAL(cpoequ,CPOEQU)
#define LAPACK_zpoequ LAPACK_GLOBAL(zpoequ,ZPOEQU)
#define LAPACK_dpoequb LAPACK_GLOBAL(dpoequb,DPOEQUB)
#define LAPACK_spoequb LAPACK_GLOBAL(spoequb,SPOEQUB)
#define LAPACK_zpoequb LAPACK_GLOBAL(zpoequb,ZPOEQUB)
#define LAPACK_cpoequb LAPACK_GLOBAL(cpoequb,CPOEQUB)
#define LAPACK_sppequ LAPACK_GLOBAL(sppequ,SPPEQU)
#define LAPACK_dppequ LAPACK_GLOBAL(dppequ,DPPEQU)
#define LAPACK_cppequ LAPACK_GLOBAL(cppequ,CPPEQU)
#define LAPACK_zppequ LAPACK_GLOBAL(zppequ,ZPPEQU)
#define LAPACK_spbequ LAPACK_GLOBAL(spbequ,SPBEQU)
#define LAPACK_dpbequ LAPACK_GLOBAL(dpbequ,DPBEQU)
#define LAPACK_cpbequ LAPACK_GLOBAL(cpbequ,CPBEQU)
#define LAPACK_zpbequ LAPACK_GLOBAL(zpbequ,ZPBEQU)
#define LAPACK_dsyequb LAPACK_GLOBAL(dsyequb,DSYEQUB)
#define LAPACK_ssyequb LAPACK_GLOBAL(ssyequb,SSYEQUB)
#define LAPACK_zsyequb LAPACK_GLOBAL(zsyequb,ZSYEQUB)
#define LAPACK_csyequb LAPACK_GLOBAL(csyequb,CSYEQUB)
#define LAPACK_zheequb LAPACK_GLOBAL(zheequb,ZHEEQUB)
#define LAPACK_cheequb LAPACK_GLOBAL(cheequb,CHEEQUB)
#define LAPACK_sgesv LAPACK_GLOBAL(sgesv,SGESV)
#define LAPACK_dgesv LAPACK_GLOBAL(dgesv,DGESV)
#define LAPACK_cgesv LAPACK_GLOBAL(cgesv,CGESV)
#define LAPACK_zgesv LAPACK_GLOBAL(zgesv,ZGESV)
#define LAPACK_dsgesv LAPACK_GLOBAL(dsgesv,DSGESV)
#define LAPACK_zcgesv LAPACK_GLOBAL(zcgesv,ZCGESV)
#define LAPACK_sgesvx LAPACK_GLOBAL(sgesvx,SGESVX)
#define LAPACK_dgesvx LAPACK_GLOBAL(dgesvx,DGESVX)
#define LAPACK_cgesvx LAPACK_GLOBAL(cgesvx,CGESVX)
#define LAPACK_zgesvx LAPACK_GLOBAL(zgesvx,ZGESVX)
#define LAPACK_dgesvxx LAPACK_GLOBAL(dgesvxx,DGESVXX)
#define LAPACK_sgesvxx LAPACK_GLOBAL(sgesvxx,SGESVXX)
#define LAPACK_zgesvxx LAPACK_GLOBAL(zgesvxx,ZGESVXX)
#define LAPACK_cgesvxx LAPACK_GLOBAL(cgesvxx,CGESVXX)
#define LAPACK_sgbsv LAPACK_GLOBAL(sgbsv,SGBSV)
#define LAPACK_dgbsv LAPACK_GLOBAL(dgbsv,DGBSV)
#define LAPACK_cgbsv LAPACK_GLOBAL(cgbsv,CGBSV)
#define LAPACK_zgbsv LAPACK_GLOBAL(zgbsv,ZGBSV)
#define LAPACK_sgbsvx LAPACK_GLOBAL(sgbsvx,SGBSVX)
#define LAPACK_dgbsvx LAPACK_GLOBAL(dgbsvx,DGBSVX)
#define LAPACK_cgbsvx LAPACK_GLOBAL(cgbsvx,CGBSVX)
#define LAPACK_zgbsvx LAPACK_GLOBAL(zgbsvx,ZGBSVX)
#define LAPACK_dgbsvxx LAPACK_GLOBAL(dgbsvxx,DGBSVXX)
#define LAPACK_sgbsvxx LAPACK_GLOBAL(sgbsvxx,SGBSVXX)
#define LAPACK_zgbsvxx LAPACK_GLOBAL(zgbsvxx,ZGBSVXX)
#define LAPACK_cgbsvxx LAPACK_GLOBAL(cgbsvxx,CGBSVXX)
#define LAPACK_sgtsv LAPACK_GLOBAL(sgtsv,SGTSV)
#define LAPACK_dgtsv LAPACK_GLOBAL(dgtsv,DGTSV)
#define LAPACK_cgtsv LAPACK_GLOBAL(cgtsv,CGTSV)
#define LAPACK_zgtsv LAPACK_GLOBAL(zgtsv,ZGTSV)
#define LAPACK_sgtsvx LAPACK_GLOBAL(sgtsvx,SGTSVX)
#define LAPACK_dgtsvx LAPACK_GLOBAL(dgtsvx,DGTSVX)
#define LAPACK_cgtsvx LAPACK_GLOBAL(cgtsvx,CGTSVX)
#define LAPACK_zgtsvx LAPACK_GLOBAL(zgtsvx,ZGTSVX)
#define LAPACK_sposv LAPACK_GLOBAL(sposv,SPOSV)
#define LAPACK_dposv LAPACK_GLOBAL(dposv,DPOSV)
#define LAPACK_cposv LAPACK_GLOBAL(cposv,CPOSV)
#define LAPACK_zposv LAPACK_GLOBAL(zposv,ZPOSV)
#define LAPACK_dsposv LAPACK_GLOBAL(dsposv,DSPOSV)
#define LAPACK_zcposv LAPACK_GLOBAL(zcposv,ZCPOSV)
#define LAPACK_sposvx LAPACK_GLOBAL(sposvx,SPOSVX)
#define LAPACK_dposvx LAPACK_GLOBAL(dposvx,DPOSVX)
#define LAPACK_cposvx LAPACK_GLOBAL(cposvx,CPOSVX)
#define LAPACK_zposvx LAPACK_GLOBAL(zposvx,ZPOSVX)
#define LAPACK_dposvxx LAPACK_GLOBAL(dposvxx,DPOSVXX)
#define LAPACK_sposvxx LAPACK_GLOBAL(sposvxx,SPOSVXX)
#define LAPACK_zposvxx LAPACK_GLOBAL(zposvxx,ZPOSVXX)
#define LAPACK_cposvxx LAPACK_GLOBAL(cposvxx,CPOSVXX)
#define LAPACK_sppsv LAPACK_GLOBAL(sppsv,SPPSV)
#define LAPACK_dppsv LAPACK_GLOBAL(dppsv,DPPSV)
#define LAPACK_cppsv LAPACK_GLOBAL(cppsv,CPPSV)
#define LAPACK_zppsv LAPACK_GLOBAL(zppsv,ZPPSV)
#define LAPACK_sppsvx LAPACK_GLOBAL(sppsvx,SPPSVX)
#define LAPACK_dppsvx LAPACK_GLOBAL(dppsvx,DPPSVX)
#define LAPACK_cppsvx LAPACK_GLOBAL(cppsvx,CPPSVX)
#define LAPACK_zppsvx LAPACK_GLOBAL(zppsvx,ZPPSVX)
#define LAPACK_spbsv LAPACK_GLOBAL(spbsv,SPBSV)
#define LAPACK_dpbsv LAPACK_GLOBAL(dpbsv,DPBSV)
#define LAPACK_cpbsv LAPACK_GLOBAL(cpbsv,CPBSV)
#define LAPACK_zpbsv LAPACK_GLOBAL(zpbsv,ZPBSV)
#define LAPACK_spbsvx LAPACK_GLOBAL(spbsvx,SPBSVX)
#define LAPACK_dpbsvx LAPACK_GLOBAL(dpbsvx,DPBSVX)
#define LAPACK_cpbsvx LAPACK_GLOBAL(cpbsvx,CPBSVX)
#define LAPACK_zpbsvx LAPACK_GLOBAL(zpbsvx,ZPBSVX)
#define LAPACK_sptsv LAPACK_GLOBAL(sptsv,SPTSV)
#define LAPACK_dptsv LAPACK_GLOBAL(dptsv,DPTSV)
#define LAPACK_cptsv LAPACK_GLOBAL(cptsv,CPTSV)
#define LAPACK_zptsv LAPACK_GLOBAL(zptsv,ZPTSV)
#define LAPACK_sptsvx LAPACK_GLOBAL(sptsvx,SPTSVX)
#define LAPACK_dptsvx LAPACK_GLOBAL(dptsvx,DPTSVX)
#define LAPACK_cptsvx LAPACK_GLOBAL(cptsvx,CPTSVX)
#define LAPACK_zptsvx LAPACK_GLOBAL(zptsvx,ZPTSVX)
#define LAPACK_ssysv LAPACK_GLOBAL(ssysv,SSYSV)
#define LAPACK_dsysv LAPACK_GLOBAL(dsysv,DSYSV)
#define LAPACK_csysv LAPACK_GLOBAL(csysv,CSYSV)
#define LAPACK_zsysv LAPACK_GLOBAL(zsysv,ZSYSV)
#define LAPACK_ssysvx LAPACK_GLOBAL(ssysvx,SSYSVX)
#define LAPACK_dsysvx LAPACK_GLOBAL(dsysvx,DSYSVX)
#define LAPACK_csysvx LAPACK_GLOBAL(csysvx,CSYSVX)
#define LAPACK_zsysvx LAPACK_GLOBAL(zsysvx,ZSYSVX)
#define LAPACK_dsysvxx LAPACK_GLOBAL(dsysvxx,DSYSVXX)
#define LAPACK_ssysvxx LAPACK_GLOBAL(ssysvxx,SSYSVXX)
#define LAPACK_zsysvxx LAPACK_GLOBAL(zsysvxx,ZSYSVXX)
#define LAPACK_csysvxx LAPACK_GLOBAL(csysvxx,CSYSVXX)
#define LAPACK_chesv LAPACK_GLOBAL(chesv,CHESV)
#define LAPACK_zhesv LAPACK_GLOBAL(zhesv,ZHESV)
#define LAPACK_chesvx LAPACK_GLOBAL(chesvx,CHESVX)
#define LAPACK_zhesvx LAPACK_GLOBAL(zhesvx,ZHESVX)
#define LAPACK_zhesvxx LAPACK_GLOBAL(zhesvxx,ZHESVXX)
#define LAPACK_chesvxx LAPACK_GLOBAL(chesvxx,CHESVXX)
#define LAPACK_sspsv LAPACK_GLOBAL(sspsv,SSPSV)
#define LAPACK_dspsv LAPACK_GLOBAL(dspsv,DSPSV)
#define LAPACK_cspsv LAPACK_GLOBAL(cspsv,CSPSV)
#define LAPACK_zspsv LAPACK_GLOBAL(zspsv,ZSPSV)
#define LAPACK_sspsvx LAPACK_GLOBAL(sspsvx,SSPSVX)
#define LAPACK_dspsvx LAPACK_GLOBAL(dspsvx,DSPSVX)
#define LAPACK_cspsvx LAPACK_GLOBAL(cspsvx,CSPSVX)
#define LAPACK_zspsvx LAPACK_GLOBAL(zspsvx,ZSPSVX)
#define LAPACK_chpsv LAPACK_GLOBAL(chpsv,CHPSV)
#define LAPACK_zhpsv LAPACK_GLOBAL(zhpsv,ZHPSV)
#define LAPACK_chpsvx LAPACK_GLOBAL(chpsvx,CHPSVX)
#define LAPACK_zhpsvx LAPACK_GLOBAL(zhpsvx,ZHPSVX)
#define LAPACK_sgeqrf LAPACK_GLOBAL(sgeqrf,SGEQRF)
#define LAPACK_dgeqrf LAPACK_GLOBAL(dgeqrf,DGEQRF)
#define LAPACK_cgeqrf LAPACK_GLOBAL(cgeqrf,CGEQRF)
#define LAPACK_zgeqrf LAPACK_GLOBAL(zgeqrf,ZGEQRF)
#define LAPACK_sgeqpf LAPACK_GLOBAL(sgeqpf,SGEQPF)
#define LAPACK_dgeqpf LAPACK_GLOBAL(dgeqpf,DGEQPF)
#define LAPACK_cgeqpf LAPACK_GLOBAL(cgeqpf,CGEQPF)
#define LAPACK_zgeqpf LAPACK_GLOBAL(zgeqpf,ZGEQPF)
#define LAPACK_sgeqp3 LAPACK_GLOBAL(sgeqp3,SGEQP3)
#define LAPACK_dgeqp3 LAPACK_GLOBAL(dgeqp3,DGEQP3)
#define LAPACK_cgeqp3 LAPACK_GLOBAL(cgeqp3,CGEQP3)
#define LAPACK_zgeqp3 LAPACK_GLOBAL(zgeqp3,ZGEQP3)
#define LAPACK_sorgqr LAPACK_GLOBAL(sorgqr,SORGQR)
#define LAPACK_dorgqr LAPACK_GLOBAL(dorgqr,DORGQR)
#define LAPACK_sormqr LAPACK_GLOBAL(sormqr,SORMQR)
#define LAPACK_dormqr LAPACK_GLOBAL(dormqr,DORMQR)
#define LAPACK_cungqr LAPACK_GLOBAL(cungqr,CUNGQR)
#define LAPACK_zungqr LAPACK_GLOBAL(zungqr,ZUNGQR)
#define LAPACK_cunmqr LAPACK_GLOBAL(cunmqr,CUNMQR)
#define LAPACK_zunmqr LAPACK_GLOBAL(zunmqr,ZUNMQR)
#define LAPACK_sgelqf LAPACK_GLOBAL(sgelqf,SGELQF)
#define LAPACK_dgelqf LAPACK_GLOBAL(dgelqf,DGELQF)
#define LAPACK_cgelqf LAPACK_GLOBAL(cgelqf,CGELQF)
#define LAPACK_zgelqf LAPACK_GLOBAL(zgelqf,ZGELQF)
#define LAPACK_sorglq LAPACK_GLOBAL(sorglq,SORGLQ)
#define LAPACK_dorglq LAPACK_GLOBAL(dorglq,DORGLQ)
#define LAPACK_sormlq LAPACK_GLOBAL(sormlq,SORMLQ)
#define LAPACK_dormlq LAPACK_GLOBAL(dormlq,DORMLQ)
#define LAPACK_cunglq LAPACK_GLOBAL(cunglq,CUNGLQ)
#define LAPACK_zunglq LAPACK_GLOBAL(zunglq,ZUNGLQ)
#define LAPACK_cunmlq LAPACK_GLOBAL(cunmlq,CUNMLQ)
#define LAPACK_zunmlq LAPACK_GLOBAL(zunmlq,ZUNMLQ)
#define LAPACK_sgeqlf LAPACK_GLOBAL(sgeqlf,SGEQLF)
#define LAPACK_dgeqlf LAPACK_GLOBAL(dgeqlf,DGEQLF)
#define LAPACK_cgeqlf LAPACK_GLOBAL(cgeqlf,CGEQLF)
#define LAPACK_zgeqlf LAPACK_GLOBAL(zgeqlf,ZGEQLF)
#define LAPACK_sorgql LAPACK_GLOBAL(sorgql,SORGQL)
#define LAPACK_dorgql LAPACK_GLOBAL(dorgql,DORGQL)
#define LAPACK_cungql LAPACK_GLOBAL(cungql,CUNGQL)
#define LAPACK_zungql LAPACK_GLOBAL(zungql,ZUNGQL)
#define LAPACK_sormql LAPACK_GLOBAL(sormql,SORMQL)
#define LAPACK_dormql LAPACK_GLOBAL(dormql,DORMQL)
#define LAPACK_cunmql LAPACK_GLOBAL(cunmql,CUNMQL)
#define LAPACK_zunmql LAPACK_GLOBAL(zunmql,ZUNMQL)
#define LAPACK_sgerqf LAPACK_GLOBAL(sgerqf,SGERQF)
#define LAPACK_dgerqf LAPACK_GLOBAL(dgerqf,DGERQF)
#define LAPACK_cgerqf LAPACK_GLOBAL(cgerqf,CGERQF)
#define LAPACK_zgerqf LAPACK_GLOBAL(zgerqf,ZGERQF)
#define LAPACK_sorgrq LAPACK_GLOBAL(sorgrq,SORGRQ)
#define LAPACK_dorgrq LAPACK_GLOBAL(dorgrq,DORGRQ)
#define LAPACK_cungrq LAPACK_GLOBAL(cungrq,CUNGRQ)
#define LAPACK_zungrq LAPACK_GLOBAL(zungrq,ZUNGRQ)
#define LAPACK_sormrq LAPACK_GLOBAL(sormrq,SORMRQ)
#define LAPACK_dormrq LAPACK_GLOBAL(dormrq,DORMRQ)
#define LAPACK_cunmrq LAPACK_GLOBAL(cunmrq,CUNMRQ)
#define LAPACK_zunmrq LAPACK_GLOBAL(zunmrq,ZUNMRQ)
#define LAPACK_stzrzf LAPACK_GLOBAL(stzrzf,STZRZF)
#define LAPACK_dtzrzf LAPACK_GLOBAL(dtzrzf,DTZRZF)
#define LAPACK_ctzrzf LAPACK_GLOBAL(ctzrzf,CTZRZF)
#define LAPACK_ztzrzf LAPACK_GLOBAL(ztzrzf,ZTZRZF)
#define LAPACK_sormrz LAPACK_GLOBAL(sormrz,SORMRZ)
#define LAPACK_dormrz LAPACK_GLOBAL(dormrz,DORMRZ)
#define LAPACK_cunmrz LAPACK_GLOBAL(cunmrz,CUNMRZ)
#define LAPACK_zunmrz LAPACK_GLOBAL(zunmrz,ZUNMRZ)
#define LAPACK_sggqrf LAPACK_GLOBAL(sggqrf,SGGQRF)
#define LAPACK_dggqrf LAPACK_GLOBAL(dggqrf,DGGQRF)
#define LAPACK_cggqrf LAPACK_GLOBAL(cggqrf,CGGQRF)
#define LAPACK_zggqrf LAPACK_GLOBAL(zggqrf,ZGGQRF)
#define LAPACK_sggrqf LAPACK_GLOBAL(sggrqf,SGGRQF)
#define LAPACK_dggrqf LAPACK_GLOBAL(dggrqf,DGGRQF)
#define LAPACK_cggrqf LAPACK_GLOBAL(cggrqf,CGGRQF)
#define LAPACK_zggrqf LAPACK_GLOBAL(zggrqf,ZGGRQF)
#define LAPACK_sgebrd LAPACK_GLOBAL(sgebrd,SGEBRD)
#define LAPACK_dgebrd LAPACK_GLOBAL(dgebrd,DGEBRD)
#define LAPACK_cgebrd LAPACK_GLOBAL(cgebrd,CGEBRD)
#define LAPACK_zgebrd LAPACK_GLOBAL(zgebrd,ZGEBRD)
#define LAPACK_sgbbrd LAPACK_GLOBAL(sgbbrd,SGBBRD)
#define LAPACK_dgbbrd LAPACK_GLOBAL(dgbbrd,DGBBRD)
#define LAPACK_cgbbrd LAPACK_GLOBAL(cgbbrd,CGBBRD)
#define LAPACK_zgbbrd LAPACK_GLOBAL(zgbbrd,ZGBBRD)
#define LAPACK_sorgbr LAPACK_GLOBAL(sorgbr,SORGBR)
#define LAPACK_dorgbr LAPACK_GLOBAL(dorgbr,DORGBR)
#define LAPACK_sormbr LAPACK_GLOBAL(sormbr,SORMBR)
#define LAPACK_dormbr LAPACK_GLOBAL(dormbr,DORMBR)
#define LAPACK_cungbr LAPACK_GLOBAL(cungbr,CUNGBR)
#define LAPACK_zungbr LAPACK_GLOBAL(zungbr,ZUNGBR)
#define LAPACK_cunmbr LAPACK_GLOBAL(cunmbr,CUNMBR)
#define LAPACK_zunmbr LAPACK_GLOBAL(zunmbr,ZUNMBR)
#define LAPACK_sbdsqr LAPACK_GLOBAL(sbdsqr,SBDSQR)
#define LAPACK_dbdsqr LAPACK_GLOBAL(dbdsqr,DBDSQR)
#define LAPACK_cbdsqr LAPACK_GLOBAL(cbdsqr,CBDSQR)
#define LAPACK_zbdsqr LAPACK_GLOBAL(zbdsqr,ZBDSQR)
#define LAPACK_sbdsdc LAPACK_GLOBAL(sbdsdc,SBDSDC)
#define LAPACK_dbdsdc LAPACK_GLOBAL(dbdsdc,DBDSDC)
#define LAPACK_ssytrd LAPACK_GLOBAL(ssytrd,SSYTRD)
#define LAPACK_dsytrd LAPACK_GLOBAL(dsytrd,DSYTRD)
#define LAPACK_sorgtr LAPACK_GLOBAL(sorgtr,SORGTR)
#define LAPACK_dorgtr LAPACK_GLOBAL(dorgtr,DORGTR)
#define LAPACK_sormtr LAPACK_GLOBAL(sormtr,SORMTR)
#define LAPACK_dormtr LAPACK_GLOBAL(dormtr,DORMTR)
#define LAPACK_chetrd LAPACK_GLOBAL(chetrd,CHETRD)
#define LAPACK_zhetrd LAPACK_GLOBAL(zhetrd,ZHETRD)
#define LAPACK_cungtr LAPACK_GLOBAL(cungtr,CUNGTR)
#define LAPACK_zungtr LAPACK_GLOBAL(zungtr,ZUNGTR)
#define LAPACK_cunmtr LAPACK_GLOBAL(cunmtr,CUNMTR)
#define LAPACK_zunmtr LAPACK_GLOBAL(zunmtr,ZUNMTR)
#define LAPACK_ssptrd LAPACK_GLOBAL(ssptrd,SSPTRD)
#define LAPACK_dsptrd LAPACK_GLOBAL(dsptrd,DSPTRD)
#define LAPACK_sopgtr LAPACK_GLOBAL(sopgtr,SOPGTR)
#define LAPACK_dopgtr LAPACK_GLOBAL(dopgtr,DOPGTR)
#define LAPACK_sopmtr LAPACK_GLOBAL(sopmtr,SOPMTR)
#define LAPACK_dopmtr LAPACK_GLOBAL(dopmtr,DOPMTR)
#define LAPACK_chptrd LAPACK_GLOBAL(chptrd,CHPTRD)
#define LAPACK_zhptrd LAPACK_GLOBAL(zhptrd,ZHPTRD)
#define LAPACK_cupgtr LAPACK_GLOBAL(cupgtr,CUPGTR)
#define LAPACK_zupgtr LAPACK_GLOBAL(zupgtr,ZUPGTR)
#define LAPACK_cupmtr LAPACK_GLOBAL(cupmtr,CUPMTR)
#define LAPACK_zupmtr LAPACK_GLOBAL(zupmtr,ZUPMTR)
#define LAPACK_ssbtrd LAPACK_GLOBAL(ssbtrd,SSBTRD)
#define LAPACK_dsbtrd LAPACK_GLOBAL(dsbtrd,DSBTRD)
#define LAPACK_chbtrd LAPACK_GLOBAL(chbtrd,CHBTRD)
#define LAPACK_zhbtrd LAPACK_GLOBAL(zhbtrd,ZHBTRD)
#define LAPACK_ssterf LAPACK_GLOBAL(ssterf,SSTERF)
#define LAPACK_dsterf LAPACK_GLOBAL(dsterf,DSTERF)
#define LAPACK_ssteqr LAPACK_GLOBAL(ssteqr,SSTEQR)
#define LAPACK_dsteqr LAPACK_GLOBAL(dsteqr,DSTEQR)
#define LAPACK_csteqr LAPACK_GLOBAL(csteqr,CSTEQR)
#define LAPACK_zsteqr LAPACK_GLOBAL(zsteqr,ZSTEQR)
#define LAPACK_sstemr LAPACK_GLOBAL(sstemr,SSTEMR)
#define LAPACK_dstemr LAPACK_GLOBAL(dstemr,DSTEMR)
#define LAPACK_cstemr LAPACK_GLOBAL(cstemr,CSTEMR)
#define LAPACK_zstemr LAPACK_GLOBAL(zstemr,ZSTEMR)
#define LAPACK_sstedc LAPACK_GLOBAL(sstedc,SSTEDC)
#define LAPACK_dstedc LAPACK_GLOBAL(dstedc,DSTEDC)
#define LAPACK_cstedc LAPACK_GLOBAL(cstedc,CSTEDC)
#define LAPACK_zstedc LAPACK_GLOBAL(zstedc,ZSTEDC)
#define LAPACK_sstegr LAPACK_GLOBAL(sstegr,SSTEGR)
#define LAPACK_dstegr LAPACK_GLOBAL(dstegr,DSTEGR)
#define LAPACK_cstegr LAPACK_GLOBAL(cstegr,CSTEGR)
#define LAPACK_zstegr LAPACK_GLOBAL(zstegr,ZSTEGR)
#define LAPACK_spteqr LAPACK_GLOBAL(spteqr,SPTEQR)
#define LAPACK_dpteqr LAPACK_GLOBAL(dpteqr,DPTEQR)
#define LAPACK_cpteqr LAPACK_GLOBAL(cpteqr,CPTEQR)
#define LAPACK_zpteqr LAPACK_GLOBAL(zpteqr,ZPTEQR)
#define LAPACK_sstebz LAPACK_GLOBAL(sstebz,SSTEBZ)
#define LAPACK_dstebz LAPACK_GLOBAL(dstebz,DSTEBZ)
#define LAPACK_sstein LAPACK_GLOBAL(sstein,SSTEIN)
#define LAPACK_dstein LAPACK_GLOBAL(dstein,DSTEIN)
#define LAPACK_cstein LAPACK_GLOBAL(cstein,CSTEIN)
#define LAPACK_zstein LAPACK_GLOBAL(zstein,ZSTEIN)
#define LAPACK_sdisna LAPACK_GLOBAL(sdisna,SDISNA)
#define LAPACK_ddisna LAPACK_GLOBAL(ddisna,DDISNA)
#define LAPACK_ssygst LAPACK_GLOBAL(ssygst,SSYGST)
#define LAPACK_dsygst LAPACK_GLOBAL(dsygst,DSYGST)
#define LAPACK_chegst LAPACK_GLOBAL(chegst,CHEGST)
#define LAPACK_zhegst LAPACK_GLOBAL(zhegst,ZHEGST)
#define LAPACK_sspgst LAPACK_GLOBAL(sspgst,SSPGST)
#define LAPACK_dspgst LAPACK_GLOBAL(dspgst,DSPGST)
#define LAPACK_chpgst LAPACK_GLOBAL(chpgst,CHPGST)
#define LAPACK_zhpgst LAPACK_GLOBAL(zhpgst,ZHPGST)
#define LAPACK_ssbgst LAPACK_GLOBAL(ssbgst,SSBGST)
#define LAPACK_dsbgst LAPACK_GLOBAL(dsbgst,DSBGST)
#define LAPACK_chbgst LAPACK_GLOBAL(chbgst,CHBGST)
#define LAPACK_zhbgst LAPACK_GLOBAL(zhbgst,ZHBGST)
#define LAPACK_spbstf LAPACK_GLOBAL(spbstf,SPBSTF)
#define LAPACK_dpbstf LAPACK_GLOBAL(dpbstf,DPBSTF)
#define LAPACK_cpbstf LAPACK_GLOBAL(cpbstf,CPBSTF)
#define LAPACK_zpbstf LAPACK_GLOBAL(zpbstf,ZPBSTF)
#define LAPACK_sgehrd LAPACK_GLOBAL(sgehrd,SGEHRD)
#define LAPACK_dgehrd LAPACK_GLOBAL(dgehrd,DGEHRD)
#define LAPACK_cgehrd LAPACK_GLOBAL(cgehrd,CGEHRD)
#define LAPACK_zgehrd LAPACK_GLOBAL(zgehrd,ZGEHRD)
#define LAPACK_sorghr LAPACK_GLOBAL(sorghr,SORGHR)
#define LAPACK_dorghr LAPACK_GLOBAL(dorghr,DORGHR)
#define LAPACK_sormhr LAPACK_GLOBAL(sormhr,SORMHR)
#define LAPACK_dormhr LAPACK_GLOBAL(dormhr,DORMHR)
#define LAPACK_cunghr LAPACK_GLOBAL(cunghr,CUNGHR)
#define LAPACK_zunghr LAPACK_GLOBAL(zunghr,ZUNGHR)
#define LAPACK_cunmhr LAPACK_GLOBAL(cunmhr,CUNMHR)
#define LAPACK_zunmhr LAPACK_GLOBAL(zunmhr,ZUNMHR)
#define LAPACK_sgebal LAPACK_GLOBAL(sgebal,SGEBAL)
#define LAPACK_dgebal LAPACK_GLOBAL(dgebal,DGEBAL)
#define LAPACK_cgebal LAPACK_GLOBAL(cgebal,CGEBAL)
#define LAPACK_zgebal LAPACK_GLOBAL(zgebal,ZGEBAL)
#define LAPACK_sgebak LAPACK_GLOBAL(sgebak,SGEBAK)
#define LAPACK_dgebak LAPACK_GLOBAL(dgebak,DGEBAK)
#define LAPACK_cgebak LAPACK_GLOBAL(cgebak,CGEBAK)
#define LAPACK_zgebak LAPACK_GLOBAL(zgebak,ZGEBAK)
#define LAPACK_shseqr LAPACK_GLOBAL(shseqr,SHSEQR)
#define LAPACK_dhseqr LAPACK_GLOBAL(dhseqr,DHSEQR)
#define LAPACK_chseqr LAPACK_GLOBAL(chseqr,CHSEQR)
#define LAPACK_zhseqr LAPACK_GLOBAL(zhseqr,ZHSEQR)
#define LAPACK_shsein LAPACK_GLOBAL(shsein,SHSEIN)
#define LAPACK_dhsein LAPACK_GLOBAL(dhsein,DHSEIN)
#define LAPACK_chsein LAPACK_GLOBAL(chsein,CHSEIN)
#define LAPACK_zhsein LAPACK_GLOBAL(zhsein,ZHSEIN)
#define LAPACK_strevc LAPACK_GLOBAL(strevc,STREVC)
#define LAPACK_dtrevc LAPACK_GLOBAL(dtrevc,DTREVC)
#define LAPACK_ctrevc LAPACK_GLOBAL(ctrevc,CTREVC)
#define LAPACK_ztrevc LAPACK_GLOBAL(ztrevc,ZTREVC)
#define LAPACK_strsna LAPACK_GLOBAL(strsna,STRSNA)
#define LAPACK_dtrsna LAPACK_GLOBAL(dtrsna,DTRSNA)
#define LAPACK_ctrsna LAPACK_GLOBAL(ctrsna,CTRSNA)
#define LAPACK_ztrsna LAPACK_GLOBAL(ztrsna,ZTRSNA)
#define LAPACK_strexc LAPACK_GLOBAL(strexc,STREXC)
#define LAPACK_dtrexc LAPACK_GLOBAL(dtrexc,DTREXC)
#define LAPACK_ctrexc LAPACK_GLOBAL(ctrexc,CTREXC)
#define LAPACK_ztrexc LAPACK_GLOBAL(ztrexc,ZTREXC)
#define LAPACK_strsen LAPACK_GLOBAL(strsen,STRSEN)
#define LAPACK_dtrsen LAPACK_GLOBAL(dtrsen,DTRSEN)
#define LAPACK_ctrsen LAPACK_GLOBAL(ctrsen,CTRSEN)
#define LAPACK_ztrsen LAPACK_GLOBAL(ztrsen,ZTRSEN)
#define LAPACK_strsyl LAPACK_GLOBAL(strsyl,STRSYL)
#define LAPACK_dtrsyl LAPACK_GLOBAL(dtrsyl,DTRSYL)
#define LAPACK_ctrsyl LAPACK_GLOBAL(ctrsyl,CTRSYL)
#define LAPACK_ztrsyl LAPACK_GLOBAL(ztrsyl,ZTRSYL)
#define LAPACK_sgghrd LAPACK_GLOBAL(sgghrd,SGGHRD)
#define LAPACK_dgghrd LAPACK_GLOBAL(dgghrd,DGGHRD)
#define LAPACK_cgghrd LAPACK_GLOBAL(cgghrd,CGGHRD)
#define LAPACK_zgghrd LAPACK_GLOBAL(zgghrd,ZGGHRD)
#define LAPACK_sggbal LAPACK_GLOBAL(sggbal,SGGBAL)
#define LAPACK_dggbal LAPACK_GLOBAL(dggbal,DGGBAL)
#define LAPACK_cggbal LAPACK_GLOBAL(cggbal,CGGBAL)
#define LAPACK_zggbal LAPACK_GLOBAL(zggbal,ZGGBAL)
#define LAPACK_sggbak LAPACK_GLOBAL(sggbak,SGGBAK)
#define LAPACK_dggbak LAPACK_GLOBAL(dggbak,DGGBAK)
#define LAPACK_cggbak LAPACK_GLOBAL(cggbak,CGGBAK)
#define LAPACK_zggbak LAPACK_GLOBAL(zggbak,ZGGBAK)
#define LAPACK_shgeqz LAPACK_GLOBAL(shgeqz,SHGEQZ)
#define LAPACK_dhgeqz LAPACK_GLOBAL(dhgeqz,DHGEQZ)
#define LAPACK_chgeqz LAPACK_GLOBAL(chgeqz,CHGEQZ)
#define LAPACK_zhgeqz LAPACK_GLOBAL(zhgeqz,ZHGEQZ)
#define LAPACK_stgevc LAPACK_GLOBAL(stgevc,STGEVC)
#define LAPACK_dtgevc LAPACK_GLOBAL(dtgevc,DTGEVC)
#define LAPACK_ctgevc LAPACK_GLOBAL(ctgevc,CTGEVC)
#define LAPACK_ztgevc LAPACK_GLOBAL(ztgevc,ZTGEVC)
#define LAPACK_stgexc LAPACK_GLOBAL(stgexc,STGEXC)
#define LAPACK_dtgexc LAPACK_GLOBAL(dtgexc,DTGEXC)
#define LAPACK_ctgexc LAPACK_GLOBAL(ctgexc,CTGEXC)
#define LAPACK_ztgexc LAPACK_GLOBAL(ztgexc,ZTGEXC)
#define LAPACK_stgsen LAPACK_GLOBAL(stgsen,STGSEN)
#define LAPACK_dtgsen LAPACK_GLOBAL(dtgsen,DTGSEN)
#define LAPACK_ctgsen LAPACK_GLOBAL(ctgsen,CTGSEN)
#define LAPACK_ztgsen LAPACK_GLOBAL(ztgsen,ZTGSEN)
#define LAPACK_stgsyl LAPACK_GLOBAL(stgsyl,STGSYL)
#define LAPACK_dtgsyl LAPACK_GLOBAL(dtgsyl,DTGSYL)
#define LAPACK_ctgsyl LAPACK_GLOBAL(ctgsyl,CTGSYL)
#define LAPACK_ztgsyl LAPACK_GLOBAL(ztgsyl,ZTGSYL)
#define LAPACK_stgsna LAPACK_GLOBAL(stgsna,STGSNA)
#define LAPACK_dtgsna LAPACK_GLOBAL(dtgsna,DTGSNA)
#define LAPACK_ctgsna LAPACK_GLOBAL(ctgsna,CTGSNA)
#define LAPACK_ztgsna LAPACK_GLOBAL(ztgsna,ZTGSNA)
#define LAPACK_sggsvp LAPACK_GLOBAL(sggsvp,SGGSVP)
#define LAPACK_dggsvp LAPACK_GLOBAL(dggsvp,DGGSVP)
#define LAPACK_cggsvp LAPACK_GLOBAL(cggsvp,CGGSVP)
#define LAPACK_zggsvp LAPACK_GLOBAL(zggsvp,ZGGSVP)
#define LAPACK_stgsja LAPACK_GLOBAL(stgsja,STGSJA)
#define LAPACK_dtgsja LAPACK_GLOBAL(dtgsja,DTGSJA)
#define LAPACK_ctgsja LAPACK_GLOBAL(ctgsja,CTGSJA)
#define LAPACK_ztgsja LAPACK_GLOBAL(ztgsja,ZTGSJA)
#define LAPACK_sgels LAPACK_GLOBAL(sgels,SGELS)
#define LAPACK_dgels LAPACK_GLOBAL(dgels,DGELS)
#define LAPACK_cgels LAPACK_GLOBAL(cgels,CGELS)
#define LAPACK_zgels LAPACK_GLOBAL(zgels,ZGELS)
#define LAPACK_sgelsy LAPACK_GLOBAL(sgelsy,SGELSY)
#define LAPACK_dgelsy LAPACK_GLOBAL(dgelsy,DGELSY)
#define LAPACK_cgelsy LAPACK_GLOBAL(cgelsy,CGELSY)
#define LAPACK_zgelsy LAPACK_GLOBAL(zgelsy,ZGELSY)
#define LAPACK_sgelss LAPACK_GLOBAL(sgelss,SGELSS)
#define LAPACK_dgelss LAPACK_GLOBAL(dgelss,DGELSS)
#define LAPACK_cgelss LAPACK_GLOBAL(cgelss,CGELSS)
#define LAPACK_zgelss LAPACK_GLOBAL(zgelss,ZGELSS)
#define LAPACK_sgelsd LAPACK_GLOBAL(sgelsd,SGELSD)
#define LAPACK_dgelsd LAPACK_GLOBAL(dgelsd,DGELSD)
#define LAPACK_cgelsd LAPACK_GLOBAL(cgelsd,CGELSD)
#define LAPACK_zgelsd LAPACK_GLOBAL(zgelsd,ZGELSD)
#define LAPACK_sgglse LAPACK_GLOBAL(sgglse,SGGLSE)
#define LAPACK_dgglse LAPACK_GLOBAL(dgglse,DGGLSE)
#define LAPACK_cgglse LAPACK_GLOBAL(cgglse,CGGLSE)
#define LAPACK_zgglse LAPACK_GLOBAL(zgglse,ZGGLSE)
#define LAPACK_sggglm LAPACK_GLOBAL(sggglm,SGGGLM)
#define LAPACK_dggglm LAPACK_GLOBAL(dggglm,DGGGLM)
#define LAPACK_cggglm LAPACK_GLOBAL(cggglm,CGGGLM)
#define LAPACK_zggglm LAPACK_GLOBAL(zggglm,ZGGGLM)
#define LAPACK_ssyev LAPACK_GLOBAL(ssyev,SSYEV)
#define LAPACK_dsyev LAPACK_GLOBAL(dsyev,DSYEV)
#define LAPACK_cheev LAPACK_GLOBAL(cheev,CHEEV)
#define LAPACK_zheev LAPACK_GLOBAL(zheev,ZHEEV)
#define LAPACK_ssyevd LAPACK_GLOBAL(ssyevd,SSYEVD)
#define LAPACK_dsyevd LAPACK_GLOBAL(dsyevd,DSYEVD)
#define LAPACK_cheevd LAPACK_GLOBAL(cheevd,CHEEVD)
#define LAPACK_zheevd LAPACK_GLOBAL(zheevd,ZHEEVD)
#define LAPACK_ssyevx LAPACK_GLOBAL(ssyevx,SSYEVX)
#define LAPACK_dsyevx LAPACK_GLOBAL(dsyevx,DSYEVX)
#define LAPACK_cheevx LAPACK_GLOBAL(cheevx,CHEEVX)
#define LAPACK_zheevx LAPACK_GLOBAL(zheevx,ZHEEVX)
#define LAPACK_ssyevr LAPACK_GLOBAL(ssyevr,SSYEVR)
#define LAPACK_dsyevr LAPACK_GLOBAL(dsyevr,DSYEVR)
#define LAPACK_cheevr LAPACK_GLOBAL(cheevr,CHEEVR)
#define LAPACK_zheevr LAPACK_GLOBAL(zheevr,ZHEEVR)
#define LAPACK_sspev LAPACK_GLOBAL(sspev,SSPEV)
#define LAPACK_dspev LAPACK_GLOBAL(dspev,DSPEV)
#define LAPACK_chpev LAPACK_GLOBAL(chpev,CHPEV)
#define LAPACK_zhpev LAPACK_GLOBAL(zhpev,ZHPEV)
#define LAPACK_sspevd LAPACK_GLOBAL(sspevd,SSPEVD)
#define LAPACK_dspevd LAPACK_GLOBAL(dspevd,DSPEVD)
#define LAPACK_chpevd LAPACK_GLOBAL(chpevd,CHPEVD)
#define LAPACK_zhpevd LAPACK_GLOBAL(zhpevd,ZHPEVD)
#define LAPACK_sspevx LAPACK_GLOBAL(sspevx,SSPEVX)
#define LAPACK_dspevx LAPACK_GLOBAL(dspevx,DSPEVX)
#define LAPACK_chpevx LAPACK_GLOBAL(chpevx,CHPEVX)
#define LAPACK_zhpevx LAPACK_GLOBAL(zhpevx,ZHPEVX)
#define LAPACK_ssbev LAPACK_GLOBAL(ssbev,SSBEV)
#define LAPACK_dsbev LAPACK_GLOBAL(dsbev,DSBEV)
#define LAPACK_chbev LAPACK_GLOBAL(chbev,CHBEV)
#define LAPACK_zhbev LAPACK_GLOBAL(zhbev,ZHBEV)
#define LAPACK_ssbevd LAPACK_GLOBAL(ssbevd,SSBEVD)
#define LAPACK_dsbevd LAPACK_GLOBAL(dsbevd,DSBEVD)
#define LAPACK_chbevd LAPACK_GLOBAL(chbevd,CHBEVD)
#define LAPACK_zhbevd LAPACK_GLOBAL(zhbevd,ZHBEVD)
#define LAPACK_ssbevx LAPACK_GLOBAL(ssbevx,SSBEVX)
#define LAPACK_dsbevx LAPACK_GLOBAL(dsbevx,DSBEVX)
#define LAPACK_chbevx LAPACK_GLOBAL(chbevx,CHBEVX)
#define LAPACK_zhbevx LAPACK_GLOBAL(zhbevx,ZHBEVX)
#define LAPACK_sstev LAPACK_GLOBAL(sstev,SSTEV)
#define LAPACK_dstev LAPACK_GLOBAL(dstev,DSTEV)
#define LAPACK_sstevd LAPACK_GLOBAL(sstevd,SSTEVD)
#define LAPACK_dstevd LAPACK_GLOBAL(dstevd,DSTEVD)
#define LAPACK_sstevx LAPACK_GLOBAL(sstevx,SSTEVX)
#define LAPACK_dstevx LAPACK_GLOBAL(dstevx,DSTEVX)
#define LAPACK_sstevr LAPACK_GLOBAL(sstevr,SSTEVR)
#define LAPACK_dstevr LAPACK_GLOBAL(dstevr,DSTEVR)
#define LAPACK_sgees LAPACK_GLOBAL(sgees,SGEES)
#define LAPACK_dgees LAPACK_GLOBAL(dgees,DGEES)
#define LAPACK_cgees LAPACK_GLOBAL(cgees,CGEES)
#define LAPACK_zgees LAPACK_GLOBAL(zgees,ZGEES)
#define LAPACK_sgeesx LAPACK_GLOBAL(sgeesx,SGEESX)
#define LAPACK_dgeesx LAPACK_GLOBAL(dgeesx,DGEESX)
#define LAPACK_cgeesx LAPACK_GLOBAL(cgeesx,CGEESX)
#define LAPACK_zgeesx LAPACK_GLOBAL(zgeesx,ZGEESX)
#define LAPACK_sgeev LAPACK_GLOBAL(sgeev,SGEEV)
#define LAPACK_dgeev LAPACK_GLOBAL(dgeev,DGEEV)
#define LAPACK_cgeev LAPACK_GLOBAL(cgeev,CGEEV)
#define LAPACK_zgeev LAPACK_GLOBAL(zgeev,ZGEEV)
#define LAPACK_sgeevx LAPACK_GLOBAL(sgeevx,SGEEVX)
#define LAPACK_dgeevx LAPACK_GLOBAL(dgeevx,DGEEVX)
#define LAPACK_cgeevx LAPACK_GLOBAL(cgeevx,CGEEVX)
#define LAPACK_zgeevx LAPACK_GLOBAL(zgeevx,ZGEEVX)
#define LAPACK_sgesvd LAPACK_GLOBAL(sgesvd,SGESVD)
#define LAPACK_dgesvd LAPACK_GLOBAL(dgesvd,DGESVD)
#define LAPACK_cgesvd LAPACK_GLOBAL(cgesvd,CGESVD)
#define LAPACK_zgesvd LAPACK_GLOBAL(zgesvd,ZGESVD)
#define LAPACK_sgesdd LAPACK_GLOBAL(sgesdd,SGESDD)
#define LAPACK_dgesdd LAPACK_GLOBAL(dgesdd,DGESDD)
#define LAPACK_cgesdd LAPACK_GLOBAL(cgesdd,CGESDD)
#define LAPACK_zgesdd LAPACK_GLOBAL(zgesdd,ZGESDD)
#define LAPACK_dgejsv LAPACK_GLOBAL(dgejsv,DGEJSV)
#define LAPACK_sgejsv LAPACK_GLOBAL(sgejsv,SGEJSV)
#define LAPACK_dgesvj LAPACK_GLOBAL(dgesvj,DGESVJ)
#define LAPACK_sgesvj LAPACK_GLOBAL(sgesvj,SGESVJ)
#define LAPACK_sggsvd LAPACK_GLOBAL(sggsvd,SGGSVD)
#define LAPACK_dggsvd LAPACK_GLOBAL(dggsvd,DGGSVD)
#define LAPACK_cggsvd LAPACK_GLOBAL(cggsvd,CGGSVD)
#define LAPACK_zggsvd LAPACK_GLOBAL(zggsvd,ZGGSVD)
#define LAPACK_ssygv LAPACK_GLOBAL(ssygv,SSYGV)
#define LAPACK_dsygv LAPACK_GLOBAL(dsygv,DSYGV)
#define LAPACK_chegv LAPACK_GLOBAL(chegv,CHEGV)
#define LAPACK_zhegv LAPACK_GLOBAL(zhegv,ZHEGV)
#define LAPACK_ssygvd LAPACK_GLOBAL(ssygvd,SSYGVD)
#define LAPACK_dsygvd LAPACK_GLOBAL(dsygvd,DSYGVD)
#define LAPACK_chegvd LAPACK_GLOBAL(chegvd,CHEGVD)
#define LAPACK_zhegvd LAPACK_GLOBAL(zhegvd,ZHEGVD)
#define LAPACK_ssygvx LAPACK_GLOBAL(ssygvx,SSYGVX)
#define LAPACK_dsygvx LAPACK_GLOBAL(dsygvx,DSYGVX)
#define LAPACK_chegvx LAPACK_GLOBAL(chegvx,CHEGVX)
#define LAPACK_zhegvx LAPACK_GLOBAL(zhegvx,ZHEGVX)
#define LAPACK_sspgv LAPACK_GLOBAL(sspgv,SSPGV)
#define LAPACK_dspgv LAPACK_GLOBAL(dspgv,DSPGV)
#define LAPACK_chpgv LAPACK_GLOBAL(chpgv,CHPGV)
#define LAPACK_zhpgv LAPACK_GLOBAL(zhpgv,ZHPGV)
#define LAPACK_sspgvd LAPACK_GLOBAL(sspgvd,SSPGVD)
#define LAPACK_dspgvd LAPACK_GLOBAL(dspgvd,DSPGVD)
#define LAPACK_chpgvd LAPACK_GLOBAL(chpgvd,CHPGVD)
#define LAPACK_zhpgvd LAPACK_GLOBAL(zhpgvd,ZHPGVD)
#define LAPACK_sspgvx LAPACK_GLOBAL(sspgvx,SSPGVX)
#define LAPACK_dspgvx LAPACK_GLOBAL(dspgvx,DSPGVX)
#define LAPACK_chpgvx LAPACK_GLOBAL(chpgvx,CHPGVX)
#define LAPACK_zhpgvx LAPACK_GLOBAL(zhpgvx,ZHPGVX)
#define LAPACK_ssbgv LAPACK_GLOBAL(ssbgv,SSBGV)
#define LAPACK_dsbgv LAPACK_GLOBAL(dsbgv,DSBGV)
#define LAPACK_chbgv LAPACK_GLOBAL(chbgv,CHBGV)
#define LAPACK_zhbgv LAPACK_GLOBAL(zhbgv,ZHBGV)
#define LAPACK_ssbgvd LAPACK_GLOBAL(ssbgvd,SSBGVD)
#define LAPACK_dsbgvd LAPACK_GLOBAL(dsbgvd,DSBGVD)
#define LAPACK_chbgvd LAPACK_GLOBAL(chbgvd,CHBGVD)
#define LAPACK_zhbgvd LAPACK_GLOBAL(zhbgvd,ZHBGVD)
#define LAPACK_ssbgvx LAPACK_GLOBAL(ssbgvx,SSBGVX)
#define LAPACK_dsbgvx LAPACK_GLOBAL(dsbgvx,DSBGVX)
#define LAPACK_chbgvx LAPACK_GLOBAL(chbgvx,CHBGVX)
#define LAPACK_zhbgvx LAPACK_GLOBAL(zhbgvx,ZHBGVX)
#define LAPACK_sgges LAPACK_GLOBAL(sgges,SGGES)
#define LAPACK_dgges LAPACK_GLOBAL(dgges,DGGES)
#define LAPACK_cgges LAPACK_GLOBAL(cgges,CGGES)
#define LAPACK_zgges LAPACK_GLOBAL(zgges,ZGGES)
#define LAPACK_sggesx LAPACK_GLOBAL(sggesx,SGGESX)
#define LAPACK_dggesx LAPACK_GLOBAL(dggesx,DGGESX)
#define LAPACK_cggesx LAPACK_GLOBAL(cggesx,CGGESX)
#define LAPACK_zggesx LAPACK_GLOBAL(zggesx,ZGGESX)
#define LAPACK_sggev LAPACK_GLOBAL(sggev,SGGEV)
#define LAPACK_dggev LAPACK_GLOBAL(dggev,DGGEV)
#define LAPACK_cggev LAPACK_GLOBAL(cggev,CGGEV)
#define LAPACK_zggev LAPACK_GLOBAL(zggev,ZGGEV)
#define LAPACK_sggevx LAPACK_GLOBAL(sggevx,SGGEVX)
#define LAPACK_dggevx LAPACK_GLOBAL(dggevx,DGGEVX)
#define LAPACK_cggevx LAPACK_GLOBAL(cggevx,CGGEVX)
#define LAPACK_zggevx LAPACK_GLOBAL(zggevx,ZGGEVX)
#define LAPACK_dsfrk LAPACK_GLOBAL(dsfrk,DSFRK)
#define LAPACK_ssfrk LAPACK_GLOBAL(ssfrk,SSFRK)
#define LAPACK_zhfrk LAPACK_GLOBAL(zhfrk,ZHFRK)
#define LAPACK_chfrk LAPACK_GLOBAL(chfrk,CHFRK)
#define LAPACK_dtfsm LAPACK_GLOBAL(dtfsm,DTFSM)
#define LAPACK_stfsm LAPACK_GLOBAL(stfsm,STFSM)
#define LAPACK_ztfsm LAPACK_GLOBAL(ztfsm,ZTFSM)
#define LAPACK_ctfsm LAPACK_GLOBAL(ctfsm,CTFSM)
#define LAPACK_dtfttp LAPACK_GLOBAL(dtfttp,DTFTTP)
#define LAPACK_stfttp LAPACK_GLOBAL(stfttp,STFTTP)
#define LAPACK_ztfttp LAPACK_GLOBAL(ztfttp,ZTFTTP)
#define LAPACK_ctfttp LAPACK_GLOBAL(ctfttp,CTFTTP)
#define LAPACK_dtfttr LAPACK_GLOBAL(dtfttr,DTFTTR)
#define LAPACK_stfttr LAPACK_GLOBAL(stfttr,STFTTR)
#define LAPACK_ztfttr LAPACK_GLOBAL(ztfttr,ZTFTTR)
#define LAPACK_ctfttr LAPACK_GLOBAL(ctfttr,CTFTTR)
#define LAPACK_dtpttf LAPACK_GLOBAL(dtpttf,DTPTTF)
#define LAPACK_stpttf LAPACK_GLOBAL(stpttf,STPTTF)
#define LAPACK_ztpttf LAPACK_GLOBAL(ztpttf,ZTPTTF)
#define LAPACK_ctpttf LAPACK_GLOBAL(ctpttf,CTPTTF)
#define LAPACK_dtpttr LAPACK_GLOBAL(dtpttr,DTPTTR)
#define LAPACK_stpttr LAPACK_GLOBAL(stpttr,STPTTR)
#define LAPACK_ztpttr LAPACK_GLOBAL(ztpttr,ZTPTTR)
#define LAPACK_ctpttr LAPACK_GLOBAL(ctpttr,CTPTTR)
#define LAPACK_dtrttf LAPACK_GLOBAL(dtrttf,DTRTTF)
#define LAPACK_strttf LAPACK_GLOBAL(strttf,STRTTF)
#define LAPACK_ztrttf LAPACK_GLOBAL(ztrttf,ZTRTTF)
#define LAPACK_ctrttf LAPACK_GLOBAL(ctrttf,CTRTTF)
#define LAPACK_dtrttp LAPACK_GLOBAL(dtrttp,DTRTTP)
#define LAPACK_strttp LAPACK_GLOBAL(strttp,STRTTP)
#define LAPACK_ztrttp LAPACK_GLOBAL(ztrttp,ZTRTTP)
#define LAPACK_ctrttp LAPACK_GLOBAL(ctrttp,CTRTTP)
#define LAPACK_sgeqrfp LAPACK_GLOBAL(sgeqrfp,SGEQRFP)
#define LAPACK_dgeqrfp LAPACK_GLOBAL(dgeqrfp,DGEQRFP)
#define LAPACK_cgeqrfp LAPACK_GLOBAL(cgeqrfp,CGEQRFP)
#define LAPACK_zgeqrfp LAPACK_GLOBAL(zgeqrfp,ZGEQRFP)
#define LAPACK_clacgv LAPACK_GLOBAL(clacgv,CLACGV)
#define LAPACK_zlacgv LAPACK_GLOBAL(zlacgv,ZLACGV)
#define LAPACK_slarnv LAPACK_GLOBAL(slarnv,SLARNV)
#define LAPACK_dlarnv LAPACK_GLOBAL(dlarnv,DLARNV)
#define LAPACK_clarnv LAPACK_GLOBAL(clarnv,CLARNV)
#define LAPACK_zlarnv LAPACK_GLOBAL(zlarnv,ZLARNV)
#define LAPACK_sgeqr2 LAPACK_GLOBAL(sgeqr2,SGEQR2)
#define LAPACK_dgeqr2 LAPACK_GLOBAL(dgeqr2,DGEQR2)
#define LAPACK_cgeqr2 LAPACK_GLOBAL(cgeqr2,CGEQR2)
#define LAPACK_zgeqr2 LAPACK_GLOBAL(zgeqr2,ZGEQR2)
#define LAPACK_slacpy LAPACK_GLOBAL(slacpy,SLACPY)
#define LAPACK_dlacpy LAPACK_GLOBAL(dlacpy,DLACPY)
#define LAPACK_clacpy LAPACK_GLOBAL(clacpy,CLACPY)
#define LAPACK_zlacpy LAPACK_GLOBAL(zlacpy,ZLACPY)
#define LAPACK_sgetf2 LAPACK_GLOBAL(sgetf2,SGETF2)
#define LAPACK_dgetf2 LAPACK_GLOBAL(dgetf2,DGETF2)
#define LAPACK_cgetf2 LAPACK_GLOBAL(cgetf2,CGETF2)
#define LAPACK_zgetf2 LAPACK_GLOBAL(zgetf2,ZGETF2)
#define LAPACK_slaswp LAPACK_GLOBAL(slaswp,SLASWP)
#define LAPACK_dlaswp LAPACK_GLOBAL(dlaswp,DLASWP)
#define LAPACK_claswp LAPACK_GLOBAL(claswp,CLASWP)
#define LAPACK_zlaswp LAPACK_GLOBAL(zlaswp,ZLASWP)
#define LAPACK_slange LAPACK_GLOBAL(slange,SLANGE)
#define LAPACK_dlange LAPACK_GLOBAL(dlange,DLANGE)
#define LAPACK_clange LAPACK_GLOBAL(clange,CLANGE)
#define LAPACK_zlange LAPACK_GLOBAL(zlange,ZLANGE)
#define LAPACK_clanhe LAPACK_GLOBAL(clanhe,CLANHE)
#define LAPACK_zlanhe LAPACK_GLOBAL(zlanhe,ZLANHE)
#define LAPACK_slansy LAPACK_GLOBAL(slansy,SLANSY)
#define LAPACK_dlansy LAPACK_GLOBAL(dlansy,DLANSY)
#define LAPACK_clansy LAPACK_GLOBAL(clansy,CLANSY)
#define LAPACK_zlansy LAPACK_GLOBAL(zlansy,ZLANSY)
#define LAPACK_slantr LAPACK_GLOBAL(slantr,SLANTR)
#define LAPACK_dlantr LAPACK_GLOBAL(dlantr,DLANTR)
#define LAPACK_clantr LAPACK_GLOBAL(clantr,CLANTR)
#define LAPACK_zlantr LAPACK_GLOBAL(zlantr,ZLANTR)
#define LAPACK_slamch LAPACK_GLOBAL(slamch,SLAMCH)
#define LAPACK_dlamch LAPACK_GLOBAL(dlamch,DLAMCH)
#define LAPACK_sgelq2 LAPACK_GLOBAL(sgelq2,SGELQ2)
#define LAPACK_dgelq2 LAPACK_GLOBAL(dgelq2,DGELQ2)
#define LAPACK_cgelq2 LAPACK_GLOBAL(cgelq2,CGELQ2)
#define LAPACK_zgelq2 LAPACK_GLOBAL(zgelq2,ZGELQ2)
#define LAPACK_slarfb LAPACK_GLOBAL(slarfb,SLARFB)
#define LAPACK_dlarfb LAPACK_GLOBAL(dlarfb,DLARFB)
#define LAPACK_clarfb LAPACK_GLOBAL(clarfb,CLARFB)
#define LAPACK_zlarfb LAPACK_GLOBAL(zlarfb,ZLARFB)
#define LAPACK_slarfg LAPACK_GLOBAL(slarfg,SLARFG)
#define LAPACK_dlarfg LAPACK_GLOBAL(dlarfg,DLARFG)
#define LAPACK_clarfg LAPACK_GLOBAL(clarfg,CLARFG)
#define LAPACK_zlarfg LAPACK_GLOBAL(zlarfg,ZLARFG)
#define LAPACK_slarft LAPACK_GLOBAL(slarft,SLARFT)
#define LAPACK_dlarft LAPACK_GLOBAL(dlarft,DLARFT)
#define LAPACK_clarft LAPACK_GLOBAL(clarft,CLARFT)
#define LAPACK_zlarft LAPACK_GLOBAL(zlarft,ZLARFT)
#define LAPACK_slarfx LAPACK_GLOBAL(slarfx,SLARFX)
#define LAPACK_dlarfx LAPACK_GLOBAL(dlarfx,DLARFX)
#define LAPACK_clarfx LAPACK_GLOBAL(clarfx,CLARFX)
#define LAPACK_zlarfx LAPACK_GLOBAL(zlarfx,ZLARFX)
#define LAPACK_slatms LAPACK_GLOBAL(slatms,SLATMS)
#define LAPACK_dlatms LAPACK_GLOBAL(dlatms,DLATMS)
#define LAPACK_clatms LAPACK_GLOBAL(clatms,CLATMS)
#define LAPACK_zlatms LAPACK_GLOBAL(zlatms,ZLATMS)
#define LAPACK_slag2d LAPACK_GLOBAL(slag2d,SLAG2D)
#define LAPACK_dlag2s LAPACK_GLOBAL(dlag2s,DLAG2S)
#define LAPACK_clag2z LAPACK_GLOBAL(clag2z,CLAG2Z)
#define LAPACK_zlag2c LAPACK_GLOBAL(zlag2c,ZLAG2C)
#define LAPACK_slauum LAPACK_GLOBAL(slauum,SLAUUM)
#define LAPACK_dlauum LAPACK_GLOBAL(dlauum,DLAUUM)
#define LAPACK_clauum LAPACK_GLOBAL(clauum,CLAUUM)
#define LAPACK_zlauum LAPACK_GLOBAL(zlauum,ZLAUUM)
#define LAPACK_slagge LAPACK_GLOBAL(slagge,SLAGGE)
#define LAPACK_dlagge LAPACK_GLOBAL(dlagge,DLAGGE)
#define LAPACK_clagge LAPACK_GLOBAL(clagge,CLAGGE)
#define LAPACK_zlagge LAPACK_GLOBAL(zlagge,ZLAGGE)
#define LAPACK_slaset LAPACK_GLOBAL(slaset,SLASET)
#define LAPACK_dlaset LAPACK_GLOBAL(dlaset,DLASET)
#define LAPACK_claset LAPACK_GLOBAL(claset,CLASET)
#define LAPACK_zlaset LAPACK_GLOBAL(zlaset,ZLASET)
#define LAPACK_slasrt LAPACK_GLOBAL(slasrt,SLASRT)
#define LAPACK_dlasrt LAPACK_GLOBAL(dlasrt,DLASRT)
#define LAPACK_slagsy LAPACK_GLOBAL(slagsy,SLAGSY)
#define LAPACK_dlagsy LAPACK_GLOBAL(dlagsy,DLAGSY)
#define LAPACK_clagsy LAPACK_GLOBAL(clagsy,CLAGSY)
#define LAPACK_zlagsy LAPACK_GLOBAL(zlagsy,ZLAGSY)
#define LAPACK_claghe LAPACK_GLOBAL(claghe,CLAGHE)
#define LAPACK_zlaghe LAPACK_GLOBAL(zlaghe,ZLAGHE)
#define LAPACK_slapmr LAPACK_GLOBAL(slapmr,SLAPMR)
#define LAPACK_dlapmr LAPACK_GLOBAL(dlapmr,DLAPMR)
#define LAPACK_clapmr LAPACK_GLOBAL(clapmr,CLAPMR)
#define LAPACK_zlapmr LAPACK_GLOBAL(zlapmr,ZLAPMR)
#define LAPACK_slapy2 LAPACK_GLOBAL(slapy2,SLAPY2)
#define LAPACK_dlapy2 LAPACK_GLOBAL(dlapy2,DLAPY2)
#define LAPACK_slapy3 LAPACK_GLOBAL(slapy3,SLAPY3)
#define LAPACK_dlapy3 LAPACK_GLOBAL(dlapy3,DLAPY3)
#define LAPACK_slartgp LAPACK_GLOBAL(slartgp,SLARTGP)
#define LAPACK_dlartgp LAPACK_GLOBAL(dlartgp,DLARTGP)
#define LAPACK_slartgs LAPACK_GLOBAL(slartgs,SLARTGS)
#define LAPACK_dlartgs LAPACK_GLOBAL(dlartgs,DLARTGS)
// LAPACK 3.3.0
#define LAPACK_cbbcsd LAPACK_GLOBAL(cbbcsd,CBBCSD)
#define LAPACK_cheswapr LAPACK_GLOBAL(cheswapr,CHESWAPR)
#define LAPACK_chetri2 LAPACK_GLOBAL(chetri2,CHETRI2)
#define LAPACK_chetri2x LAPACK_GLOBAL(chetri2x,CHETRI2X)
#define LAPACK_chetrs2 LAPACK_GLOBAL(chetrs2,CHETRS2)
#define LAPACK_csyconv LAPACK_GLOBAL(csyconv,CSYCONV)
#define LAPACK_csyswapr LAPACK_GLOBAL(csyswapr,CSYSWAPR)
#define LAPACK_csytri2 LAPACK_GLOBAL(csytri2,CSYTRI2)
#define LAPACK_csytri2x LAPACK_GLOBAL(csytri2x,CSYTRI2X)
#define LAPACK_csytrs2 LAPACK_GLOBAL(csytrs2,CSYTRS2)
#define LAPACK_cunbdb LAPACK_GLOBAL(cunbdb,CUNBDB)
#define LAPACK_cuncsd LAPACK_GLOBAL(cuncsd,CUNCSD)
#define LAPACK_dbbcsd LAPACK_GLOBAL(dbbcsd,DBBCSD)
#define LAPACK_dorbdb LAPACK_GLOBAL(dorbdb,DORBDB)
#define LAPACK_dorcsd LAPACK_GLOBAL(dorcsd,DORCSD)
#define LAPACK_dsyconv LAPACK_GLOBAL(dsyconv,DSYCONV)
#define LAPACK_dsyswapr LAPACK_GLOBAL(dsyswapr,DSYSWAPR)
#define LAPACK_dsytri2 LAPACK_GLOBAL(dsytri2,DSYTRI2)
#define LAPACK_dsytri2x LAPACK_GLOBAL(dsytri2x,DSYTRI2X)
#define LAPACK_dsytrs2 LAPACK_GLOBAL(dsytrs2,DSYTRS2)
#define LAPACK_sbbcsd LAPACK_GLOBAL(sbbcsd,SBBCSD)
#define LAPACK_sorbdb LAPACK_GLOBAL(sorbdb,SORBDB)
#define LAPACK_sorcsd LAPACK_GLOBAL(sorcsd,SORCSD)
#define LAPACK_ssyconv LAPACK_GLOBAL(ssyconv,SSYCONV)
#define LAPACK_ssyswapr LAPACK_GLOBAL(ssyswapr,SSYSWAPR)
#define LAPACK_ssytri2 LAPACK_GLOBAL(ssytri2,SSYTRI2)
#define LAPACK_ssytri2x LAPACK_GLOBAL(ssytri2x,SSYTRI2X)
#define LAPACK_ssytrs2 LAPACK_GLOBAL(ssytrs2,SSYTRS2)
#define LAPACK_zbbcsd LAPACK_GLOBAL(zbbcsd,ZBBCSD)
#define LAPACK_zheswapr LAPACK_GLOBAL(zheswapr,ZHESWAPR)
#define LAPACK_zhetri2 LAPACK_GLOBAL(zhetri2,ZHETRI2)
#define LAPACK_zhetri2x LAPACK_GLOBAL(zhetri2x,ZHETRI2X)
#define LAPACK_zhetrs2 LAPACK_GLOBAL(zhetrs2,ZHETRS2)
#define LAPACK_zsyconv LAPACK_GLOBAL(zsyconv,ZSYCONV)
#define LAPACK_zsyswapr LAPACK_GLOBAL(zsyswapr,ZSYSWAPR)
#define LAPACK_zsytri2 LAPACK_GLOBAL(zsytri2,ZSYTRI2)
#define LAPACK_zsytri2x LAPACK_GLOBAL(zsytri2x,ZSYTRI2X)
#define LAPACK_zsytrs2 LAPACK_GLOBAL(zsytrs2,ZSYTRS2)
#define LAPACK_zunbdb LAPACK_GLOBAL(zunbdb,ZUNBDB)
#define LAPACK_zuncsd LAPACK_GLOBAL(zuncsd,ZUNCSD)
// LAPACK 3.4.0
#define LAPACK_sgemqrt LAPACK_GLOBAL(sgemqrt,SGEMQRT)
#define LAPACK_dgemqrt LAPACK_GLOBAL(dgemqrt,DGEMQRT)
#define LAPACK_cgemqrt LAPACK_GLOBAL(cgemqrt,CGEMQRT)
#define LAPACK_zgemqrt LAPACK_GLOBAL(zgemqrt,ZGEMQRT)
#define LAPACK_sgeqrt LAPACK_GLOBAL(sgeqrt,SGEQRT)
#define LAPACK_dgeqrt LAPACK_GLOBAL(dgeqrt,DGEQRT)
#define LAPACK_cgeqrt LAPACK_GLOBAL(cgeqrt,CGEQRT)
#define LAPACK_zgeqrt LAPACK_GLOBAL(zgeqrt,ZGEQRT)
#define LAPACK_sgeqrt2 LAPACK_GLOBAL(sgeqrt2,SGEQRT2)
#define LAPACK_dgeqrt2 LAPACK_GLOBAL(dgeqrt2,DGEQRT2)
#define LAPACK_cgeqrt2 LAPACK_GLOBAL(cgeqrt2,CGEQRT2)
#define LAPACK_zgeqrt2 LAPACK_GLOBAL(zgeqrt2,ZGEQRT2)
#define LAPACK_sgeqrt3 LAPACK_GLOBAL(sgeqrt3,SGEQRT3)
#define LAPACK_dgeqrt3 LAPACK_GLOBAL(dgeqrt3,DGEQRT3)
#define LAPACK_cgeqrt3 LAPACK_GLOBAL(cgeqrt3,CGEQRT3)
#define LAPACK_zgeqrt3 LAPACK_GLOBAL(zgeqrt3,ZGEQRT3)
#define LAPACK_stpmqrt LAPACK_GLOBAL(stpmqrt,STPMQRT)
#define LAPACK_dtpmqrt LAPACK_GLOBAL(dtpmqrt,DTPMQRT)
#define LAPACK_ctpmqrt LAPACK_GLOBAL(ctpmqrt,CTPMQRT)
#define LAPACK_ztpmqrt LAPACK_GLOBAL(ztpmqrt,ZTPMQRT)
#define LAPACK_dtpqrt LAPACK_GLOBAL(dtpqrt,DTPQRT)
#define LAPACK_ctpqrt LAPACK_GLOBAL(ctpqrt,CTPQRT)
#define LAPACK_ztpqrt LAPACK_GLOBAL(ztpqrt,ZTPQRT)
#define LAPACK_stpqrt2 LAPACK_GLOBAL(stpqrt2,STPQRT2)
#define LAPACK_dtpqrt2 LAPACK_GLOBAL(dtpqrt2,DTPQRT2)
#define LAPACK_ctpqrt2 LAPACK_GLOBAL(ctpqrt2,CTPQRT2)
#define LAPACK_ztpqrt2 LAPACK_GLOBAL(ztpqrt2,ZTPQRT2)
#define LAPACK_stprfb LAPACK_GLOBAL(stprfb,STPRFB)
#define LAPACK_dtprfb LAPACK_GLOBAL(dtprfb,DTPRFB)
#define LAPACK_ctprfb LAPACK_GLOBAL(ctprfb,CTPRFB)
#define LAPACK_ztprfb LAPACK_GLOBAL(ztprfb,ZTPRFB)
// LAPACK 3.X.X
#define LAPACK_csyr LAPACK_GLOBAL(csyr,CSYR)
#define LAPACK_zsyr LAPACK_GLOBAL(zsyr,ZSYR)
void LAPACK_sgetrf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
lapack_int* ipiv, lapack_int *info );
void LAPACK_dgetrf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
lapack_int* ipiv, lapack_int *info );
void LAPACK_cgetrf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_int* ipiv, lapack_int *info );
void LAPACK_zgetrf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_int* ipiv, lapack_int *info );
void LAPACK_sgbtrf( lapack_int* m, lapack_int* n, lapack_int* kl,
lapack_int* ku, float* ab, lapack_int* ldab,
lapack_int* ipiv, lapack_int *info );
void LAPACK_dgbtrf( lapack_int* m, lapack_int* n, lapack_int* kl,
lapack_int* ku, double* ab, lapack_int* ldab,
lapack_int* ipiv, lapack_int *info );
void LAPACK_cgbtrf( lapack_int* m, lapack_int* n, lapack_int* kl,
lapack_int* ku, lapack_complex_float* ab, lapack_int* ldab,
lapack_int* ipiv, lapack_int *info );
void LAPACK_zgbtrf( lapack_int* m, lapack_int* n, lapack_int* kl,
lapack_int* ku, lapack_complex_double* ab, lapack_int* ldab,
lapack_int* ipiv, lapack_int *info );
void LAPACK_sgttrf( lapack_int* n, float* dl, float* d, float* du, float* du2,
lapack_int* ipiv, lapack_int *info );
void LAPACK_dgttrf( lapack_int* n, double* dl, double* d, double* du,
double* du2, lapack_int* ipiv, lapack_int *info );
void LAPACK_cgttrf( lapack_int* n, lapack_complex_float* dl,
lapack_complex_float* d, lapack_complex_float* du,
lapack_complex_float* du2, lapack_int* ipiv,
lapack_int *info );
void LAPACK_zgttrf( lapack_int* n, lapack_complex_double* dl,
lapack_complex_double* d, lapack_complex_double* du,
lapack_complex_double* du2, lapack_int* ipiv,
lapack_int *info );
void LAPACK_spotrf( char* uplo, lapack_int* n, float* a, lapack_int* lda,
lapack_int *info );
void LAPACK_dpotrf( char* uplo, lapack_int* n, double* a, lapack_int* lda,
lapack_int *info );
void LAPACK_cpotrf( char* uplo, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_int *info );
void LAPACK_zpotrf( char* uplo, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_int *info );
void LAPACK_dpstrf( char* uplo, lapack_int* n, double* a, lapack_int* lda,
lapack_int* piv, lapack_int* rank, double* tol,
double* work, lapack_int *info );
void LAPACK_spstrf( char* uplo, lapack_int* n, float* a, lapack_int* lda,
lapack_int* piv, lapack_int* rank, float* tol, float* work,
lapack_int *info );
void LAPACK_zpstrf( char* uplo, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_int* piv, lapack_int* rank,
double* tol, double* work, lapack_int *info );
void LAPACK_cpstrf( char* uplo, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_int* piv, lapack_int* rank,
float* tol, float* work, lapack_int *info );
void LAPACK_dpftrf( char* transr, char* uplo, lapack_int* n, double* a,
lapack_int *info );
void LAPACK_spftrf( char* transr, char* uplo, lapack_int* n, float* a,
lapack_int *info );
void LAPACK_zpftrf( char* transr, char* uplo, lapack_int* n,
lapack_complex_double* a, lapack_int *info );
void LAPACK_cpftrf( char* transr, char* uplo, lapack_int* n,
lapack_complex_float* a, lapack_int *info );
void LAPACK_spptrf( char* uplo, lapack_int* n, float* ap, lapack_int *info );
void LAPACK_dpptrf( char* uplo, lapack_int* n, double* ap, lapack_int *info );
void LAPACK_cpptrf( char* uplo, lapack_int* n, lapack_complex_float* ap,
lapack_int *info );
void LAPACK_zpptrf( char* uplo, lapack_int* n, lapack_complex_double* ap,
lapack_int *info );
void LAPACK_spbtrf( char* uplo, lapack_int* n, lapack_int* kd, float* ab,
lapack_int* ldab, lapack_int *info );
void LAPACK_dpbtrf( char* uplo, lapack_int* n, lapack_int* kd, double* ab,
lapack_int* ldab, lapack_int *info );
void LAPACK_cpbtrf( char* uplo, lapack_int* n, lapack_int* kd,
lapack_complex_float* ab, lapack_int* ldab,
lapack_int *info );
void LAPACK_zpbtrf( char* uplo, lapack_int* n, lapack_int* kd,
lapack_complex_double* ab, lapack_int* ldab,
lapack_int *info );
void LAPACK_spttrf( lapack_int* n, float* d, float* e, lapack_int *info );
void LAPACK_dpttrf( lapack_int* n, double* d, double* e, lapack_int *info );
void LAPACK_cpttrf( lapack_int* n, float* d, lapack_complex_float* e,
lapack_int *info );
void LAPACK_zpttrf( lapack_int* n, double* d, lapack_complex_double* e,
lapack_int *info );
void LAPACK_ssytrf( char* uplo, lapack_int* n, float* a, lapack_int* lda,
lapack_int* ipiv, float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_dsytrf( char* uplo, lapack_int* n, double* a, lapack_int* lda,
lapack_int* ipiv, double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_csytrf( char* uplo, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_int* ipiv,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_zsytrf( char* uplo, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_int* ipiv,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_chetrf( char* uplo, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_int* ipiv,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_zhetrf( char* uplo, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_int* ipiv,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_ssptrf( char* uplo, lapack_int* n, float* ap, lapack_int* ipiv,
lapack_int *info );
void LAPACK_dsptrf( char* uplo, lapack_int* n, double* ap, lapack_int* ipiv,
lapack_int *info );
void LAPACK_csptrf( char* uplo, lapack_int* n, lapack_complex_float* ap,
lapack_int* ipiv, lapack_int *info );
void LAPACK_zsptrf( char* uplo, lapack_int* n, lapack_complex_double* ap,
lapack_int* ipiv, lapack_int *info );
void LAPACK_chptrf( char* uplo, lapack_int* n, lapack_complex_float* ap,
lapack_int* ipiv, lapack_int *info );
void LAPACK_zhptrf( char* uplo, lapack_int* n, lapack_complex_double* ap,
lapack_int* ipiv, lapack_int *info );
void LAPACK_sgetrs( char* trans, lapack_int* n, lapack_int* nrhs,
const float* a, lapack_int* lda, const lapack_int* ipiv,
float* b, lapack_int* ldb, lapack_int *info );
void LAPACK_dgetrs( char* trans, lapack_int* n, lapack_int* nrhs,
const double* a, lapack_int* lda, const lapack_int* ipiv,
double* b, lapack_int* ldb, lapack_int *info );
void LAPACK_cgetrs( char* trans, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* a, lapack_int* lda,
const lapack_int* ipiv, lapack_complex_float* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_zgetrs( char* trans, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* a, lapack_int* lda,
const lapack_int* ipiv, lapack_complex_double* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_sgbtrs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
lapack_int* nrhs, const float* ab, lapack_int* ldab,
const lapack_int* ipiv, float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_dgbtrs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
lapack_int* nrhs, const double* ab, lapack_int* ldab,
const lapack_int* ipiv, double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_cgbtrs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
lapack_int* nrhs, const lapack_complex_float* ab,
lapack_int* ldab, const lapack_int* ipiv,
lapack_complex_float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_zgbtrs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
lapack_int* nrhs, const lapack_complex_double* ab,
lapack_int* ldab, const lapack_int* ipiv,
lapack_complex_double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_sgttrs( char* trans, lapack_int* n, lapack_int* nrhs,
const float* dl, const float* d, const float* du,
const float* du2, const lapack_int* ipiv, float* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_dgttrs( char* trans, lapack_int* n, lapack_int* nrhs,
const double* dl, const double* d, const double* du,
const double* du2, const lapack_int* ipiv, double* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_cgttrs( char* trans, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* dl,
const lapack_complex_float* d,
const lapack_complex_float* du,
const lapack_complex_float* du2, const lapack_int* ipiv,
lapack_complex_float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_zgttrs( char* trans, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* dl,
const lapack_complex_double* d,
const lapack_complex_double* du,
const lapack_complex_double* du2, const lapack_int* ipiv,
lapack_complex_double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_spotrs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* a,
lapack_int* lda, float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_dpotrs( char* uplo, lapack_int* n, lapack_int* nrhs,
const double* a, lapack_int* lda, double* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_cpotrs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_zpotrs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_dpftrs( char* transr, char* uplo, lapack_int* n, lapack_int* nrhs,
const double* a, double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_spftrs( char* transr, char* uplo, lapack_int* n, lapack_int* nrhs,
const float* a, float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_zpftrs( char* transr, char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* a, lapack_complex_double* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_cpftrs( char* transr, char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* a, lapack_complex_float* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_spptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
const float* ap, float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_dpptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
const double* ap, double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_cpptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* ap, lapack_complex_float* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_zpptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* ap, lapack_complex_double* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_spbtrs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
const float* ab, lapack_int* ldab, float* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_dpbtrs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
const double* ab, lapack_int* ldab, double* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_cpbtrs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
const lapack_complex_float* ab, lapack_int* ldab,
lapack_complex_float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_zpbtrs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
const lapack_complex_double* ab, lapack_int* ldab,
lapack_complex_double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_spttrs( lapack_int* n, lapack_int* nrhs, const float* d,
const float* e, float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_dpttrs( lapack_int* n, lapack_int* nrhs, const double* d,
const double* e, double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_cpttrs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* d,
const lapack_complex_float* e, lapack_complex_float* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_zpttrs( char* uplo, lapack_int* n, lapack_int* nrhs,
const double* d, const lapack_complex_double* e,
lapack_complex_double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_ssytrs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* a,
lapack_int* lda, const lapack_int* ipiv, float* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_dsytrs( char* uplo, lapack_int* n, lapack_int* nrhs,
const double* a, lapack_int* lda, const lapack_int* ipiv,
double* b, lapack_int* ldb, lapack_int *info );
void LAPACK_csytrs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* a, lapack_int* lda,
const lapack_int* ipiv, lapack_complex_float* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_zsytrs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* a, lapack_int* lda,
const lapack_int* ipiv, lapack_complex_double* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_chetrs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* a, lapack_int* lda,
const lapack_int* ipiv, lapack_complex_float* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_zhetrs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* a, lapack_int* lda,
const lapack_int* ipiv, lapack_complex_double* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_ssptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
const float* ap, const lapack_int* ipiv, float* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_dsptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
const double* ap, const lapack_int* ipiv, double* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_csptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* ap, const lapack_int* ipiv,
lapack_complex_float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_zsptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* ap, const lapack_int* ipiv,
lapack_complex_double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_chptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* ap, const lapack_int* ipiv,
lapack_complex_float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_zhptrs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* ap, const lapack_int* ipiv,
lapack_complex_double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_strtrs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* nrhs, const float* a, lapack_int* lda, float* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_dtrtrs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* nrhs, const double* a, lapack_int* lda,
double* b, lapack_int* ldb, lapack_int *info );
void LAPACK_ctrtrs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* nrhs, const lapack_complex_float* a,
lapack_int* lda, lapack_complex_float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_ztrtrs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* nrhs, const lapack_complex_double* a,
lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_stptrs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* nrhs, const float* ap, float* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_dtptrs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* nrhs, const double* ap, double* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_ctptrs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* nrhs, const lapack_complex_float* ap,
lapack_complex_float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_ztptrs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* nrhs, const lapack_complex_double* ap,
lapack_complex_double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_stbtrs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* kd, lapack_int* nrhs, const float* ab,
lapack_int* ldab, float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_dtbtrs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* kd, lapack_int* nrhs, const double* ab,
lapack_int* ldab, double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_ctbtrs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* kd, lapack_int* nrhs,
const lapack_complex_float* ab, lapack_int* ldab,
lapack_complex_float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_ztbtrs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* kd, lapack_int* nrhs,
const lapack_complex_double* ab, lapack_int* ldab,
lapack_complex_double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_sgecon( char* norm, lapack_int* n, const float* a, lapack_int* lda,
float* anorm, float* rcond, float* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_dgecon( char* norm, lapack_int* n, const double* a, lapack_int* lda,
double* anorm, double* rcond, double* work,
lapack_int* iwork, lapack_int *info );
void LAPACK_cgecon( char* norm, lapack_int* n, const lapack_complex_float* a,
lapack_int* lda, float* anorm, float* rcond,
lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_zgecon( char* norm, lapack_int* n, const lapack_complex_double* a,
lapack_int* lda, double* anorm, double* rcond,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_sgbcon( char* norm, lapack_int* n, lapack_int* kl, lapack_int* ku,
const float* ab, lapack_int* ldab, const lapack_int* ipiv,
float* anorm, float* rcond, float* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_dgbcon( char* norm, lapack_int* n, lapack_int* kl, lapack_int* ku,
const double* ab, lapack_int* ldab, const lapack_int* ipiv,
double* anorm, double* rcond, double* work,
lapack_int* iwork, lapack_int *info );
void LAPACK_cgbcon( char* norm, lapack_int* n, lapack_int* kl, lapack_int* ku,
const lapack_complex_float* ab, lapack_int* ldab,
const lapack_int* ipiv, float* anorm, float* rcond,
lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_zgbcon( char* norm, lapack_int* n, lapack_int* kl, lapack_int* ku,
const lapack_complex_double* ab, lapack_int* ldab,
const lapack_int* ipiv, double* anorm, double* rcond,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_sgtcon( char* norm, lapack_int* n, const float* dl, const float* d,
const float* du, const float* du2, const lapack_int* ipiv,
float* anorm, float* rcond, float* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_dgtcon( char* norm, lapack_int* n, const double* dl,
const double* d, const double* du, const double* du2,
const lapack_int* ipiv, double* anorm, double* rcond,
double* work, lapack_int* iwork, lapack_int *info );
void LAPACK_cgtcon( char* norm, lapack_int* n, const lapack_complex_float* dl,
const lapack_complex_float* d,
const lapack_complex_float* du,
const lapack_complex_float* du2, const lapack_int* ipiv,
float* anorm, float* rcond, lapack_complex_float* work,
lapack_int *info );
void LAPACK_zgtcon( char* norm, lapack_int* n, const lapack_complex_double* dl,
const lapack_complex_double* d,
const lapack_complex_double* du,
const lapack_complex_double* du2, const lapack_int* ipiv,
double* anorm, double* rcond, lapack_complex_double* work,
lapack_int *info );
void LAPACK_spocon( char* uplo, lapack_int* n, const float* a, lapack_int* lda,
float* anorm, float* rcond, float* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_dpocon( char* uplo, lapack_int* n, const double* a, lapack_int* lda,
double* anorm, double* rcond, double* work,
lapack_int* iwork, lapack_int *info );
void LAPACK_cpocon( char* uplo, lapack_int* n, const lapack_complex_float* a,
lapack_int* lda, float* anorm, float* rcond,
lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_zpocon( char* uplo, lapack_int* n, const lapack_complex_double* a,
lapack_int* lda, double* anorm, double* rcond,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_sppcon( char* uplo, lapack_int* n, const float* ap, float* anorm,
float* rcond, float* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_dppcon( char* uplo, lapack_int* n, const double* ap, double* anorm,
double* rcond, double* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_cppcon( char* uplo, lapack_int* n, const lapack_complex_float* ap,
float* anorm, float* rcond, lapack_complex_float* work,
float* rwork, lapack_int *info );
void LAPACK_zppcon( char* uplo, lapack_int* n, const lapack_complex_double* ap,
double* anorm, double* rcond, lapack_complex_double* work,
double* rwork, lapack_int *info );
void LAPACK_spbcon( char* uplo, lapack_int* n, lapack_int* kd, const float* ab,
lapack_int* ldab, float* anorm, float* rcond, float* work,
lapack_int* iwork, lapack_int *info );
void LAPACK_dpbcon( char* uplo, lapack_int* n, lapack_int* kd, const double* ab,
lapack_int* ldab, double* anorm, double* rcond,
double* work, lapack_int* iwork, lapack_int *info );
void LAPACK_cpbcon( char* uplo, lapack_int* n, lapack_int* kd,
const lapack_complex_float* ab, lapack_int* ldab,
float* anorm, float* rcond, lapack_complex_float* work,
float* rwork, lapack_int *info );
void LAPACK_zpbcon( char* uplo, lapack_int* n, lapack_int* kd,
const lapack_complex_double* ab, lapack_int* ldab,
double* anorm, double* rcond, lapack_complex_double* work,
double* rwork, lapack_int *info );
void LAPACK_sptcon( lapack_int* n, const float* d, const float* e, float* anorm,
float* rcond, float* work, lapack_int *info );
void LAPACK_dptcon( lapack_int* n, const double* d, const double* e,
double* anorm, double* rcond, double* work,
lapack_int *info );
void LAPACK_cptcon( lapack_int* n, const float* d,
const lapack_complex_float* e, float* anorm, float* rcond,
float* work, lapack_int *info );
void LAPACK_zptcon( lapack_int* n, const double* d,
const lapack_complex_double* e, double* anorm,
double* rcond, double* work, lapack_int *info );
void LAPACK_ssycon( char* uplo, lapack_int* n, const float* a, lapack_int* lda,
const lapack_int* ipiv, float* anorm, float* rcond,
float* work, lapack_int* iwork, lapack_int *info );
void LAPACK_dsycon( char* uplo, lapack_int* n, const double* a, lapack_int* lda,
const lapack_int* ipiv, double* anorm, double* rcond,
double* work, lapack_int* iwork, lapack_int *info );
void LAPACK_csycon( char* uplo, lapack_int* n, const lapack_complex_float* a,
lapack_int* lda, const lapack_int* ipiv, float* anorm,
float* rcond, lapack_complex_float* work,
lapack_int *info );
void LAPACK_zsycon( char* uplo, lapack_int* n, const lapack_complex_double* a,
lapack_int* lda, const lapack_int* ipiv, double* anorm,
double* rcond, lapack_complex_double* work,
lapack_int *info );
void LAPACK_checon( char* uplo, lapack_int* n, const lapack_complex_float* a,
lapack_int* lda, const lapack_int* ipiv, float* anorm,
float* rcond, lapack_complex_float* work,
lapack_int *info );
void LAPACK_zhecon( char* uplo, lapack_int* n, const lapack_complex_double* a,
lapack_int* lda, const lapack_int* ipiv, double* anorm,
double* rcond, lapack_complex_double* work,
lapack_int *info );
void LAPACK_sspcon( char* uplo, lapack_int* n, const float* ap,
const lapack_int* ipiv, float* anorm, float* rcond,
float* work, lapack_int* iwork, lapack_int *info );
void LAPACK_dspcon( char* uplo, lapack_int* n, const double* ap,
const lapack_int* ipiv, double* anorm, double* rcond,
double* work, lapack_int* iwork, lapack_int *info );
void LAPACK_cspcon( char* uplo, lapack_int* n, const lapack_complex_float* ap,
const lapack_int* ipiv, float* anorm, float* rcond,
lapack_complex_float* work, lapack_int *info );
void LAPACK_zspcon( char* uplo, lapack_int* n, const lapack_complex_double* ap,
const lapack_int* ipiv, double* anorm, double* rcond,
lapack_complex_double* work, lapack_int *info );
void LAPACK_chpcon( char* uplo, lapack_int* n, const lapack_complex_float* ap,
const lapack_int* ipiv, float* anorm, float* rcond,
lapack_complex_float* work, lapack_int *info );
void LAPACK_zhpcon( char* uplo, lapack_int* n, const lapack_complex_double* ap,
const lapack_int* ipiv, double* anorm, double* rcond,
lapack_complex_double* work, lapack_int *info );
void LAPACK_strcon( char* norm, char* uplo, char* diag, lapack_int* n,
const float* a, lapack_int* lda, float* rcond, float* work,
lapack_int* iwork, lapack_int *info );
void LAPACK_dtrcon( char* norm, char* uplo, char* diag, lapack_int* n,
const double* a, lapack_int* lda, double* rcond,
double* work, lapack_int* iwork, lapack_int *info );
void LAPACK_ctrcon( char* norm, char* uplo, char* diag, lapack_int* n,
const lapack_complex_float* a, lapack_int* lda,
float* rcond, lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_ztrcon( char* norm, char* uplo, char* diag, lapack_int* n,
const lapack_complex_double* a, lapack_int* lda,
double* rcond, lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_stpcon( char* norm, char* uplo, char* diag, lapack_int* n,
const float* ap, float* rcond, float* work,
lapack_int* iwork, lapack_int *info );
void LAPACK_dtpcon( char* norm, char* uplo, char* diag, lapack_int* n,
const double* ap, double* rcond, double* work,
lapack_int* iwork, lapack_int *info );
void LAPACK_ctpcon( char* norm, char* uplo, char* diag, lapack_int* n,
const lapack_complex_float* ap, float* rcond,
lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_ztpcon( char* norm, char* uplo, char* diag, lapack_int* n,
const lapack_complex_double* ap, double* rcond,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_stbcon( char* norm, char* uplo, char* diag, lapack_int* n,
lapack_int* kd, const float* ab, lapack_int* ldab,
float* rcond, float* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_dtbcon( char* norm, char* uplo, char* diag, lapack_int* n,
lapack_int* kd, const double* ab, lapack_int* ldab,
double* rcond, double* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_ctbcon( char* norm, char* uplo, char* diag, lapack_int* n,
lapack_int* kd, const lapack_complex_float* ab,
lapack_int* ldab, float* rcond, lapack_complex_float* work,
float* rwork, lapack_int *info );
void LAPACK_ztbcon( char* norm, char* uplo, char* diag, lapack_int* n,
lapack_int* kd, const lapack_complex_double* ab,
lapack_int* ldab, double* rcond,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_sgerfs( char* trans, lapack_int* n, lapack_int* nrhs,
const float* a, lapack_int* lda, const float* af,
lapack_int* ldaf, const lapack_int* ipiv, const float* b,
lapack_int* ldb, float* x, lapack_int* ldx, float* ferr,
float* berr, float* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_dgerfs( char* trans, lapack_int* n, lapack_int* nrhs,
const double* a, lapack_int* lda, const double* af,
lapack_int* ldaf, const lapack_int* ipiv, const double* b,
lapack_int* ldb, double* x, lapack_int* ldx, double* ferr,
double* berr, double* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_cgerfs( char* trans, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* a, lapack_int* lda,
const lapack_complex_float* af, lapack_int* ldaf,
const lapack_int* ipiv, const lapack_complex_float* b,
lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
float* ferr, float* berr, lapack_complex_float* work,
float* rwork, lapack_int *info );
void LAPACK_zgerfs( char* trans, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* a, lapack_int* lda,
const lapack_complex_double* af, lapack_int* ldaf,
const lapack_int* ipiv, const lapack_complex_double* b,
lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
double* ferr, double* berr, lapack_complex_double* work,
double* rwork, lapack_int *info );
void LAPACK_dgerfsx( char* trans, char* equed, lapack_int* n, lapack_int* nrhs,
const double* a, lapack_int* lda, const double* af,
lapack_int* ldaf, const lapack_int* ipiv, const double* r,
const double* c, const double* b, lapack_int* ldb,
double* x, lapack_int* ldx, double* rcond, double* berr,
lapack_int* n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int* nparams, double* params,
double* work, lapack_int* iwork, lapack_int *info );
void LAPACK_sgerfsx( char* trans, char* equed, lapack_int* n, lapack_int* nrhs,
const float* a, lapack_int* lda, const float* af,
lapack_int* ldaf, const lapack_int* ipiv, const float* r,
const float* c, const float* b, lapack_int* ldb, float* x,
lapack_int* ldx, float* rcond, float* berr,
lapack_int* n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int* nparams, float* params,
float* work, lapack_int* iwork, lapack_int *info );
void LAPACK_zgerfsx( char* trans, char* equed, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* a, lapack_int* lda,
const lapack_complex_double* af, lapack_int* ldaf,
const lapack_int* ipiv, const double* r, const double* c,
const lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* rcond,
double* berr, lapack_int* n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int* nparams, double* params,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_cgerfsx( char* trans, char* equed, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* a, lapack_int* lda,
const lapack_complex_float* af, lapack_int* ldaf,
const lapack_int* ipiv, const float* r, const float* c,
const lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* rcond,
float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int* nparams, float* params,
lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_sgbrfs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
lapack_int* nrhs, const float* ab, lapack_int* ldab,
const float* afb, lapack_int* ldafb, const lapack_int* ipiv,
const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
float* ferr, float* berr, float* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_dgbrfs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
lapack_int* nrhs, const double* ab, lapack_int* ldab,
const double* afb, lapack_int* ldafb,
const lapack_int* ipiv, const double* b, lapack_int* ldb,
double* x, lapack_int* ldx, double* ferr, double* berr,
double* work, lapack_int* iwork, lapack_int *info );
void LAPACK_cgbrfs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
lapack_int* nrhs, const lapack_complex_float* ab,
lapack_int* ldab, const lapack_complex_float* afb,
lapack_int* ldafb, const lapack_int* ipiv,
const lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* ferr,
float* berr, lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_zgbrfs( char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku,
lapack_int* nrhs, const lapack_complex_double* ab,
lapack_int* ldab, const lapack_complex_double* afb,
lapack_int* ldafb, const lapack_int* ipiv,
const lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* ferr,
double* berr, lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_dgbrfsx( char* trans, char* equed, lapack_int* n, lapack_int* kl,
lapack_int* ku, lapack_int* nrhs, const double* ab,
lapack_int* ldab, const double* afb, lapack_int* ldafb,
const lapack_int* ipiv, const double* r, const double* c,
const double* b, lapack_int* ldb, double* x,
lapack_int* ldx, double* rcond, double* berr,
lapack_int* n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int* nparams, double* params,
double* work, lapack_int* iwork, lapack_int *info );
void LAPACK_sgbrfsx( char* trans, char* equed, lapack_int* n, lapack_int* kl,
lapack_int* ku, lapack_int* nrhs, const float* ab,
lapack_int* ldab, const float* afb, lapack_int* ldafb,
const lapack_int* ipiv, const float* r, const float* c,
const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
float* rcond, float* berr, lapack_int* n_err_bnds,
float* err_bnds_norm, float* err_bnds_comp,
lapack_int* nparams, float* params, float* work,
lapack_int* iwork, lapack_int *info );
void LAPACK_zgbrfsx( char* trans, char* equed, lapack_int* n, lapack_int* kl,
lapack_int* ku, lapack_int* nrhs,
const lapack_complex_double* ab, lapack_int* ldab,
const lapack_complex_double* afb, lapack_int* ldafb,
const lapack_int* ipiv, const double* r, const double* c,
const lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* rcond,
double* berr, lapack_int* n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int* nparams, double* params,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_cgbrfsx( char* trans, char* equed, lapack_int* n, lapack_int* kl,
lapack_int* ku, lapack_int* nrhs,
const lapack_complex_float* ab, lapack_int* ldab,
const lapack_complex_float* afb, lapack_int* ldafb,
const lapack_int* ipiv, const float* r, const float* c,
const lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* rcond,
float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int* nparams, float* params,
lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_sgtrfs( char* trans, lapack_int* n, lapack_int* nrhs,
const float* dl, const float* d, const float* du,
const float* dlf, const float* df, const float* duf,
const float* du2, const lapack_int* ipiv, const float* b,
lapack_int* ldb, float* x, lapack_int* ldx, float* ferr,
float* berr, float* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_dgtrfs( char* trans, lapack_int* n, lapack_int* nrhs,
const double* dl, const double* d, const double* du,
const double* dlf, const double* df, const double* duf,
const double* du2, const lapack_int* ipiv, const double* b,
lapack_int* ldb, double* x, lapack_int* ldx, double* ferr,
double* berr, double* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_cgtrfs( char* trans, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* dl,
const lapack_complex_float* d,
const lapack_complex_float* du,
const lapack_complex_float* dlf,
const lapack_complex_float* df,
const lapack_complex_float* duf,
const lapack_complex_float* du2, const lapack_int* ipiv,
const lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* ferr,
float* berr, lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_zgtrfs( char* trans, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* dl,
const lapack_complex_double* d,
const lapack_complex_double* du,
const lapack_complex_double* dlf,
const lapack_complex_double* df,
const lapack_complex_double* duf,
const lapack_complex_double* du2, const lapack_int* ipiv,
const lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* ferr,
double* berr, lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_sporfs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* a,
lapack_int* lda, const float* af, lapack_int* ldaf,
const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
float* ferr, float* berr, float* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_dporfs( char* uplo, lapack_int* n, lapack_int* nrhs,
const double* a, lapack_int* lda, const double* af,
lapack_int* ldaf, const double* b, lapack_int* ldb,
double* x, lapack_int* ldx, double* ferr, double* berr,
double* work, lapack_int* iwork, lapack_int *info );
void LAPACK_cporfs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* a, lapack_int* lda,
const lapack_complex_float* af, lapack_int* ldaf,
const lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* ferr,
float* berr, lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_zporfs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* a, lapack_int* lda,
const lapack_complex_double* af, lapack_int* ldaf,
const lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* ferr,
double* berr, lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_dporfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
const double* a, lapack_int* lda, const double* af,
lapack_int* ldaf, const double* s, const double* b,
lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
double* berr, lapack_int* n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int* nparams, double* params, double* work,
lapack_int* iwork, lapack_int *info );
void LAPACK_sporfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
const float* a, lapack_int* lda, const float* af,
lapack_int* ldaf, const float* s, const float* b,
lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int* nparams, float* params,
float* work, lapack_int* iwork, lapack_int *info );
void LAPACK_zporfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* a, lapack_int* lda,
const lapack_complex_double* af, lapack_int* ldaf,
const double* s, const lapack_complex_double* b,
lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
double* rcond, double* berr, lapack_int* n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int* nparams, double* params,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_cporfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* a, lapack_int* lda,
const lapack_complex_float* af, lapack_int* ldaf,
const float* s, const lapack_complex_float* b,
lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
float* rcond, float* berr, lapack_int* n_err_bnds,
float* err_bnds_norm, float* err_bnds_comp,
lapack_int* nparams, float* params,
lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_spprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
const float* ap, const float* afp, const float* b,
lapack_int* ldb, float* x, lapack_int* ldx, float* ferr,
float* berr, float* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_dpprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
const double* ap, const double* afp, const double* b,
lapack_int* ldb, double* x, lapack_int* ldx, double* ferr,
double* berr, double* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_cpprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* ap,
const lapack_complex_float* afp,
const lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* ferr,
float* berr, lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_zpprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* ap,
const lapack_complex_double* afp,
const lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* ferr,
double* berr, lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_spbrfs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
const float* ab, lapack_int* ldab, const float* afb,
lapack_int* ldafb, const float* b, lapack_int* ldb,
float* x, lapack_int* ldx, float* ferr, float* berr,
float* work, lapack_int* iwork, lapack_int *info );
void LAPACK_dpbrfs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
const double* ab, lapack_int* ldab, const double* afb,
lapack_int* ldafb, const double* b, lapack_int* ldb,
double* x, lapack_int* ldx, double* ferr, double* berr,
double* work, lapack_int* iwork, lapack_int *info );
void LAPACK_cpbrfs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
const lapack_complex_float* ab, lapack_int* ldab,
const lapack_complex_float* afb, lapack_int* ldafb,
const lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* ferr,
float* berr, lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_zpbrfs( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
const lapack_complex_double* ab, lapack_int* ldab,
const lapack_complex_double* afb, lapack_int* ldafb,
const lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* ferr,
double* berr, lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_sptrfs( lapack_int* n, lapack_int* nrhs, const float* d,
const float* e, const float* df, const float* ef,
const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
float* ferr, float* berr, float* work, lapack_int *info );
void LAPACK_dptrfs( lapack_int* n, lapack_int* nrhs, const double* d,
const double* e, const double* df, const double* ef,
const double* b, lapack_int* ldb, double* x,
lapack_int* ldx, double* ferr, double* berr, double* work,
lapack_int *info );
void LAPACK_cptrfs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* d,
const lapack_complex_float* e, const float* df,
const lapack_complex_float* ef,
const lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* ferr,
float* berr, lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_zptrfs( char* uplo, lapack_int* n, lapack_int* nrhs,
const double* d, const lapack_complex_double* e,
const double* df, const lapack_complex_double* ef,
const lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* ferr,
double* berr, lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_ssyrfs( char* uplo, lapack_int* n, lapack_int* nrhs, const float* a,
lapack_int* lda, const float* af, lapack_int* ldaf,
const lapack_int* ipiv, const float* b, lapack_int* ldb,
float* x, lapack_int* ldx, float* ferr, float* berr,
float* work, lapack_int* iwork, lapack_int *info );
void LAPACK_dsyrfs( char* uplo, lapack_int* n, lapack_int* nrhs,
const double* a, lapack_int* lda, const double* af,
lapack_int* ldaf, const lapack_int* ipiv, const double* b,
lapack_int* ldb, double* x, lapack_int* ldx, double* ferr,
double* berr, double* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_csyrfs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* a, lapack_int* lda,
const lapack_complex_float* af, lapack_int* ldaf,
const lapack_int* ipiv, const lapack_complex_float* b,
lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
float* ferr, float* berr, lapack_complex_float* work,
float* rwork, lapack_int *info );
void LAPACK_zsyrfs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* a, lapack_int* lda,
const lapack_complex_double* af, lapack_int* ldaf,
const lapack_int* ipiv, const lapack_complex_double* b,
lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
double* ferr, double* berr, lapack_complex_double* work,
double* rwork, lapack_int *info );
void LAPACK_dsyrfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
const double* a, lapack_int* lda, const double* af,
lapack_int* ldaf, const lapack_int* ipiv, const double* s,
const double* b, lapack_int* ldb, double* x,
lapack_int* ldx, double* rcond, double* berr,
lapack_int* n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int* nparams, double* params,
double* work, lapack_int* iwork, lapack_int *info );
void LAPACK_ssyrfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
const float* a, lapack_int* lda, const float* af,
lapack_int* ldaf, const lapack_int* ipiv, const float* s,
const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
float* rcond, float* berr, lapack_int* n_err_bnds,
float* err_bnds_norm, float* err_bnds_comp,
lapack_int* nparams, float* params, float* work,
lapack_int* iwork, lapack_int *info );
void LAPACK_zsyrfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* a, lapack_int* lda,
const lapack_complex_double* af, lapack_int* ldaf,
const lapack_int* ipiv, const double* s,
const lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* rcond,
double* berr, lapack_int* n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int* nparams, double* params,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_csyrfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* a, lapack_int* lda,
const lapack_complex_float* af, lapack_int* ldaf,
const lapack_int* ipiv, const float* s,
const lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* rcond,
float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int* nparams, float* params,
lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_cherfs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* a, lapack_int* lda,
const lapack_complex_float* af, lapack_int* ldaf,
const lapack_int* ipiv, const lapack_complex_float* b,
lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
float* ferr, float* berr, lapack_complex_float* work,
float* rwork, lapack_int *info );
void LAPACK_zherfs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* a, lapack_int* lda,
const lapack_complex_double* af, lapack_int* ldaf,
const lapack_int* ipiv, const lapack_complex_double* b,
lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
double* ferr, double* berr, lapack_complex_double* work,
double* rwork, lapack_int *info );
void LAPACK_zherfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* a, lapack_int* lda,
const lapack_complex_double* af, lapack_int* ldaf,
const lapack_int* ipiv, const double* s,
const lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* rcond,
double* berr, lapack_int* n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int* nparams, double* params,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_cherfsx( char* uplo, char* equed, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* a, lapack_int* lda,
const lapack_complex_float* af, lapack_int* ldaf,
const lapack_int* ipiv, const float* s,
const lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* rcond,
float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int* nparams, float* params,
lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_ssprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
const float* ap, const float* afp, const lapack_int* ipiv,
const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
float* ferr, float* berr, float* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_dsprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
const double* ap, const double* afp, const lapack_int* ipiv,
const double* b, lapack_int* ldb, double* x,
lapack_int* ldx, double* ferr, double* berr, double* work,
lapack_int* iwork, lapack_int *info );
void LAPACK_csprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* ap,
const lapack_complex_float* afp, const lapack_int* ipiv,
const lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* ferr,
float* berr, lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_zsprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* ap,
const lapack_complex_double* afp, const lapack_int* ipiv,
const lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* ferr,
double* berr, lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_chprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* ap,
const lapack_complex_float* afp, const lapack_int* ipiv,
const lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* ferr,
float* berr, lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_zhprfs( char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* ap,
const lapack_complex_double* afp, const lapack_int* ipiv,
const lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* ferr,
double* berr, lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_strrfs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* nrhs, const float* a, lapack_int* lda,
const float* b, lapack_int* ldb, const float* x,
lapack_int* ldx, float* ferr, float* berr, float* work,
lapack_int* iwork, lapack_int *info );
void LAPACK_dtrrfs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* nrhs, const double* a, lapack_int* lda,
const double* b, lapack_int* ldb, const double* x,
lapack_int* ldx, double* ferr, double* berr, double* work,
lapack_int* iwork, lapack_int *info );
void LAPACK_ctrrfs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* nrhs, const lapack_complex_float* a,
lapack_int* lda, const lapack_complex_float* b,
lapack_int* ldb, const lapack_complex_float* x,
lapack_int* ldx, float* ferr, float* berr,
lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_ztrrfs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* nrhs, const lapack_complex_double* a,
lapack_int* lda, const lapack_complex_double* b,
lapack_int* ldb, const lapack_complex_double* x,
lapack_int* ldx, double* ferr, double* berr,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_stprfs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* nrhs, const float* ap, const float* b,
lapack_int* ldb, const float* x, lapack_int* ldx,
float* ferr, float* berr, float* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_dtprfs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* nrhs, const double* ap, const double* b,
lapack_int* ldb, const double* x, lapack_int* ldx,
double* ferr, double* berr, double* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_ctprfs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* nrhs, const lapack_complex_float* ap,
const lapack_complex_float* b, lapack_int* ldb,
const lapack_complex_float* x, lapack_int* ldx, float* ferr,
float* berr, lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_ztprfs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* nrhs, const lapack_complex_double* ap,
const lapack_complex_double* b, lapack_int* ldb,
const lapack_complex_double* x, lapack_int* ldx,
double* ferr, double* berr, lapack_complex_double* work,
double* rwork, lapack_int *info );
void LAPACK_stbrfs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* kd, lapack_int* nrhs, const float* ab,
lapack_int* ldab, const float* b, lapack_int* ldb,
const float* x, lapack_int* ldx, float* ferr, float* berr,
float* work, lapack_int* iwork, lapack_int *info );
void LAPACK_dtbrfs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* kd, lapack_int* nrhs, const double* ab,
lapack_int* ldab, const double* b, lapack_int* ldb,
const double* x, lapack_int* ldx, double* ferr,
double* berr, double* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_ctbrfs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* kd, lapack_int* nrhs,
const lapack_complex_float* ab, lapack_int* ldab,
const lapack_complex_float* b, lapack_int* ldb,
const lapack_complex_float* x, lapack_int* ldx, float* ferr,
float* berr, lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_ztbrfs( char* uplo, char* trans, char* diag, lapack_int* n,
lapack_int* kd, lapack_int* nrhs,
const lapack_complex_double* ab, lapack_int* ldab,
const lapack_complex_double* b, lapack_int* ldb,
const lapack_complex_double* x, lapack_int* ldx,
double* ferr, double* berr, lapack_complex_double* work,
double* rwork, lapack_int *info );
void LAPACK_sgetri( lapack_int* n, float* a, lapack_int* lda,
const lapack_int* ipiv, float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_dgetri( lapack_int* n, double* a, lapack_int* lda,
const lapack_int* ipiv, double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_cgetri( lapack_int* n, lapack_complex_float* a, lapack_int* lda,
const lapack_int* ipiv, lapack_complex_float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_zgetri( lapack_int* n, lapack_complex_double* a, lapack_int* lda,
const lapack_int* ipiv, lapack_complex_double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_spotri( char* uplo, lapack_int* n, float* a, lapack_int* lda,
lapack_int *info );
void LAPACK_dpotri( char* uplo, lapack_int* n, double* a, lapack_int* lda,
lapack_int *info );
void LAPACK_cpotri( char* uplo, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_int *info );
void LAPACK_zpotri( char* uplo, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_int *info );
void LAPACK_dpftri( char* transr, char* uplo, lapack_int* n, double* a,
lapack_int *info );
void LAPACK_spftri( char* transr, char* uplo, lapack_int* n, float* a,
lapack_int *info );
void LAPACK_zpftri( char* transr, char* uplo, lapack_int* n,
lapack_complex_double* a, lapack_int *info );
void LAPACK_cpftri( char* transr, char* uplo, lapack_int* n,
lapack_complex_float* a, lapack_int *info );
void LAPACK_spptri( char* uplo, lapack_int* n, float* ap, lapack_int *info );
void LAPACK_dpptri( char* uplo, lapack_int* n, double* ap, lapack_int *info );
void LAPACK_cpptri( char* uplo, lapack_int* n, lapack_complex_float* ap,
lapack_int *info );
void LAPACK_zpptri( char* uplo, lapack_int* n, lapack_complex_double* ap,
lapack_int *info );
void LAPACK_ssytri( char* uplo, lapack_int* n, float* a, lapack_int* lda,
const lapack_int* ipiv, float* work, lapack_int *info );
void LAPACK_dsytri( char* uplo, lapack_int* n, double* a, lapack_int* lda,
const lapack_int* ipiv, double* work, lapack_int *info );
void LAPACK_csytri( char* uplo, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, const lapack_int* ipiv,
lapack_complex_float* work, lapack_int *info );
void LAPACK_zsytri( char* uplo, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, const lapack_int* ipiv,
lapack_complex_double* work, lapack_int *info );
void LAPACK_chetri( char* uplo, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, const lapack_int* ipiv,
lapack_complex_float* work, lapack_int *info );
void LAPACK_zhetri( char* uplo, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, const lapack_int* ipiv,
lapack_complex_double* work, lapack_int *info );
void LAPACK_ssptri( char* uplo, lapack_int* n, float* ap,
const lapack_int* ipiv, float* work, lapack_int *info );
void LAPACK_dsptri( char* uplo, lapack_int* n, double* ap,
const lapack_int* ipiv, double* work, lapack_int *info );
void LAPACK_csptri( char* uplo, lapack_int* n, lapack_complex_float* ap,
const lapack_int* ipiv, lapack_complex_float* work,
lapack_int *info );
void LAPACK_zsptri( char* uplo, lapack_int* n, lapack_complex_double* ap,
const lapack_int* ipiv, lapack_complex_double* work,
lapack_int *info );
void LAPACK_chptri( char* uplo, lapack_int* n, lapack_complex_float* ap,
const lapack_int* ipiv, lapack_complex_float* work,
lapack_int *info );
void LAPACK_zhptri( char* uplo, lapack_int* n, lapack_complex_double* ap,
const lapack_int* ipiv, lapack_complex_double* work,
lapack_int *info );
void LAPACK_strtri( char* uplo, char* diag, lapack_int* n, float* a,
lapack_int* lda, lapack_int *info );
void LAPACK_dtrtri( char* uplo, char* diag, lapack_int* n, double* a,
lapack_int* lda, lapack_int *info );
void LAPACK_ctrtri( char* uplo, char* diag, lapack_int* n,
lapack_complex_float* a, lapack_int* lda,
lapack_int *info );
void LAPACK_ztrtri( char* uplo, char* diag, lapack_int* n,
lapack_complex_double* a, lapack_int* lda,
lapack_int *info );
void LAPACK_dtftri( char* transr, char* uplo, char* diag, lapack_int* n,
double* a, lapack_int *info );
void LAPACK_stftri( char* transr, char* uplo, char* diag, lapack_int* n,
float* a, lapack_int *info );
void LAPACK_ztftri( char* transr, char* uplo, char* diag, lapack_int* n,
lapack_complex_double* a, lapack_int *info );
void LAPACK_ctftri( char* transr, char* uplo, char* diag, lapack_int* n,
lapack_complex_float* a, lapack_int *info );
void LAPACK_stptri( char* uplo, char* diag, lapack_int* n, float* ap,
lapack_int *info );
void LAPACK_dtptri( char* uplo, char* diag, lapack_int* n, double* ap,
lapack_int *info );
void LAPACK_ctptri( char* uplo, char* diag, lapack_int* n,
lapack_complex_float* ap, lapack_int *info );
void LAPACK_ztptri( char* uplo, char* diag, lapack_int* n,
lapack_complex_double* ap, lapack_int *info );
void LAPACK_sgeequ( lapack_int* m, lapack_int* n, const float* a,
lapack_int* lda, float* r, float* c, float* rowcnd,
float* colcnd, float* amax, lapack_int *info );
void LAPACK_dgeequ( lapack_int* m, lapack_int* n, const double* a,
lapack_int* lda, double* r, double* c, double* rowcnd,
double* colcnd, double* amax, lapack_int *info );
void LAPACK_cgeequ( lapack_int* m, lapack_int* n, const lapack_complex_float* a,
lapack_int* lda, float* r, float* c, float* rowcnd,
float* colcnd, float* amax, lapack_int *info );
void LAPACK_zgeequ( lapack_int* m, lapack_int* n,
const lapack_complex_double* a, lapack_int* lda, double* r,
double* c, double* rowcnd, double* colcnd, double* amax,
lapack_int *info );
void LAPACK_dgeequb( lapack_int* m, lapack_int* n, const double* a,
lapack_int* lda, double* r, double* c, double* rowcnd,
double* colcnd, double* amax, lapack_int *info );
void LAPACK_sgeequb( lapack_int* m, lapack_int* n, const float* a,
lapack_int* lda, float* r, float* c, float* rowcnd,
float* colcnd, float* amax, lapack_int *info );
void LAPACK_zgeequb( lapack_int* m, lapack_int* n,
const lapack_complex_double* a, lapack_int* lda, double* r,
double* c, double* rowcnd, double* colcnd, double* amax,
lapack_int *info );
void LAPACK_cgeequb( lapack_int* m, lapack_int* n,
const lapack_complex_float* a, lapack_int* lda, float* r,
float* c, float* rowcnd, float* colcnd, float* amax,
lapack_int *info );
void LAPACK_sgbequ( lapack_int* m, lapack_int* n, lapack_int* kl,
lapack_int* ku, const float* ab, lapack_int* ldab, float* r,
float* c, float* rowcnd, float* colcnd, float* amax,
lapack_int *info );
void LAPACK_dgbequ( lapack_int* m, lapack_int* n, lapack_int* kl,
lapack_int* ku, const double* ab, lapack_int* ldab,
double* r, double* c, double* rowcnd, double* colcnd,
double* amax, lapack_int *info );
void LAPACK_cgbequ( lapack_int* m, lapack_int* n, lapack_int* kl,
lapack_int* ku, const lapack_complex_float* ab,
lapack_int* ldab, float* r, float* c, float* rowcnd,
float* colcnd, float* amax, lapack_int *info );
void LAPACK_zgbequ( lapack_int* m, lapack_int* n, lapack_int* kl,
lapack_int* ku, const lapack_complex_double* ab,
lapack_int* ldab, double* r, double* c, double* rowcnd,
double* colcnd, double* amax, lapack_int *info );
void LAPACK_dgbequb( lapack_int* m, lapack_int* n, lapack_int* kl,
lapack_int* ku, const double* ab, lapack_int* ldab,
double* r, double* c, double* rowcnd, double* colcnd,
double* amax, lapack_int *info );
void LAPACK_sgbequb( lapack_int* m, lapack_int* n, lapack_int* kl,
lapack_int* ku, const float* ab, lapack_int* ldab,
float* r, float* c, float* rowcnd, float* colcnd,
float* amax, lapack_int *info );
void LAPACK_zgbequb( lapack_int* m, lapack_int* n, lapack_int* kl,
lapack_int* ku, const lapack_complex_double* ab,
lapack_int* ldab, double* r, double* c, double* rowcnd,
double* colcnd, double* amax, lapack_int *info );
void LAPACK_cgbequb( lapack_int* m, lapack_int* n, lapack_int* kl,
lapack_int* ku, const lapack_complex_float* ab,
lapack_int* ldab, float* r, float* c, float* rowcnd,
float* colcnd, float* amax, lapack_int *info );
void LAPACK_spoequ( lapack_int* n, const float* a, lapack_int* lda, float* s,
float* scond, float* amax, lapack_int *info );
void LAPACK_dpoequ( lapack_int* n, const double* a, lapack_int* lda, double* s,
double* scond, double* amax, lapack_int *info );
void LAPACK_cpoequ( lapack_int* n, const lapack_complex_float* a,
lapack_int* lda, float* s, float* scond, float* amax,
lapack_int *info );
void LAPACK_zpoequ( lapack_int* n, const lapack_complex_double* a,
lapack_int* lda, double* s, double* scond, double* amax,
lapack_int *info );
void LAPACK_dpoequb( lapack_int* n, const double* a, lapack_int* lda, double* s,
double* scond, double* amax, lapack_int *info );
void LAPACK_spoequb( lapack_int* n, const float* a, lapack_int* lda, float* s,
float* scond, float* amax, lapack_int *info );
void LAPACK_zpoequb( lapack_int* n, const lapack_complex_double* a,
lapack_int* lda, double* s, double* scond, double* amax,
lapack_int *info );
void LAPACK_cpoequb( lapack_int* n, const lapack_complex_float* a,
lapack_int* lda, float* s, float* scond, float* amax,
lapack_int *info );
void LAPACK_sppequ( char* uplo, lapack_int* n, const float* ap, float* s,
float* scond, float* amax, lapack_int *info );
void LAPACK_dppequ( char* uplo, lapack_int* n, const double* ap, double* s,
double* scond, double* amax, lapack_int *info );
void LAPACK_cppequ( char* uplo, lapack_int* n, const lapack_complex_float* ap,
float* s, float* scond, float* amax, lapack_int *info );
void LAPACK_zppequ( char* uplo, lapack_int* n, const lapack_complex_double* ap,
double* s, double* scond, double* amax, lapack_int *info );
void LAPACK_spbequ( char* uplo, lapack_int* n, lapack_int* kd, const float* ab,
lapack_int* ldab, float* s, float* scond, float* amax,
lapack_int *info );
void LAPACK_dpbequ( char* uplo, lapack_int* n, lapack_int* kd, const double* ab,
lapack_int* ldab, double* s, double* scond, double* amax,
lapack_int *info );
void LAPACK_cpbequ( char* uplo, lapack_int* n, lapack_int* kd,
const lapack_complex_float* ab, lapack_int* ldab, float* s,
float* scond, float* amax, lapack_int *info );
void LAPACK_zpbequ( char* uplo, lapack_int* n, lapack_int* kd,
const lapack_complex_double* ab, lapack_int* ldab,
double* s, double* scond, double* amax, lapack_int *info );
void LAPACK_dsyequb( char* uplo, lapack_int* n, const double* a,
lapack_int* lda, double* s, double* scond, double* amax,
double* work, lapack_int *info );
void LAPACK_ssyequb( char* uplo, lapack_int* n, const float* a, lapack_int* lda,
float* s, float* scond, float* amax, float* work,
lapack_int *info );
void LAPACK_zsyequb( char* uplo, lapack_int* n, const lapack_complex_double* a,
lapack_int* lda, double* s, double* scond, double* amax,
lapack_complex_double* work, lapack_int *info );
void LAPACK_csyequb( char* uplo, lapack_int* n, const lapack_complex_float* a,
lapack_int* lda, float* s, float* scond, float* amax,
lapack_complex_float* work, lapack_int *info );
void LAPACK_zheequb( char* uplo, lapack_int* n, const lapack_complex_double* a,
lapack_int* lda, double* s, double* scond, double* amax,
lapack_complex_double* work, lapack_int *info );
void LAPACK_cheequb( char* uplo, lapack_int* n, const lapack_complex_float* a,
lapack_int* lda, float* s, float* scond, float* amax,
lapack_complex_float* work, lapack_int *info );
void LAPACK_sgesv( lapack_int* n, lapack_int* nrhs, float* a, lapack_int* lda,
lapack_int* ipiv, float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_dgesv( lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda,
lapack_int* ipiv, double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_cgesv( lapack_int* n, lapack_int* nrhs, lapack_complex_float* a,
lapack_int* lda, lapack_int* ipiv, lapack_complex_float* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_zgesv( lapack_int* n, lapack_int* nrhs, lapack_complex_double* a,
lapack_int* lda, lapack_int* ipiv, lapack_complex_double* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_dsgesv( lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda,
lapack_int* ipiv, double* b, lapack_int* ldb, double* x,
lapack_int* ldx, double* work, float* swork,
lapack_int* iter, lapack_int *info );
void LAPACK_zcgesv( lapack_int* n, lapack_int* nrhs, lapack_complex_double* a,
lapack_int* lda, lapack_int* ipiv, lapack_complex_double* b,
lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
lapack_complex_double* work, lapack_complex_float* swork,
double* rwork, lapack_int* iter, lapack_int *info );
void LAPACK_sgesvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
float* a, lapack_int* lda, float* af, lapack_int* ldaf,
lapack_int* ipiv, char* equed, float* r, float* c, float* b,
lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
float* ferr, float* berr, float* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_dgesvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
double* a, lapack_int* lda, double* af, lapack_int* ldaf,
lapack_int* ipiv, char* equed, double* r, double* c,
double* b, lapack_int* ldb, double* x, lapack_int* ldx,
double* rcond, double* ferr, double* berr, double* work,
lapack_int* iwork, lapack_int *info );
void LAPACK_cgesvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* af, lapack_int* ldaf,
lapack_int* ipiv, char* equed, float* r, float* c,
lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* rcond,
float* ferr, float* berr, lapack_complex_float* work,
float* rwork, lapack_int *info );
void LAPACK_zgesvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* af, lapack_int* ldaf,
lapack_int* ipiv, char* equed, double* r, double* c,
lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* rcond,
double* ferr, double* berr, lapack_complex_double* work,
double* rwork, lapack_int *info );
void LAPACK_dgesvxx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
double* a, lapack_int* lda, double* af, lapack_int* ldaf,
lapack_int* ipiv, char* equed, double* r, double* c,
double* b, lapack_int* ldb, double* x, lapack_int* ldx,
double* rcond, double* rpvgrw, double* berr,
lapack_int* n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int* nparams, double* params,
double* work, lapack_int* iwork, lapack_int *info );
void LAPACK_sgesvxx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
float* a, lapack_int* lda, float* af, lapack_int* ldaf,
lapack_int* ipiv, char* equed, float* r, float* c,
float* b, lapack_int* ldb, float* x, lapack_int* ldx,
float* rcond, float* rpvgrw, float* berr,
lapack_int* n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int* nparams, float* params,
float* work, lapack_int* iwork, lapack_int *info );
void LAPACK_zgesvxx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* af, lapack_int* ldaf,
lapack_int* ipiv, char* equed, double* r, double* c,
lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* rcond,
double* rpvgrw, double* berr, lapack_int* n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int* nparams, double* params,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_cgesvxx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* af, lapack_int* ldaf,
lapack_int* ipiv, char* equed, float* r, float* c,
lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* rcond,
float* rpvgrw, float* berr, lapack_int* n_err_bnds,
float* err_bnds_norm, float* err_bnds_comp,
lapack_int* nparams, float* params,
lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_sgbsv( lapack_int* n, lapack_int* kl, lapack_int* ku,
lapack_int* nrhs, float* ab, lapack_int* ldab,
lapack_int* ipiv, float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_dgbsv( lapack_int* n, lapack_int* kl, lapack_int* ku,
lapack_int* nrhs, double* ab, lapack_int* ldab,
lapack_int* ipiv, double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_cgbsv( lapack_int* n, lapack_int* kl, lapack_int* ku,
lapack_int* nrhs, lapack_complex_float* ab, lapack_int* ldab,
lapack_int* ipiv, lapack_complex_float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_zgbsv( lapack_int* n, lapack_int* kl, lapack_int* ku,
lapack_int* nrhs, lapack_complex_double* ab,
lapack_int* ldab, lapack_int* ipiv, lapack_complex_double* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_sgbsvx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
lapack_int* ku, lapack_int* nrhs, float* ab,
lapack_int* ldab, float* afb, lapack_int* ldafb,
lapack_int* ipiv, char* equed, float* r, float* c, float* b,
lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
float* ferr, float* berr, float* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_dgbsvx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
lapack_int* ku, lapack_int* nrhs, double* ab,
lapack_int* ldab, double* afb, lapack_int* ldafb,
lapack_int* ipiv, char* equed, double* r, double* c,
double* b, lapack_int* ldb, double* x, lapack_int* ldx,
double* rcond, double* ferr, double* berr, double* work,
lapack_int* iwork, lapack_int *info );
void LAPACK_cgbsvx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
lapack_int* ku, lapack_int* nrhs, lapack_complex_float* ab,
lapack_int* ldab, lapack_complex_float* afb,
lapack_int* ldafb, lapack_int* ipiv, char* equed, float* r,
float* c, lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* rcond,
float* ferr, float* berr, lapack_complex_float* work,
float* rwork, lapack_int *info );
void LAPACK_zgbsvx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
lapack_int* ku, lapack_int* nrhs, lapack_complex_double* ab,
lapack_int* ldab, lapack_complex_double* afb,
lapack_int* ldafb, lapack_int* ipiv, char* equed, double* r,
double* c, lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* rcond,
double* ferr, double* berr, lapack_complex_double* work,
double* rwork, lapack_int *info );
void LAPACK_dgbsvxx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
lapack_int* ku, lapack_int* nrhs, double* ab,
lapack_int* ldab, double* afb, lapack_int* ldafb,
lapack_int* ipiv, char* equed, double* r, double* c,
double* b, lapack_int* ldb, double* x, lapack_int* ldx,
double* rcond, double* rpvgrw, double* berr,
lapack_int* n_err_bnds, double* err_bnds_norm,
double* err_bnds_comp, lapack_int* nparams, double* params,
double* work, lapack_int* iwork, lapack_int *info );
void LAPACK_sgbsvxx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
lapack_int* ku, lapack_int* nrhs, float* ab,
lapack_int* ldab, float* afb, lapack_int* ldafb,
lapack_int* ipiv, char* equed, float* r, float* c,
float* b, lapack_int* ldb, float* x, lapack_int* ldx,
float* rcond, float* rpvgrw, float* berr,
lapack_int* n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int* nparams, float* params,
float* work, lapack_int* iwork, lapack_int *info );
void LAPACK_zgbsvxx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
lapack_int* ku, lapack_int* nrhs,
lapack_complex_double* ab, lapack_int* ldab,
lapack_complex_double* afb, lapack_int* ldafb,
lapack_int* ipiv, char* equed, double* r, double* c,
lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* rcond,
double* rpvgrw, double* berr, lapack_int* n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int* nparams, double* params,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_cgbsvxx( char* fact, char* trans, lapack_int* n, lapack_int* kl,
lapack_int* ku, lapack_int* nrhs, lapack_complex_float* ab,
lapack_int* ldab, lapack_complex_float* afb,
lapack_int* ldafb, lapack_int* ipiv, char* equed, float* r,
float* c, lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* rcond,
float* rpvgrw, float* berr, lapack_int* n_err_bnds,
float* err_bnds_norm, float* err_bnds_comp,
lapack_int* nparams, float* params,
lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_sgtsv( lapack_int* n, lapack_int* nrhs, float* dl, float* d,
float* du, float* b, lapack_int* ldb, lapack_int *info );
void LAPACK_dgtsv( lapack_int* n, lapack_int* nrhs, double* dl, double* d,
double* du, double* b, lapack_int* ldb, lapack_int *info );
void LAPACK_cgtsv( lapack_int* n, lapack_int* nrhs, lapack_complex_float* dl,
lapack_complex_float* d, lapack_complex_float* du,
lapack_complex_float* b, lapack_int* ldb, lapack_int *info );
void LAPACK_zgtsv( lapack_int* n, lapack_int* nrhs, lapack_complex_double* dl,
lapack_complex_double* d, lapack_complex_double* du,
lapack_complex_double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_sgtsvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
const float* dl, const float* d, const float* du,
float* dlf, float* df, float* duf, float* du2,
lapack_int* ipiv, const float* b, lapack_int* ldb, float* x,
lapack_int* ldx, float* rcond, float* ferr, float* berr,
float* work, lapack_int* iwork, lapack_int *info );
void LAPACK_dgtsvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
const double* dl, const double* d, const double* du,
double* dlf, double* df, double* duf, double* du2,
lapack_int* ipiv, const double* b, lapack_int* ldb,
double* x, lapack_int* ldx, double* rcond, double* ferr,
double* berr, double* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_cgtsvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* dl,
const lapack_complex_float* d,
const lapack_complex_float* du, lapack_complex_float* dlf,
lapack_complex_float* df, lapack_complex_float* duf,
lapack_complex_float* du2, lapack_int* ipiv,
const lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* rcond,
float* ferr, float* berr, lapack_complex_float* work,
float* rwork, lapack_int *info );
void LAPACK_zgtsvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* dl,
const lapack_complex_double* d,
const lapack_complex_double* du, lapack_complex_double* dlf,
lapack_complex_double* df, lapack_complex_double* duf,
lapack_complex_double* du2, lapack_int* ipiv,
const lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* rcond,
double* ferr, double* berr, lapack_complex_double* work,
double* rwork, lapack_int *info );
void LAPACK_sposv( char* uplo, lapack_int* n, lapack_int* nrhs, float* a,
lapack_int* lda, float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_dposv( char* uplo, lapack_int* n, lapack_int* nrhs, double* a,
lapack_int* lda, double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_cposv( char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb, lapack_int *info );
void LAPACK_zposv( char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_dsposv( char* uplo, lapack_int* n, lapack_int* nrhs, double* a,
lapack_int* lda, double* b, lapack_int* ldb, double* x,
lapack_int* ldx, double* work, float* swork,
lapack_int* iter, lapack_int *info );
void LAPACK_zcposv( char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx,
lapack_complex_double* work, lapack_complex_float* swork,
double* rwork, lapack_int* iter, lapack_int *info );
void LAPACK_sposvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
float* a, lapack_int* lda, float* af, lapack_int* ldaf,
char* equed, float* s, float* b, lapack_int* ldb, float* x,
lapack_int* ldx, float* rcond, float* ferr, float* berr,
float* work, lapack_int* iwork, lapack_int *info );
void LAPACK_dposvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
double* a, lapack_int* lda, double* af, lapack_int* ldaf,
char* equed, double* s, double* b, lapack_int* ldb,
double* x, lapack_int* ldx, double* rcond, double* ferr,
double* berr, double* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_cposvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* af, lapack_int* ldaf, char* equed,
float* s, lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* rcond,
float* ferr, float* berr, lapack_complex_float* work,
float* rwork, lapack_int *info );
void LAPACK_zposvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* af, lapack_int* ldaf, char* equed,
double* s, lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* rcond,
double* ferr, double* berr, lapack_complex_double* work,
double* rwork, lapack_int *info );
void LAPACK_dposvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
double* a, lapack_int* lda, double* af, lapack_int* ldaf,
char* equed, double* s, double* b, lapack_int* ldb,
double* x, lapack_int* ldx, double* rcond, double* rpvgrw,
double* berr, lapack_int* n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int* nparams, double* params, double* work,
lapack_int* iwork, lapack_int *info );
void LAPACK_sposvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
float* a, lapack_int* lda, float* af, lapack_int* ldaf,
char* equed, float* s, float* b, lapack_int* ldb, float* x,
lapack_int* ldx, float* rcond, float* rpvgrw, float* berr,
lapack_int* n_err_bnds, float* err_bnds_norm,
float* err_bnds_comp, lapack_int* nparams, float* params,
float* work, lapack_int* iwork, lapack_int *info );
void LAPACK_zposvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* af, lapack_int* ldaf, char* equed,
double* s, lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* rcond,
double* rpvgrw, double* berr, lapack_int* n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int* nparams, double* params,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_cposvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* af, lapack_int* ldaf, char* equed,
float* s, lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* rcond,
float* rpvgrw, float* berr, lapack_int* n_err_bnds,
float* err_bnds_norm, float* err_bnds_comp,
lapack_int* nparams, float* params,
lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_sppsv( char* uplo, lapack_int* n, lapack_int* nrhs, float* ap,
float* b, lapack_int* ldb, lapack_int *info );
void LAPACK_dppsv( char* uplo, lapack_int* n, lapack_int* nrhs, double* ap,
double* b, lapack_int* ldb, lapack_int *info );
void LAPACK_cppsv( char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_float* ap, lapack_complex_float* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_zppsv( char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_double* ap, lapack_complex_double* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_sppsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
float* ap, float* afp, char* equed, float* s, float* b,
lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
float* ferr, float* berr, float* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_dppsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
double* ap, double* afp, char* equed, double* s, double* b,
lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
double* ferr, double* berr, double* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_cppsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_float* ap, lapack_complex_float* afp,
char* equed, float* s, lapack_complex_float* b,
lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
float* rcond, float* ferr, float* berr,
lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_zppsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_double* ap, lapack_complex_double* afp,
char* equed, double* s, lapack_complex_double* b,
lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
double* rcond, double* ferr, double* berr,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_spbsv( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
float* ab, lapack_int* ldab, float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_dpbsv( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
double* ab, lapack_int* ldab, double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_cpbsv( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
lapack_complex_float* ab, lapack_int* ldab,
lapack_complex_float* b, lapack_int* ldb, lapack_int *info );
void LAPACK_zpbsv( char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
lapack_complex_double* ab, lapack_int* ldab,
lapack_complex_double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_spbsvx( char* fact, char* uplo, lapack_int* n, lapack_int* kd,
lapack_int* nrhs, float* ab, lapack_int* ldab, float* afb,
lapack_int* ldafb, char* equed, float* s, float* b,
lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
float* ferr, float* berr, float* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_dpbsvx( char* fact, char* uplo, lapack_int* n, lapack_int* kd,
lapack_int* nrhs, double* ab, lapack_int* ldab, double* afb,
lapack_int* ldafb, char* equed, double* s, double* b,
lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
double* ferr, double* berr, double* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_cpbsvx( char* fact, char* uplo, lapack_int* n, lapack_int* kd,
lapack_int* nrhs, lapack_complex_float* ab,
lapack_int* ldab, lapack_complex_float* afb,
lapack_int* ldafb, char* equed, float* s,
lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* rcond,
float* ferr, float* berr, lapack_complex_float* work,
float* rwork, lapack_int *info );
void LAPACK_zpbsvx( char* fact, char* uplo, lapack_int* n, lapack_int* kd,
lapack_int* nrhs, lapack_complex_double* ab,
lapack_int* ldab, lapack_complex_double* afb,
lapack_int* ldafb, char* equed, double* s,
lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* rcond,
double* ferr, double* berr, lapack_complex_double* work,
double* rwork, lapack_int *info );
void LAPACK_sptsv( lapack_int* n, lapack_int* nrhs, float* d, float* e,
float* b, lapack_int* ldb, lapack_int *info );
void LAPACK_dptsv( lapack_int* n, lapack_int* nrhs, double* d, double* e,
double* b, lapack_int* ldb, lapack_int *info );
void LAPACK_cptsv( lapack_int* n, lapack_int* nrhs, float* d,
lapack_complex_float* e, lapack_complex_float* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_zptsv( lapack_int* n, lapack_int* nrhs, double* d,
lapack_complex_double* e, lapack_complex_double* b,
lapack_int* ldb, lapack_int *info );
void LAPACK_sptsvx( char* fact, lapack_int* n, lapack_int* nrhs, const float* d,
const float* e, float* df, float* ef, const float* b,
lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
float* ferr, float* berr, float* work, lapack_int *info );
void LAPACK_dptsvx( char* fact, lapack_int* n, lapack_int* nrhs,
const double* d, const double* e, double* df, double* ef,
const double* b, lapack_int* ldb, double* x,
lapack_int* ldx, double* rcond, double* ferr, double* berr,
double* work, lapack_int *info );
void LAPACK_cptsvx( char* fact, lapack_int* n, lapack_int* nrhs, const float* d,
const lapack_complex_float* e, float* df,
lapack_complex_float* ef, const lapack_complex_float* b,
lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
float* rcond, float* ferr, float* berr,
lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_zptsvx( char* fact, lapack_int* n, lapack_int* nrhs,
const double* d, const lapack_complex_double* e, double* df,
lapack_complex_double* ef, const lapack_complex_double* b,
lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
double* rcond, double* ferr, double* berr,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_ssysv( char* uplo, lapack_int* n, lapack_int* nrhs, float* a,
lapack_int* lda, lapack_int* ipiv, float* b, lapack_int* ldb,
float* work, lapack_int* lwork, lapack_int *info );
void LAPACK_dsysv( char* uplo, lapack_int* n, lapack_int* nrhs, double* a,
lapack_int* lda, lapack_int* ipiv, double* b,
lapack_int* ldb, double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_csysv( char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_float* a, lapack_int* lda, lapack_int* ipiv,
lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_zsysv( char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_double* a, lapack_int* lda, lapack_int* ipiv,
lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_ssysvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
const float* a, lapack_int* lda, float* af,
lapack_int* ldaf, lapack_int* ipiv, const float* b,
lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
float* ferr, float* berr, float* work, lapack_int* lwork,
lapack_int* iwork, lapack_int *info );
void LAPACK_dsysvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
const double* a, lapack_int* lda, double* af,
lapack_int* ldaf, lapack_int* ipiv, const double* b,
lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
double* ferr, double* berr, double* work, lapack_int* lwork,
lapack_int* iwork, lapack_int *info );
void LAPACK_csysvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* af, lapack_int* ldaf,
lapack_int* ipiv, const lapack_complex_float* b,
lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
float* rcond, float* ferr, float* berr,
lapack_complex_float* work, lapack_int* lwork, float* rwork,
lapack_int *info );
void LAPACK_zsysvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* af, lapack_int* ldaf,
lapack_int* ipiv, const lapack_complex_double* b,
lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
double* rcond, double* ferr, double* berr,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_int *info );
void LAPACK_dsysvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
double* a, lapack_int* lda, double* af, lapack_int* ldaf,
lapack_int* ipiv, char* equed, double* s, double* b,
lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
double* rpvgrw, double* berr, lapack_int* n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int* nparams, double* params, double* work,
lapack_int* iwork, lapack_int *info );
void LAPACK_ssysvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
float* a, lapack_int* lda, float* af, lapack_int* ldaf,
lapack_int* ipiv, char* equed, float* s, float* b,
lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
float* rpvgrw, float* berr, lapack_int* n_err_bnds,
float* err_bnds_norm, float* err_bnds_comp,
lapack_int* nparams, float* params, float* work,
lapack_int* iwork, lapack_int *info );
void LAPACK_zsysvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* af, lapack_int* ldaf,
lapack_int* ipiv, char* equed, double* s,
lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* rcond,
double* rpvgrw, double* berr, lapack_int* n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int* nparams, double* params,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_csysvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* af, lapack_int* ldaf,
lapack_int* ipiv, char* equed, float* s,
lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* rcond,
float* rpvgrw, float* berr, lapack_int* n_err_bnds,
float* err_bnds_norm, float* err_bnds_comp,
lapack_int* nparams, float* params,
lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_chesv( char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_float* a, lapack_int* lda, lapack_int* ipiv,
lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_zhesv( char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_double* a, lapack_int* lda, lapack_int* ipiv,
lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_chesvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* af, lapack_int* ldaf,
lapack_int* ipiv, const lapack_complex_float* b,
lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
float* rcond, float* ferr, float* berr,
lapack_complex_float* work, lapack_int* lwork, float* rwork,
lapack_int *info );
void LAPACK_zhesvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* af, lapack_int* ldaf,
lapack_int* ipiv, const lapack_complex_double* b,
lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
double* rcond, double* ferr, double* berr,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_int *info );
void LAPACK_zhesvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* af, lapack_int* ldaf,
lapack_int* ipiv, char* equed, double* s,
lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* x, lapack_int* ldx, double* rcond,
double* rpvgrw, double* berr, lapack_int* n_err_bnds,
double* err_bnds_norm, double* err_bnds_comp,
lapack_int* nparams, double* params,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_chesvxx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* af, lapack_int* ldaf,
lapack_int* ipiv, char* equed, float* s,
lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* x, lapack_int* ldx, float* rcond,
float* rpvgrw, float* berr, lapack_int* n_err_bnds,
float* err_bnds_norm, float* err_bnds_comp,
lapack_int* nparams, float* params,
lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_sspsv( char* uplo, lapack_int* n, lapack_int* nrhs, float* ap,
lapack_int* ipiv, float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_dspsv( char* uplo, lapack_int* n, lapack_int* nrhs, double* ap,
lapack_int* ipiv, double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_cspsv( char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_float* ap, lapack_int* ipiv,
lapack_complex_float* b, lapack_int* ldb, lapack_int *info );
void LAPACK_zspsv( char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_double* ap, lapack_int* ipiv,
lapack_complex_double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_sspsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
const float* ap, float* afp, lapack_int* ipiv,
const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
float* rcond, float* ferr, float* berr, float* work,
lapack_int* iwork, lapack_int *info );
void LAPACK_dspsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
const double* ap, double* afp, lapack_int* ipiv,
const double* b, lapack_int* ldb, double* x,
lapack_int* ldx, double* rcond, double* ferr, double* berr,
double* work, lapack_int* iwork, lapack_int *info );
void LAPACK_cspsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* ap, lapack_complex_float* afp,
lapack_int* ipiv, const lapack_complex_float* b,
lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
float* rcond, float* ferr, float* berr,
lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_zspsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* ap, lapack_complex_double* afp,
lapack_int* ipiv, const lapack_complex_double* b,
lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
double* rcond, double* ferr, double* berr,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_chpsv( char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_float* ap, lapack_int* ipiv,
lapack_complex_float* b, lapack_int* ldb, lapack_int *info );
void LAPACK_zhpsv( char* uplo, lapack_int* n, lapack_int* nrhs,
lapack_complex_double* ap, lapack_int* ipiv,
lapack_complex_double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_chpsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_float* ap, lapack_complex_float* afp,
lapack_int* ipiv, const lapack_complex_float* b,
lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
float* rcond, float* ferr, float* berr,
lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_zhpsvx( char* fact, char* uplo, lapack_int* n, lapack_int* nrhs,
const lapack_complex_double* ap, lapack_complex_double* afp,
lapack_int* ipiv, const lapack_complex_double* b,
lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
double* rcond, double* ferr, double* berr,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_sgeqrf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
float* tau, float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_dgeqrf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
double* tau, double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_cgeqrf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_complex_float* tau,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_zgeqrf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_complex_double* tau,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_sgeqpf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
lapack_int* jpvt, float* tau, float* work,
lapack_int *info );
void LAPACK_dgeqpf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
lapack_int* jpvt, double* tau, double* work,
lapack_int *info );
void LAPACK_cgeqpf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_int* jpvt,
lapack_complex_float* tau, lapack_complex_float* work,
float* rwork, lapack_int *info );
void LAPACK_zgeqpf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_int* jpvt,
lapack_complex_double* tau, lapack_complex_double* work,
double* rwork, lapack_int *info );
void LAPACK_sgeqp3( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
lapack_int* jpvt, float* tau, float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_dgeqp3( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
lapack_int* jpvt, double* tau, double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_cgeqp3( lapack_int* m, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_int* jpvt,
lapack_complex_float* tau, lapack_complex_float* work,
lapack_int* lwork, float* rwork, lapack_int *info );
void LAPACK_zgeqp3( lapack_int* m, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_int* jpvt,
lapack_complex_double* tau, lapack_complex_double* work,
lapack_int* lwork, double* rwork, lapack_int *info );
void LAPACK_sorgqr( lapack_int* m, lapack_int* n, lapack_int* k, float* a,
lapack_int* lda, const float* tau, float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_dorgqr( lapack_int* m, lapack_int* n, lapack_int* k, double* a,
lapack_int* lda, const double* tau, double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_sormqr( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, const float* a, lapack_int* lda,
const float* tau, float* c, lapack_int* ldc, float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_dormqr( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, const double* a, lapack_int* lda,
const double* tau, double* c, lapack_int* ldc, double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_cungqr( lapack_int* m, lapack_int* n, lapack_int* k,
lapack_complex_float* a, lapack_int* lda,
const lapack_complex_float* tau, lapack_complex_float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_zungqr( lapack_int* m, lapack_int* n, lapack_int* k,
lapack_complex_double* a, lapack_int* lda,
const lapack_complex_double* tau,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_cunmqr( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, const lapack_complex_float* a,
lapack_int* lda, const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int* ldc,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_zunmqr( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, const lapack_complex_double* a,
lapack_int* lda, const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int* ldc,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_sgelqf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
float* tau, float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_dgelqf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
double* tau, double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_cgelqf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_complex_float* tau,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_zgelqf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_complex_double* tau,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_sorglq( lapack_int* m, lapack_int* n, lapack_int* k, float* a,
lapack_int* lda, const float* tau, float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_dorglq( lapack_int* m, lapack_int* n, lapack_int* k, double* a,
lapack_int* lda, const double* tau, double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_sormlq( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, const float* a, lapack_int* lda,
const float* tau, float* c, lapack_int* ldc, float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_dormlq( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, const double* a, lapack_int* lda,
const double* tau, double* c, lapack_int* ldc, double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_cunglq( lapack_int* m, lapack_int* n, lapack_int* k,
lapack_complex_float* a, lapack_int* lda,
const lapack_complex_float* tau, lapack_complex_float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_zunglq( lapack_int* m, lapack_int* n, lapack_int* k,
lapack_complex_double* a, lapack_int* lda,
const lapack_complex_double* tau,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_cunmlq( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, const lapack_complex_float* a,
lapack_int* lda, const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int* ldc,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_zunmlq( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, const lapack_complex_double* a,
lapack_int* lda, const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int* ldc,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_sgeqlf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
float* tau, float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_dgeqlf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
double* tau, double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_cgeqlf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_complex_float* tau,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_zgeqlf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_complex_double* tau,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_sorgql( lapack_int* m, lapack_int* n, lapack_int* k, float* a,
lapack_int* lda, const float* tau, float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_dorgql( lapack_int* m, lapack_int* n, lapack_int* k, double* a,
lapack_int* lda, const double* tau, double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_cungql( lapack_int* m, lapack_int* n, lapack_int* k,
lapack_complex_float* a, lapack_int* lda,
const lapack_complex_float* tau, lapack_complex_float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_zungql( lapack_int* m, lapack_int* n, lapack_int* k,
lapack_complex_double* a, lapack_int* lda,
const lapack_complex_double* tau,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_sormql( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, const float* a, lapack_int* lda,
const float* tau, float* c, lapack_int* ldc, float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_dormql( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, const double* a, lapack_int* lda,
const double* tau, double* c, lapack_int* ldc, double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_cunmql( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, const lapack_complex_float* a,
lapack_int* lda, const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int* ldc,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_zunmql( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, const lapack_complex_double* a,
lapack_int* lda, const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int* ldc,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_sgerqf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
float* tau, float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_dgerqf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
double* tau, double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_cgerqf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_complex_float* tau,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_zgerqf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_complex_double* tau,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_sorgrq( lapack_int* m, lapack_int* n, lapack_int* k, float* a,
lapack_int* lda, const float* tau, float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_dorgrq( lapack_int* m, lapack_int* n, lapack_int* k, double* a,
lapack_int* lda, const double* tau, double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_cungrq( lapack_int* m, lapack_int* n, lapack_int* k,
lapack_complex_float* a, lapack_int* lda,
const lapack_complex_float* tau, lapack_complex_float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_zungrq( lapack_int* m, lapack_int* n, lapack_int* k,
lapack_complex_double* a, lapack_int* lda,
const lapack_complex_double* tau,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_sormrq( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, const float* a, lapack_int* lda,
const float* tau, float* c, lapack_int* ldc, float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_dormrq( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, const double* a, lapack_int* lda,
const double* tau, double* c, lapack_int* ldc, double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_cunmrq( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, const lapack_complex_float* a,
lapack_int* lda, const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int* ldc,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_zunmrq( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, const lapack_complex_double* a,
lapack_int* lda, const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int* ldc,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_stzrzf( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
float* tau, float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_dtzrzf( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
double* tau, double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_ctzrzf( lapack_int* m, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_complex_float* tau,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_ztzrzf( lapack_int* m, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_complex_double* tau,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_sormrz( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, lapack_int* l, const float* a,
lapack_int* lda, const float* tau, float* c,
lapack_int* ldc, float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_dormrz( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, lapack_int* l, const double* a,
lapack_int* lda, const double* tau, double* c,
lapack_int* ldc, double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_cunmrz( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, lapack_int* l, const lapack_complex_float* a,
lapack_int* lda, const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int* ldc,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_zunmrz( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, lapack_int* l,
const lapack_complex_double* a, lapack_int* lda,
const lapack_complex_double* tau, lapack_complex_double* c,
lapack_int* ldc, lapack_complex_double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_sggqrf( lapack_int* n, lapack_int* m, lapack_int* p, float* a,
lapack_int* lda, float* taua, float* b, lapack_int* ldb,
float* taub, float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_dggqrf( lapack_int* n, lapack_int* m, lapack_int* p, double* a,
lapack_int* lda, double* taua, double* b, lapack_int* ldb,
double* taub, double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_cggqrf( lapack_int* n, lapack_int* m, lapack_int* p,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* taua, lapack_complex_float* b,
lapack_int* ldb, lapack_complex_float* taub,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_zggqrf( lapack_int* n, lapack_int* m, lapack_int* p,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* taua, lapack_complex_double* b,
lapack_int* ldb, lapack_complex_double* taub,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_sggrqf( lapack_int* m, lapack_int* p, lapack_int* n, float* a,
lapack_int* lda, float* taua, float* b, lapack_int* ldb,
float* taub, float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_dggrqf( lapack_int* m, lapack_int* p, lapack_int* n, double* a,
lapack_int* lda, double* taua, double* b, lapack_int* ldb,
double* taub, double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_cggrqf( lapack_int* m, lapack_int* p, lapack_int* n,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* taua, lapack_complex_float* b,
lapack_int* ldb, lapack_complex_float* taub,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_zggrqf( lapack_int* m, lapack_int* p, lapack_int* n,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* taua, lapack_complex_double* b,
lapack_int* ldb, lapack_complex_double* taub,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_sgebrd( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
float* d, float* e, float* tauq, float* taup, float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_dgebrd( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
double* d, double* e, double* tauq, double* taup,
double* work, lapack_int* lwork, lapack_int *info );
void LAPACK_cgebrd( lapack_int* m, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, float* d, float* e,
lapack_complex_float* tauq, lapack_complex_float* taup,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_zgebrd( lapack_int* m, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, double* d, double* e,
lapack_complex_double* tauq, lapack_complex_double* taup,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_sgbbrd( char* vect, lapack_int* m, lapack_int* n, lapack_int* ncc,
lapack_int* kl, lapack_int* ku, float* ab, lapack_int* ldab,
float* d, float* e, float* q, lapack_int* ldq, float* pt,
lapack_int* ldpt, float* c, lapack_int* ldc, float* work,
lapack_int *info );
void LAPACK_dgbbrd( char* vect, lapack_int* m, lapack_int* n, lapack_int* ncc,
lapack_int* kl, lapack_int* ku, double* ab,
lapack_int* ldab, double* d, double* e, double* q,
lapack_int* ldq, double* pt, lapack_int* ldpt, double* c,
lapack_int* ldc, double* work, lapack_int *info );
void LAPACK_cgbbrd( char* vect, lapack_int* m, lapack_int* n, lapack_int* ncc,
lapack_int* kl, lapack_int* ku, lapack_complex_float* ab,
lapack_int* ldab, float* d, float* e,
lapack_complex_float* q, lapack_int* ldq,
lapack_complex_float* pt, lapack_int* ldpt,
lapack_complex_float* c, lapack_int* ldc,
lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_zgbbrd( char* vect, lapack_int* m, lapack_int* n, lapack_int* ncc,
lapack_int* kl, lapack_int* ku, lapack_complex_double* ab,
lapack_int* ldab, double* d, double* e,
lapack_complex_double* q, lapack_int* ldq,
lapack_complex_double* pt, lapack_int* ldpt,
lapack_complex_double* c, lapack_int* ldc,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_sorgbr( char* vect, lapack_int* m, lapack_int* n, lapack_int* k,
float* a, lapack_int* lda, const float* tau, float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_dorgbr( char* vect, lapack_int* m, lapack_int* n, lapack_int* k,
double* a, lapack_int* lda, const double* tau, double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_sormbr( char* vect, char* side, char* trans, lapack_int* m,
lapack_int* n, lapack_int* k, const float* a,
lapack_int* lda, const float* tau, float* c,
lapack_int* ldc, float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_dormbr( char* vect, char* side, char* trans, lapack_int* m,
lapack_int* n, lapack_int* k, const double* a,
lapack_int* lda, const double* tau, double* c,
lapack_int* ldc, double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_cungbr( char* vect, lapack_int* m, lapack_int* n, lapack_int* k,
lapack_complex_float* a, lapack_int* lda,
const lapack_complex_float* tau, lapack_complex_float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_zungbr( char* vect, lapack_int* m, lapack_int* n, lapack_int* k,
lapack_complex_double* a, lapack_int* lda,
const lapack_complex_double* tau,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_cunmbr( char* vect, char* side, char* trans, lapack_int* m,
lapack_int* n, lapack_int* k, const lapack_complex_float* a,
lapack_int* lda, const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int* ldc,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_zunmbr( char* vect, char* side, char* trans, lapack_int* m,
lapack_int* n, lapack_int* k,
const lapack_complex_double* a, lapack_int* lda,
const lapack_complex_double* tau, lapack_complex_double* c,
lapack_int* ldc, lapack_complex_double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_sbdsqr( char* uplo, lapack_int* n, lapack_int* ncvt,
lapack_int* nru, lapack_int* ncc, float* d, float* e,
float* vt, lapack_int* ldvt, float* u, lapack_int* ldu,
float* c, lapack_int* ldc, float* work, lapack_int *info );
void LAPACK_dbdsqr( char* uplo, lapack_int* n, lapack_int* ncvt,
lapack_int* nru, lapack_int* ncc, double* d, double* e,
double* vt, lapack_int* ldvt, double* u, lapack_int* ldu,
double* c, lapack_int* ldc, double* work,
lapack_int *info );
void LAPACK_cbdsqr( char* uplo, lapack_int* n, lapack_int* ncvt,
lapack_int* nru, lapack_int* ncc, float* d, float* e,
lapack_complex_float* vt, lapack_int* ldvt,
lapack_complex_float* u, lapack_int* ldu,
lapack_complex_float* c, lapack_int* ldc, float* work,
lapack_int *info );
void LAPACK_zbdsqr( char* uplo, lapack_int* n, lapack_int* ncvt,
lapack_int* nru, lapack_int* ncc, double* d, double* e,
lapack_complex_double* vt, lapack_int* ldvt,
lapack_complex_double* u, lapack_int* ldu,
lapack_complex_double* c, lapack_int* ldc, double* work,
lapack_int *info );
void LAPACK_sbdsdc( char* uplo, char* compq, lapack_int* n, float* d, float* e,
float* u, lapack_int* ldu, float* vt, lapack_int* ldvt,
float* q, lapack_int* iq, float* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_dbdsdc( char* uplo, char* compq, lapack_int* n, double* d,
double* e, double* u, lapack_int* ldu, double* vt,
lapack_int* ldvt, double* q, lapack_int* iq, double* work,
lapack_int* iwork, lapack_int *info );
void LAPACK_ssytrd( char* uplo, lapack_int* n, float* a, lapack_int* lda,
float* d, float* e, float* tau, float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_dsytrd( char* uplo, lapack_int* n, double* a, lapack_int* lda,
double* d, double* e, double* tau, double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_sorgtr( char* uplo, lapack_int* n, float* a, lapack_int* lda,
const float* tau, float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_dorgtr( char* uplo, lapack_int* n, double* a, lapack_int* lda,
const double* tau, double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_sormtr( char* side, char* uplo, char* trans, lapack_int* m,
lapack_int* n, const float* a, lapack_int* lda,
const float* tau, float* c, lapack_int* ldc, float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_dormtr( char* side, char* uplo, char* trans, lapack_int* m,
lapack_int* n, const double* a, lapack_int* lda,
const double* tau, double* c, lapack_int* ldc, double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_chetrd( char* uplo, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, float* d, float* e,
lapack_complex_float* tau, lapack_complex_float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_zhetrd( char* uplo, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, double* d, double* e,
lapack_complex_double* tau, lapack_complex_double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_cungtr( char* uplo, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, const lapack_complex_float* tau,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_zungtr( char* uplo, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, const lapack_complex_double* tau,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_cunmtr( char* side, char* uplo, char* trans, lapack_int* m,
lapack_int* n, const lapack_complex_float* a,
lapack_int* lda, const lapack_complex_float* tau,
lapack_complex_float* c, lapack_int* ldc,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_zunmtr( char* side, char* uplo, char* trans, lapack_int* m,
lapack_int* n, const lapack_complex_double* a,
lapack_int* lda, const lapack_complex_double* tau,
lapack_complex_double* c, lapack_int* ldc,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_ssptrd( char* uplo, lapack_int* n, float* ap, float* d, float* e,
float* tau, lapack_int *info );
void LAPACK_dsptrd( char* uplo, lapack_int* n, double* ap, double* d, double* e,
double* tau, lapack_int *info );
void LAPACK_sopgtr( char* uplo, lapack_int* n, const float* ap,
const float* tau, float* q, lapack_int* ldq, float* work,
lapack_int *info );
void LAPACK_dopgtr( char* uplo, lapack_int* n, const double* ap,
const double* tau, double* q, lapack_int* ldq, double* work,
lapack_int *info );
void LAPACK_sopmtr( char* side, char* uplo, char* trans, lapack_int* m,
lapack_int* n, const float* ap, const float* tau, float* c,
lapack_int* ldc, float* work, lapack_int *info );
void LAPACK_dopmtr( char* side, char* uplo, char* trans, lapack_int* m,
lapack_int* n, const double* ap, const double* tau,
double* c, lapack_int* ldc, double* work,
lapack_int *info );
void LAPACK_chptrd( char* uplo, lapack_int* n, lapack_complex_float* ap,
float* d, float* e, lapack_complex_float* tau,
lapack_int *info );
void LAPACK_zhptrd( char* uplo, lapack_int* n, lapack_complex_double* ap,
double* d, double* e, lapack_complex_double* tau,
lapack_int *info );
void LAPACK_cupgtr( char* uplo, lapack_int* n, const lapack_complex_float* ap,
const lapack_complex_float* tau, lapack_complex_float* q,
lapack_int* ldq, lapack_complex_float* work,
lapack_int *info );
void LAPACK_zupgtr( char* uplo, lapack_int* n, const lapack_complex_double* ap,
const lapack_complex_double* tau, lapack_complex_double* q,
lapack_int* ldq, lapack_complex_double* work,
lapack_int *info );
void LAPACK_cupmtr( char* side, char* uplo, char* trans, lapack_int* m,
lapack_int* n, const lapack_complex_float* ap,
const lapack_complex_float* tau, lapack_complex_float* c,
lapack_int* ldc, lapack_complex_float* work,
lapack_int *info );
void LAPACK_zupmtr( char* side, char* uplo, char* trans, lapack_int* m,
lapack_int* n, const lapack_complex_double* ap,
const lapack_complex_double* tau, lapack_complex_double* c,
lapack_int* ldc, lapack_complex_double* work,
lapack_int *info );
void LAPACK_ssbtrd( char* vect, char* uplo, lapack_int* n, lapack_int* kd,
float* ab, lapack_int* ldab, float* d, float* e, float* q,
lapack_int* ldq, float* work, lapack_int *info );
void LAPACK_dsbtrd( char* vect, char* uplo, lapack_int* n, lapack_int* kd,
double* ab, lapack_int* ldab, double* d, double* e,
double* q, lapack_int* ldq, double* work,
lapack_int *info );
void LAPACK_chbtrd( char* vect, char* uplo, lapack_int* n, lapack_int* kd,
lapack_complex_float* ab, lapack_int* ldab, float* d,
float* e, lapack_complex_float* q, lapack_int* ldq,
lapack_complex_float* work, lapack_int *info );
void LAPACK_zhbtrd( char* vect, char* uplo, lapack_int* n, lapack_int* kd,
lapack_complex_double* ab, lapack_int* ldab, double* d,
double* e, lapack_complex_double* q, lapack_int* ldq,
lapack_complex_double* work, lapack_int *info );
void LAPACK_ssterf( lapack_int* n, float* d, float* e, lapack_int *info );
void LAPACK_dsterf( lapack_int* n, double* d, double* e, lapack_int *info );
void LAPACK_ssteqr( char* compz, lapack_int* n, float* d, float* e, float* z,
lapack_int* ldz, float* work, lapack_int *info );
void LAPACK_dsteqr( char* compz, lapack_int* n, double* d, double* e, double* z,
lapack_int* ldz, double* work, lapack_int *info );
void LAPACK_csteqr( char* compz, lapack_int* n, float* d, float* e,
lapack_complex_float* z, lapack_int* ldz, float* work,
lapack_int *info );
void LAPACK_zsteqr( char* compz, lapack_int* n, double* d, double* e,
lapack_complex_double* z, lapack_int* ldz, double* work,
lapack_int *info );
void LAPACK_sstemr( char* jobz, char* range, lapack_int* n, float* d, float* e,
float* vl, float* vu, lapack_int* il, lapack_int* iu,
lapack_int* m, float* w, float* z, lapack_int* ldz,
lapack_int* nzc, lapack_int* isuppz, lapack_logical* tryrac,
float* work, lapack_int* lwork, lapack_int* iwork,
lapack_int* liwork, lapack_int *info );
void LAPACK_dstemr( char* jobz, char* range, lapack_int* n, double* d,
double* e, double* vl, double* vu, lapack_int* il,
lapack_int* iu, lapack_int* m, double* w, double* z,
lapack_int* ldz, lapack_int* nzc, lapack_int* isuppz,
lapack_logical* tryrac, double* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_cstemr( char* jobz, char* range, lapack_int* n, float* d, float* e,
float* vl, float* vu, lapack_int* il, lapack_int* iu,
lapack_int* m, float* w, lapack_complex_float* z,
lapack_int* ldz, lapack_int* nzc, lapack_int* isuppz,
lapack_logical* tryrac, float* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_zstemr( char* jobz, char* range, lapack_int* n, double* d,
double* e, double* vl, double* vu, lapack_int* il,
lapack_int* iu, lapack_int* m, double* w,
lapack_complex_double* z, lapack_int* ldz, lapack_int* nzc,
lapack_int* isuppz, lapack_logical* tryrac, double* work,
lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
lapack_int *info );
void LAPACK_sstedc( char* compz, lapack_int* n, float* d, float* e, float* z,
lapack_int* ldz, float* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_dstedc( char* compz, lapack_int* n, double* d, double* e, double* z,
lapack_int* ldz, double* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_cstedc( char* compz, lapack_int* n, float* d, float* e,
lapack_complex_float* z, lapack_int* ldz,
lapack_complex_float* work, lapack_int* lwork, float* rwork,
lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
lapack_int *info );
void LAPACK_zstedc( char* compz, lapack_int* n, double* d, double* e,
lapack_complex_double* z, lapack_int* ldz,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_int* lrwork, lapack_int* iwork,
lapack_int* liwork, lapack_int *info );
void LAPACK_sstegr( char* jobz, char* range, lapack_int* n, float* d, float* e,
float* vl, float* vu, lapack_int* il, lapack_int* iu,
float* abstol, lapack_int* m, float* w, float* z,
lapack_int* ldz, lapack_int* isuppz, float* work,
lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
lapack_int *info );
void LAPACK_dstegr( char* jobz, char* range, lapack_int* n, double* d,
double* e, double* vl, double* vu, lapack_int* il,
lapack_int* iu, double* abstol, lapack_int* m, double* w,
double* z, lapack_int* ldz, lapack_int* isuppz,
double* work, lapack_int* lwork, lapack_int* iwork,
lapack_int* liwork, lapack_int *info );
void LAPACK_cstegr( char* jobz, char* range, lapack_int* n, float* d, float* e,
float* vl, float* vu, lapack_int* il, lapack_int* iu,
float* abstol, lapack_int* m, float* w,
lapack_complex_float* z, lapack_int* ldz,
lapack_int* isuppz, float* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_zstegr( char* jobz, char* range, lapack_int* n, double* d,
double* e, double* vl, double* vu, lapack_int* il,
lapack_int* iu, double* abstol, lapack_int* m, double* w,
lapack_complex_double* z, lapack_int* ldz,
lapack_int* isuppz, double* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_spteqr( char* compz, lapack_int* n, float* d, float* e, float* z,
lapack_int* ldz, float* work, lapack_int *info );
void LAPACK_dpteqr( char* compz, lapack_int* n, double* d, double* e, double* z,
lapack_int* ldz, double* work, lapack_int *info );
void LAPACK_cpteqr( char* compz, lapack_int* n, float* d, float* e,
lapack_complex_float* z, lapack_int* ldz, float* work,
lapack_int *info );
void LAPACK_zpteqr( char* compz, lapack_int* n, double* d, double* e,
lapack_complex_double* z, lapack_int* ldz, double* work,
lapack_int *info );
void LAPACK_sstebz( char* range, char* order, lapack_int* n, float* vl,
float* vu, lapack_int* il, lapack_int* iu, float* abstol,
const float* d, const float* e, lapack_int* m,
lapack_int* nsplit, float* w, lapack_int* iblock,
lapack_int* isplit, float* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_dstebz( char* range, char* order, lapack_int* n, double* vl,
double* vu, lapack_int* il, lapack_int* iu, double* abstol,
const double* d, const double* e, lapack_int* m,
lapack_int* nsplit, double* w, lapack_int* iblock,
lapack_int* isplit, double* work, lapack_int* iwork,
lapack_int *info );
void LAPACK_sstein( lapack_int* n, const float* d, const float* e,
lapack_int* m, const float* w, const lapack_int* iblock,
const lapack_int* isplit, float* z, lapack_int* ldz,
float* work, lapack_int* iwork, lapack_int* ifailv,
lapack_int *info );
void LAPACK_dstein( lapack_int* n, const double* d, const double* e,
lapack_int* m, const double* w, const lapack_int* iblock,
const lapack_int* isplit, double* z, lapack_int* ldz,
double* work, lapack_int* iwork, lapack_int* ifailv,
lapack_int *info );
void LAPACK_cstein( lapack_int* n, const float* d, const float* e,
lapack_int* m, const float* w, const lapack_int* iblock,
const lapack_int* isplit, lapack_complex_float* z,
lapack_int* ldz, float* work, lapack_int* iwork,
lapack_int* ifailv, lapack_int *info );
void LAPACK_zstein( lapack_int* n, const double* d, const double* e,
lapack_int* m, const double* w, const lapack_int* iblock,
const lapack_int* isplit, lapack_complex_double* z,
lapack_int* ldz, double* work, lapack_int* iwork,
lapack_int* ifailv, lapack_int *info );
void LAPACK_sdisna( char* job, lapack_int* m, lapack_int* n, const float* d,
float* sep, lapack_int *info );
void LAPACK_ddisna( char* job, lapack_int* m, lapack_int* n, const double* d,
double* sep, lapack_int *info );
void LAPACK_ssygst( lapack_int* itype, char* uplo, lapack_int* n, float* a,
lapack_int* lda, const float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_dsygst( lapack_int* itype, char* uplo, lapack_int* n, double* a,
lapack_int* lda, const double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_chegst( lapack_int* itype, char* uplo, lapack_int* n,
lapack_complex_float* a, lapack_int* lda,
const lapack_complex_float* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_zhegst( lapack_int* itype, char* uplo, lapack_int* n,
lapack_complex_double* a, lapack_int* lda,
const lapack_complex_double* b, lapack_int* ldb,
lapack_int *info );
void LAPACK_sspgst( lapack_int* itype, char* uplo, lapack_int* n, float* ap,
const float* bp, lapack_int *info );
void LAPACK_dspgst( lapack_int* itype, char* uplo, lapack_int* n, double* ap,
const double* bp, lapack_int *info );
void LAPACK_chpgst( lapack_int* itype, char* uplo, lapack_int* n,
lapack_complex_float* ap, const lapack_complex_float* bp,
lapack_int *info );
void LAPACK_zhpgst( lapack_int* itype, char* uplo, lapack_int* n,
lapack_complex_double* ap, const lapack_complex_double* bp,
lapack_int *info );
void LAPACK_ssbgst( char* vect, char* uplo, lapack_int* n, lapack_int* ka,
lapack_int* kb, float* ab, lapack_int* ldab,
const float* bb, lapack_int* ldbb, float* x,
lapack_int* ldx, float* work, lapack_int *info );
void LAPACK_dsbgst( char* vect, char* uplo, lapack_int* n, lapack_int* ka,
lapack_int* kb, double* ab, lapack_int* ldab,
const double* bb, lapack_int* ldbb, double* x,
lapack_int* ldx, double* work, lapack_int *info );
void LAPACK_chbgst( char* vect, char* uplo, lapack_int* n, lapack_int* ka,
lapack_int* kb, lapack_complex_float* ab, lapack_int* ldab,
const lapack_complex_float* bb, lapack_int* ldbb,
lapack_complex_float* x, lapack_int* ldx,
lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_zhbgst( char* vect, char* uplo, lapack_int* n, lapack_int* ka,
lapack_int* kb, lapack_complex_double* ab, lapack_int* ldab,
const lapack_complex_double* bb, lapack_int* ldbb,
lapack_complex_double* x, lapack_int* ldx,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_spbstf( char* uplo, lapack_int* n, lapack_int* kb, float* bb,
lapack_int* ldbb, lapack_int *info );
void LAPACK_dpbstf( char* uplo, lapack_int* n, lapack_int* kb, double* bb,
lapack_int* ldbb, lapack_int *info );
void LAPACK_cpbstf( char* uplo, lapack_int* n, lapack_int* kb,
lapack_complex_float* bb, lapack_int* ldbb,
lapack_int *info );
void LAPACK_zpbstf( char* uplo, lapack_int* n, lapack_int* kb,
lapack_complex_double* bb, lapack_int* ldbb,
lapack_int *info );
void LAPACK_sgehrd( lapack_int* n, lapack_int* ilo, lapack_int* ihi, float* a,
lapack_int* lda, float* tau, float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_dgehrd( lapack_int* n, lapack_int* ilo, lapack_int* ihi, double* a,
lapack_int* lda, double* tau, double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_cgehrd( lapack_int* n, lapack_int* ilo, lapack_int* ihi,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* tau, lapack_complex_float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_zgehrd( lapack_int* n, lapack_int* ilo, lapack_int* ihi,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* tau, lapack_complex_double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_sorghr( lapack_int* n, lapack_int* ilo, lapack_int* ihi, float* a,
lapack_int* lda, const float* tau, float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_dorghr( lapack_int* n, lapack_int* ilo, lapack_int* ihi, double* a,
lapack_int* lda, const double* tau, double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_sormhr( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* ilo, lapack_int* ihi, const float* a,
lapack_int* lda, const float* tau, float* c,
lapack_int* ldc, float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_dormhr( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* ilo, lapack_int* ihi, const double* a,
lapack_int* lda, const double* tau, double* c,
lapack_int* ldc, double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_cunghr( lapack_int* n, lapack_int* ilo, lapack_int* ihi,
lapack_complex_float* a, lapack_int* lda,
const lapack_complex_float* tau, lapack_complex_float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_zunghr( lapack_int* n, lapack_int* ilo, lapack_int* ihi,
lapack_complex_double* a, lapack_int* lda,
const lapack_complex_double* tau,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_cunmhr( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* ilo, lapack_int* ihi,
const lapack_complex_float* a, lapack_int* lda,
const lapack_complex_float* tau, lapack_complex_float* c,
lapack_int* ldc, lapack_complex_float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_zunmhr( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* ilo, lapack_int* ihi,
const lapack_complex_double* a, lapack_int* lda,
const lapack_complex_double* tau, lapack_complex_double* c,
lapack_int* ldc, lapack_complex_double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_sgebal( char* job, lapack_int* n, float* a, lapack_int* lda,
lapack_int* ilo, lapack_int* ihi, float* scale,
lapack_int *info );
void LAPACK_dgebal( char* job, lapack_int* n, double* a, lapack_int* lda,
lapack_int* ilo, lapack_int* ihi, double* scale,
lapack_int *info );
void LAPACK_cgebal( char* job, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_int* ilo, lapack_int* ihi,
float* scale, lapack_int *info );
void LAPACK_zgebal( char* job, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_int* ilo, lapack_int* ihi,
double* scale, lapack_int *info );
void LAPACK_sgebak( char* job, char* side, lapack_int* n, lapack_int* ilo,
lapack_int* ihi, const float* scale, lapack_int* m,
float* v, lapack_int* ldv, lapack_int *info );
void LAPACK_dgebak( char* job, char* side, lapack_int* n, lapack_int* ilo,
lapack_int* ihi, const double* scale, lapack_int* m,
double* v, lapack_int* ldv, lapack_int *info );
void LAPACK_cgebak( char* job, char* side, lapack_int* n, lapack_int* ilo,
lapack_int* ihi, const float* scale, lapack_int* m,
lapack_complex_float* v, lapack_int* ldv,
lapack_int *info );
void LAPACK_zgebak( char* job, char* side, lapack_int* n, lapack_int* ilo,
lapack_int* ihi, const double* scale, lapack_int* m,
lapack_complex_double* v, lapack_int* ldv,
lapack_int *info );
void LAPACK_shseqr( char* job, char* compz, lapack_int* n, lapack_int* ilo,
lapack_int* ihi, float* h, lapack_int* ldh, float* wr,
float* wi, float* z, lapack_int* ldz, float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_dhseqr( char* job, char* compz, lapack_int* n, lapack_int* ilo,
lapack_int* ihi, double* h, lapack_int* ldh, double* wr,
double* wi, double* z, lapack_int* ldz, double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_chseqr( char* job, char* compz, lapack_int* n, lapack_int* ilo,
lapack_int* ihi, lapack_complex_float* h, lapack_int* ldh,
lapack_complex_float* w, lapack_complex_float* z,
lapack_int* ldz, lapack_complex_float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_zhseqr( char* job, char* compz, lapack_int* n, lapack_int* ilo,
lapack_int* ihi, lapack_complex_double* h, lapack_int* ldh,
lapack_complex_double* w, lapack_complex_double* z,
lapack_int* ldz, lapack_complex_double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_shsein( char* job, char* eigsrc, char* initv,
lapack_logical* select, lapack_int* n, const float* h,
lapack_int* ldh, float* wr, const float* wi, float* vl,
lapack_int* ldvl, float* vr, lapack_int* ldvr,
lapack_int* mm, lapack_int* m, float* work,
lapack_int* ifaill, lapack_int* ifailr, lapack_int *info );
void LAPACK_dhsein( char* job, char* eigsrc, char* initv,
lapack_logical* select, lapack_int* n, const double* h,
lapack_int* ldh, double* wr, const double* wi, double* vl,
lapack_int* ldvl, double* vr, lapack_int* ldvr,
lapack_int* mm, lapack_int* m, double* work,
lapack_int* ifaill, lapack_int* ifailr, lapack_int *info );
void LAPACK_chsein( char* job, char* eigsrc, char* initv,
const lapack_logical* select, lapack_int* n,
const lapack_complex_float* h, lapack_int* ldh,
lapack_complex_float* w, lapack_complex_float* vl,
lapack_int* ldvl, lapack_complex_float* vr,
lapack_int* ldvr, lapack_int* mm, lapack_int* m,
lapack_complex_float* work, float* rwork,
lapack_int* ifaill, lapack_int* ifailr, lapack_int *info );
void LAPACK_zhsein( char* job, char* eigsrc, char* initv,
const lapack_logical* select, lapack_int* n,
const lapack_complex_double* h, lapack_int* ldh,
lapack_complex_double* w, lapack_complex_double* vl,
lapack_int* ldvl, lapack_complex_double* vr,
lapack_int* ldvr, lapack_int* mm, lapack_int* m,
lapack_complex_double* work, double* rwork,
lapack_int* ifaill, lapack_int* ifailr, lapack_int *info );
void LAPACK_strevc( char* side, char* howmny, lapack_logical* select,
lapack_int* n, const float* t, lapack_int* ldt, float* vl,
lapack_int* ldvl, float* vr, lapack_int* ldvr,
lapack_int* mm, lapack_int* m, float* work,
lapack_int *info );
void LAPACK_dtrevc( char* side, char* howmny, lapack_logical* select,
lapack_int* n, const double* t, lapack_int* ldt, double* vl,
lapack_int* ldvl, double* vr, lapack_int* ldvr,
lapack_int* mm, lapack_int* m, double* work,
lapack_int *info );
void LAPACK_ctrevc( char* side, char* howmny, const lapack_logical* select,
lapack_int* n, lapack_complex_float* t, lapack_int* ldt,
lapack_complex_float* vl, lapack_int* ldvl,
lapack_complex_float* vr, lapack_int* ldvr, lapack_int* mm,
lapack_int* m, lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_ztrevc( char* side, char* howmny, const lapack_logical* select,
lapack_int* n, lapack_complex_double* t, lapack_int* ldt,
lapack_complex_double* vl, lapack_int* ldvl,
lapack_complex_double* vr, lapack_int* ldvr, lapack_int* mm,
lapack_int* m, lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_strsna( char* job, char* howmny, const lapack_logical* select,
lapack_int* n, const float* t, lapack_int* ldt,
const float* vl, lapack_int* ldvl, const float* vr,
lapack_int* ldvr, float* s, float* sep, lapack_int* mm,
lapack_int* m, float* work, lapack_int* ldwork,
lapack_int* iwork, lapack_int *info );
void LAPACK_dtrsna( char* job, char* howmny, const lapack_logical* select,
lapack_int* n, const double* t, lapack_int* ldt,
const double* vl, lapack_int* ldvl, const double* vr,
lapack_int* ldvr, double* s, double* sep, lapack_int* mm,
lapack_int* m, double* work, lapack_int* ldwork,
lapack_int* iwork, lapack_int *info );
void LAPACK_ctrsna( char* job, char* howmny, const lapack_logical* select,
lapack_int* n, const lapack_complex_float* t,
lapack_int* ldt, const lapack_complex_float* vl,
lapack_int* ldvl, const lapack_complex_float* vr,
lapack_int* ldvr, float* s, float* sep, lapack_int* mm,
lapack_int* m, lapack_complex_float* work,
lapack_int* ldwork, float* rwork, lapack_int *info );
void LAPACK_ztrsna( char* job, char* howmny, const lapack_logical* select,
lapack_int* n, const lapack_complex_double* t,
lapack_int* ldt, const lapack_complex_double* vl,
lapack_int* ldvl, const lapack_complex_double* vr,
lapack_int* ldvr, double* s, double* sep, lapack_int* mm,
lapack_int* m, lapack_complex_double* work,
lapack_int* ldwork, double* rwork, lapack_int *info );
void LAPACK_strexc( char* compq, lapack_int* n, float* t, lapack_int* ldt,
float* q, lapack_int* ldq, lapack_int* ifst,
lapack_int* ilst, float* work, lapack_int *info );
void LAPACK_dtrexc( char* compq, lapack_int* n, double* t, lapack_int* ldt,
double* q, lapack_int* ldq, lapack_int* ifst,
lapack_int* ilst, double* work, lapack_int *info );
void LAPACK_ctrexc( char* compq, lapack_int* n, lapack_complex_float* t,
lapack_int* ldt, lapack_complex_float* q, lapack_int* ldq,
lapack_int* ifst, lapack_int* ilst, lapack_int *info );
void LAPACK_ztrexc( char* compq, lapack_int* n, lapack_complex_double* t,
lapack_int* ldt, lapack_complex_double* q, lapack_int* ldq,
lapack_int* ifst, lapack_int* ilst, lapack_int *info );
void LAPACK_strsen( char* job, char* compq, const lapack_logical* select,
lapack_int* n, float* t, lapack_int* ldt, float* q,
lapack_int* ldq, float* wr, float* wi, lapack_int* m,
float* s, float* sep, float* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_dtrsen( char* job, char* compq, const lapack_logical* select,
lapack_int* n, double* t, lapack_int* ldt, double* q,
lapack_int* ldq, double* wr, double* wi, lapack_int* m,
double* s, double* sep, double* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_ctrsen( char* job, char* compq, const lapack_logical* select,
lapack_int* n, lapack_complex_float* t, lapack_int* ldt,
lapack_complex_float* q, lapack_int* ldq,
lapack_complex_float* w, lapack_int* m, float* s,
float* sep, lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_ztrsen( char* job, char* compq, const lapack_logical* select,
lapack_int* n, lapack_complex_double* t, lapack_int* ldt,
lapack_complex_double* q, lapack_int* ldq,
lapack_complex_double* w, lapack_int* m, double* s,
double* sep, lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_strsyl( char* trana, char* tranb, lapack_int* isgn, lapack_int* m,
lapack_int* n, const float* a, lapack_int* lda,
const float* b, lapack_int* ldb, float* c, lapack_int* ldc,
float* scale, lapack_int *info );
void LAPACK_dtrsyl( char* trana, char* tranb, lapack_int* isgn, lapack_int* m,
lapack_int* n, const double* a, lapack_int* lda,
const double* b, lapack_int* ldb, double* c,
lapack_int* ldc, double* scale, lapack_int *info );
void LAPACK_ctrsyl( char* trana, char* tranb, lapack_int* isgn, lapack_int* m,
lapack_int* n, const lapack_complex_float* a,
lapack_int* lda, const lapack_complex_float* b,
lapack_int* ldb, lapack_complex_float* c, lapack_int* ldc,
float* scale, lapack_int *info );
void LAPACK_ztrsyl( char* trana, char* tranb, lapack_int* isgn, lapack_int* m,
lapack_int* n, const lapack_complex_double* a,
lapack_int* lda, const lapack_complex_double* b,
lapack_int* ldb, lapack_complex_double* c, lapack_int* ldc,
double* scale, lapack_int *info );
void LAPACK_sgghrd( char* compq, char* compz, lapack_int* n, lapack_int* ilo,
lapack_int* ihi, float* a, lapack_int* lda, float* b,
lapack_int* ldb, float* q, lapack_int* ldq, float* z,
lapack_int* ldz, lapack_int *info );
void LAPACK_dgghrd( char* compq, char* compz, lapack_int* n, lapack_int* ilo,
lapack_int* ihi, double* a, lapack_int* lda, double* b,
lapack_int* ldb, double* q, lapack_int* ldq, double* z,
lapack_int* ldz, lapack_int *info );
void LAPACK_cgghrd( char* compq, char* compz, lapack_int* n, lapack_int* ilo,
lapack_int* ihi, lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* q, lapack_int* ldq,
lapack_complex_float* z, lapack_int* ldz,
lapack_int *info );
void LAPACK_zgghrd( char* compq, char* compz, lapack_int* n, lapack_int* ilo,
lapack_int* ihi, lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* q, lapack_int* ldq,
lapack_complex_double* z, lapack_int* ldz,
lapack_int *info );
void LAPACK_sggbal( char* job, lapack_int* n, float* a, lapack_int* lda,
float* b, lapack_int* ldb, lapack_int* ilo, lapack_int* ihi,
float* lscale, float* rscale, float* work,
lapack_int *info );
void LAPACK_dggbal( char* job, lapack_int* n, double* a, lapack_int* lda,
double* b, lapack_int* ldb, lapack_int* ilo,
lapack_int* ihi, double* lscale, double* rscale,
double* work, lapack_int *info );
void LAPACK_cggbal( char* job, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_complex_float* b, lapack_int* ldb,
lapack_int* ilo, lapack_int* ihi, float* lscale,
float* rscale, float* work, lapack_int *info );
void LAPACK_zggbal( char* job, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
lapack_int* ilo, lapack_int* ihi, double* lscale,
double* rscale, double* work, lapack_int *info );
void LAPACK_sggbak( char* job, char* side, lapack_int* n, lapack_int* ilo,
lapack_int* ihi, const float* lscale, const float* rscale,
lapack_int* m, float* v, lapack_int* ldv,
lapack_int *info );
void LAPACK_dggbak( char* job, char* side, lapack_int* n, lapack_int* ilo,
lapack_int* ihi, const double* lscale, const double* rscale,
lapack_int* m, double* v, lapack_int* ldv,
lapack_int *info );
void LAPACK_cggbak( char* job, char* side, lapack_int* n, lapack_int* ilo,
lapack_int* ihi, const float* lscale, const float* rscale,
lapack_int* m, lapack_complex_float* v, lapack_int* ldv,
lapack_int *info );
void LAPACK_zggbak( char* job, char* side, lapack_int* n, lapack_int* ilo,
lapack_int* ihi, const double* lscale, const double* rscale,
lapack_int* m, lapack_complex_double* v, lapack_int* ldv,
lapack_int *info );
void LAPACK_shgeqz( char* job, char* compq, char* compz, lapack_int* n,
lapack_int* ilo, lapack_int* ihi, float* h, lapack_int* ldh,
float* t, lapack_int* ldt, float* alphar, float* alphai,
float* beta, float* q, lapack_int* ldq, float* z,
lapack_int* ldz, float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_dhgeqz( char* job, char* compq, char* compz, lapack_int* n,
lapack_int* ilo, lapack_int* ihi, double* h,
lapack_int* ldh, double* t, lapack_int* ldt, double* alphar,
double* alphai, double* beta, double* q, lapack_int* ldq,
double* z, lapack_int* ldz, double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_chgeqz( char* job, char* compq, char* compz, lapack_int* n,
lapack_int* ilo, lapack_int* ihi, lapack_complex_float* h,
lapack_int* ldh, lapack_complex_float* t, lapack_int* ldt,
lapack_complex_float* alpha, lapack_complex_float* beta,
lapack_complex_float* q, lapack_int* ldq,
lapack_complex_float* z, lapack_int* ldz,
lapack_complex_float* work, lapack_int* lwork, float* rwork,
lapack_int *info );
void LAPACK_zhgeqz( char* job, char* compq, char* compz, lapack_int* n,
lapack_int* ilo, lapack_int* ihi, lapack_complex_double* h,
lapack_int* ldh, lapack_complex_double* t, lapack_int* ldt,
lapack_complex_double* alpha, lapack_complex_double* beta,
lapack_complex_double* q, lapack_int* ldq,
lapack_complex_double* z, lapack_int* ldz,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_int *info );
void LAPACK_stgevc( char* side, char* howmny, const lapack_logical* select,
lapack_int* n, const float* s, lapack_int* lds,
const float* p, lapack_int* ldp, float* vl,
lapack_int* ldvl, float* vr, lapack_int* ldvr,
lapack_int* mm, lapack_int* m, float* work,
lapack_int *info );
void LAPACK_dtgevc( char* side, char* howmny, const lapack_logical* select,
lapack_int* n, const double* s, lapack_int* lds,
const double* p, lapack_int* ldp, double* vl,
lapack_int* ldvl, double* vr, lapack_int* ldvr,
lapack_int* mm, lapack_int* m, double* work,
lapack_int *info );
void LAPACK_ctgevc( char* side, char* howmny, const lapack_logical* select,
lapack_int* n, const lapack_complex_float* s,
lapack_int* lds, const lapack_complex_float* p,
lapack_int* ldp, lapack_complex_float* vl, lapack_int* ldvl,
lapack_complex_float* vr, lapack_int* ldvr, lapack_int* mm,
lapack_int* m, lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_ztgevc( char* side, char* howmny, const lapack_logical* select,
lapack_int* n, const lapack_complex_double* s,
lapack_int* lds, const lapack_complex_double* p,
lapack_int* ldp, lapack_complex_double* vl,
lapack_int* ldvl, lapack_complex_double* vr,
lapack_int* ldvr, lapack_int* mm, lapack_int* m,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_stgexc( lapack_logical* wantq, lapack_logical* wantz, lapack_int* n,
float* a, lapack_int* lda, float* b, lapack_int* ldb,
float* q, lapack_int* ldq, float* z, lapack_int* ldz,
lapack_int* ifst, lapack_int* ilst, float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_dtgexc( lapack_logical* wantq, lapack_logical* wantz, lapack_int* n,
double* a, lapack_int* lda, double* b, lapack_int* ldb,
double* q, lapack_int* ldq, double* z, lapack_int* ldz,
lapack_int* ifst, lapack_int* ilst, double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_ctgexc( lapack_logical* wantq, lapack_logical* wantz, lapack_int* n,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* q, lapack_int* ldq,
lapack_complex_float* z, lapack_int* ldz, lapack_int* ifst,
lapack_int* ilst, lapack_int *info );
void LAPACK_ztgexc( lapack_logical* wantq, lapack_logical* wantz, lapack_int* n,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* q, lapack_int* ldq,
lapack_complex_double* z, lapack_int* ldz, lapack_int* ifst,
lapack_int* ilst, lapack_int *info );
void LAPACK_stgsen( lapack_int* ijob, lapack_logical* wantq,
lapack_logical* wantz, const lapack_logical* select,
lapack_int* n, float* a, lapack_int* lda, float* b,
lapack_int* ldb, float* alphar, float* alphai, float* beta,
float* q, lapack_int* ldq, float* z, lapack_int* ldz,
lapack_int* m, float* pl, float* pr, float* dif,
float* work, lapack_int* lwork, lapack_int* iwork,
lapack_int* liwork, lapack_int *info );
void LAPACK_dtgsen( lapack_int* ijob, lapack_logical* wantq,
lapack_logical* wantz, const lapack_logical* select,
lapack_int* n, double* a, lapack_int* lda, double* b,
lapack_int* ldb, double* alphar, double* alphai,
double* beta, double* q, lapack_int* ldq, double* z,
lapack_int* ldz, lapack_int* m, double* pl, double* pr,
double* dif, double* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_ctgsen( lapack_int* ijob, lapack_logical* wantq,
lapack_logical* wantz, const lapack_logical* select,
lapack_int* n, lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* alpha, lapack_complex_float* beta,
lapack_complex_float* q, lapack_int* ldq,
lapack_complex_float* z, lapack_int* ldz, lapack_int* m,
float* pl, float* pr, float* dif,
lapack_complex_float* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_ztgsen( lapack_int* ijob, lapack_logical* wantq,
lapack_logical* wantz, const lapack_logical* select,
lapack_int* n, lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* alpha, lapack_complex_double* beta,
lapack_complex_double* q, lapack_int* ldq,
lapack_complex_double* z, lapack_int* ldz, lapack_int* m,
double* pl, double* pr, double* dif,
lapack_complex_double* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_stgsyl( char* trans, lapack_int* ijob, lapack_int* m, lapack_int* n,
const float* a, lapack_int* lda, const float* b,
lapack_int* ldb, float* c, lapack_int* ldc, const float* d,
lapack_int* ldd, const float* e, lapack_int* lde, float* f,
lapack_int* ldf, float* scale, float* dif, float* work,
lapack_int* lwork, lapack_int* iwork, lapack_int *info );
void LAPACK_dtgsyl( char* trans, lapack_int* ijob, lapack_int* m, lapack_int* n,
const double* a, lapack_int* lda, const double* b,
lapack_int* ldb, double* c, lapack_int* ldc,
const double* d, lapack_int* ldd, const double* e,
lapack_int* lde, double* f, lapack_int* ldf, double* scale,
double* dif, double* work, lapack_int* lwork,
lapack_int* iwork, lapack_int *info );
void LAPACK_ctgsyl( char* trans, lapack_int* ijob, lapack_int* m, lapack_int* n,
const lapack_complex_float* a, lapack_int* lda,
const lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* c, lapack_int* ldc,
const lapack_complex_float* d, lapack_int* ldd,
const lapack_complex_float* e, lapack_int* lde,
lapack_complex_float* f, lapack_int* ldf, float* scale,
float* dif, lapack_complex_float* work, lapack_int* lwork,
lapack_int* iwork, lapack_int *info );
void LAPACK_ztgsyl( char* trans, lapack_int* ijob, lapack_int* m, lapack_int* n,
const lapack_complex_double* a, lapack_int* lda,
const lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* c, lapack_int* ldc,
const lapack_complex_double* d, lapack_int* ldd,
const lapack_complex_double* e, lapack_int* lde,
lapack_complex_double* f, lapack_int* ldf, double* scale,
double* dif, lapack_complex_double* work, lapack_int* lwork,
lapack_int* iwork, lapack_int *info );
void LAPACK_stgsna( char* job, char* howmny, const lapack_logical* select,
lapack_int* n, const float* a, lapack_int* lda,
const float* b, lapack_int* ldb, const float* vl,
lapack_int* ldvl, const float* vr, lapack_int* ldvr,
float* s, float* dif, lapack_int* mm, lapack_int* m,
float* work, lapack_int* lwork, lapack_int* iwork,
lapack_int *info );
void LAPACK_dtgsna( char* job, char* howmny, const lapack_logical* select,
lapack_int* n, const double* a, lapack_int* lda,
const double* b, lapack_int* ldb, const double* vl,
lapack_int* ldvl, const double* vr, lapack_int* ldvr,
double* s, double* dif, lapack_int* mm, lapack_int* m,
double* work, lapack_int* lwork, lapack_int* iwork,
lapack_int *info );
void LAPACK_ctgsna( char* job, char* howmny, const lapack_logical* select,
lapack_int* n, const lapack_complex_float* a,
lapack_int* lda, const lapack_complex_float* b,
lapack_int* ldb, const lapack_complex_float* vl,
lapack_int* ldvl, const lapack_complex_float* vr,
lapack_int* ldvr, float* s, float* dif, lapack_int* mm,
lapack_int* m, lapack_complex_float* work,
lapack_int* lwork, lapack_int* iwork, lapack_int *info );
void LAPACK_ztgsna( char* job, char* howmny, const lapack_logical* select,
lapack_int* n, const lapack_complex_double* a,
lapack_int* lda, const lapack_complex_double* b,
lapack_int* ldb, const lapack_complex_double* vl,
lapack_int* ldvl, const lapack_complex_double* vr,
lapack_int* ldvr, double* s, double* dif, lapack_int* mm,
lapack_int* m, lapack_complex_double* work,
lapack_int* lwork, lapack_int* iwork, lapack_int *info );
void LAPACK_sggsvp( char* jobu, char* jobv, char* jobq, lapack_int* m,
lapack_int* p, lapack_int* n, float* a, lapack_int* lda,
float* b, lapack_int* ldb, float* tola, float* tolb,
lapack_int* k, lapack_int* l, float* u, lapack_int* ldu,
float* v, lapack_int* ldv, float* q, lapack_int* ldq,
lapack_int* iwork, float* tau, float* work,
lapack_int *info );
void LAPACK_dggsvp( char* jobu, char* jobv, char* jobq, lapack_int* m,
lapack_int* p, lapack_int* n, double* a, lapack_int* lda,
double* b, lapack_int* ldb, double* tola, double* tolb,
lapack_int* k, lapack_int* l, double* u, lapack_int* ldu,
double* v, lapack_int* ldv, double* q, lapack_int* ldq,
lapack_int* iwork, double* tau, double* work,
lapack_int *info );
void LAPACK_cggsvp( char* jobu, char* jobv, char* jobq, lapack_int* m,
lapack_int* p, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_complex_float* b, lapack_int* ldb,
float* tola, float* tolb, lapack_int* k, lapack_int* l,
lapack_complex_float* u, lapack_int* ldu,
lapack_complex_float* v, lapack_int* ldv,
lapack_complex_float* q, lapack_int* ldq, lapack_int* iwork,
float* rwork, lapack_complex_float* tau,
lapack_complex_float* work, lapack_int *info );
void LAPACK_zggsvp( char* jobu, char* jobv, char* jobq, lapack_int* m,
lapack_int* p, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
double* tola, double* tolb, lapack_int* k, lapack_int* l,
lapack_complex_double* u, lapack_int* ldu,
lapack_complex_double* v, lapack_int* ldv,
lapack_complex_double* q, lapack_int* ldq,
lapack_int* iwork, double* rwork,
lapack_complex_double* tau, lapack_complex_double* work,
lapack_int *info );
void LAPACK_stgsja( char* jobu, char* jobv, char* jobq, lapack_int* m,
lapack_int* p, lapack_int* n, lapack_int* k, lapack_int* l,
float* a, lapack_int* lda, float* b, lapack_int* ldb,
float* tola, float* tolb, float* alpha, float* beta,
float* u, lapack_int* ldu, float* v, lapack_int* ldv,
float* q, lapack_int* ldq, float* work, lapack_int* ncycle,
lapack_int *info );
void LAPACK_dtgsja( char* jobu, char* jobv, char* jobq, lapack_int* m,
lapack_int* p, lapack_int* n, lapack_int* k, lapack_int* l,
double* a, lapack_int* lda, double* b, lapack_int* ldb,
double* tola, double* tolb, double* alpha, double* beta,
double* u, lapack_int* ldu, double* v, lapack_int* ldv,
double* q, lapack_int* ldq, double* work,
lapack_int* ncycle, lapack_int *info );
void LAPACK_ctgsja( char* jobu, char* jobv, char* jobq, lapack_int* m,
lapack_int* p, lapack_int* n, lapack_int* k, lapack_int* l,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb, float* tola,
float* tolb, float* alpha, float* beta,
lapack_complex_float* u, lapack_int* ldu,
lapack_complex_float* v, lapack_int* ldv,
lapack_complex_float* q, lapack_int* ldq,
lapack_complex_float* work, lapack_int* ncycle,
lapack_int *info );
void LAPACK_ztgsja( char* jobu, char* jobv, char* jobq, lapack_int* m,
lapack_int* p, lapack_int* n, lapack_int* k, lapack_int* l,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb, double* tola,
double* tolb, double* alpha, double* beta,
lapack_complex_double* u, lapack_int* ldu,
lapack_complex_double* v, lapack_int* ldv,
lapack_complex_double* q, lapack_int* ldq,
lapack_complex_double* work, lapack_int* ncycle,
lapack_int *info );
void LAPACK_sgels( char* trans, lapack_int* m, lapack_int* n, lapack_int* nrhs,
float* a, lapack_int* lda, float* b, lapack_int* ldb,
float* work, lapack_int* lwork, lapack_int *info );
void LAPACK_dgels( char* trans, lapack_int* m, lapack_int* n, lapack_int* nrhs,
double* a, lapack_int* lda, double* b, lapack_int* ldb,
double* work, lapack_int* lwork, lapack_int *info );
void LAPACK_cgels( char* trans, lapack_int* m, lapack_int* n, lapack_int* nrhs,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_zgels( char* trans, lapack_int* m, lapack_int* n, lapack_int* nrhs,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_sgelsy( lapack_int* m, lapack_int* n, lapack_int* nrhs, float* a,
lapack_int* lda, float* b, lapack_int* ldb,
lapack_int* jpvt, float* rcond, lapack_int* rank,
float* work, lapack_int* lwork, lapack_int *info );
void LAPACK_dgelsy( lapack_int* m, lapack_int* n, lapack_int* nrhs, double* a,
lapack_int* lda, double* b, lapack_int* ldb,
lapack_int* jpvt, double* rcond, lapack_int* rank,
double* work, lapack_int* lwork, lapack_int *info );
void LAPACK_cgelsy( lapack_int* m, lapack_int* n, lapack_int* nrhs,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb, lapack_int* jpvt,
float* rcond, lapack_int* rank, lapack_complex_float* work,
lapack_int* lwork, float* rwork, lapack_int *info );
void LAPACK_zgelsy( lapack_int* m, lapack_int* n, lapack_int* nrhs,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb, lapack_int* jpvt,
double* rcond, lapack_int* rank,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_int *info );
void LAPACK_sgelss( lapack_int* m, lapack_int* n, lapack_int* nrhs, float* a,
lapack_int* lda, float* b, lapack_int* ldb, float* s,
float* rcond, lapack_int* rank, float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_dgelss( lapack_int* m, lapack_int* n, lapack_int* nrhs, double* a,
lapack_int* lda, double* b, lapack_int* ldb, double* s,
double* rcond, lapack_int* rank, double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_cgelss( lapack_int* m, lapack_int* n, lapack_int* nrhs,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb, float* s,
float* rcond, lapack_int* rank, lapack_complex_float* work,
lapack_int* lwork, float* rwork, lapack_int *info );
void LAPACK_zgelss( lapack_int* m, lapack_int* n, lapack_int* nrhs,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb, double* s,
double* rcond, lapack_int* rank,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_int *info );
void LAPACK_sgelsd( lapack_int* m, lapack_int* n, lapack_int* nrhs, float* a,
lapack_int* lda, float* b, lapack_int* ldb, float* s,
float* rcond, lapack_int* rank, float* work,
lapack_int* lwork, lapack_int* iwork, lapack_int *info );
void LAPACK_dgelsd( lapack_int* m, lapack_int* n, lapack_int* nrhs, double* a,
lapack_int* lda, double* b, lapack_int* ldb, double* s,
double* rcond, lapack_int* rank, double* work,
lapack_int* lwork, lapack_int* iwork, lapack_int *info );
void LAPACK_cgelsd( lapack_int* m, lapack_int* n, lapack_int* nrhs,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb, float* s,
float* rcond, lapack_int* rank, lapack_complex_float* work,
lapack_int* lwork, float* rwork, lapack_int* iwork,
lapack_int *info );
void LAPACK_zgelsd( lapack_int* m, lapack_int* n, lapack_int* nrhs,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb, double* s,
double* rcond, lapack_int* rank,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_int* iwork, lapack_int *info );
void LAPACK_sgglse( lapack_int* m, lapack_int* n, lapack_int* p, float* a,
lapack_int* lda, float* b, lapack_int* ldb, float* c,
float* d, float* x, float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_dgglse( lapack_int* m, lapack_int* n, lapack_int* p, double* a,
lapack_int* lda, double* b, lapack_int* ldb, double* c,
double* d, double* x, double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_cgglse( lapack_int* m, lapack_int* n, lapack_int* p,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* c, lapack_complex_float* d,
lapack_complex_float* x, lapack_complex_float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_zgglse( lapack_int* m, lapack_int* n, lapack_int* p,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* c, lapack_complex_double* d,
lapack_complex_double* x, lapack_complex_double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_sggglm( lapack_int* n, lapack_int* m, lapack_int* p, float* a,
lapack_int* lda, float* b, lapack_int* ldb, float* d,
float* x, float* y, float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_dggglm( lapack_int* n, lapack_int* m, lapack_int* p, double* a,
lapack_int* lda, double* b, lapack_int* ldb, double* d,
double* x, double* y, double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_cggglm( lapack_int* n, lapack_int* m, lapack_int* p,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* d, lapack_complex_float* x,
lapack_complex_float* y, lapack_complex_float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_zggglm( lapack_int* n, lapack_int* m, lapack_int* p,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* d, lapack_complex_double* x,
lapack_complex_double* y, lapack_complex_double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_ssyev( char* jobz, char* uplo, lapack_int* n, float* a,
lapack_int* lda, float* w, float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_dsyev( char* jobz, char* uplo, lapack_int* n, double* a,
lapack_int* lda, double* w, double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_cheev( char* jobz, char* uplo, lapack_int* n,
lapack_complex_float* a, lapack_int* lda, float* w,
lapack_complex_float* work, lapack_int* lwork, float* rwork,
lapack_int *info );
void LAPACK_zheev( char* jobz, char* uplo, lapack_int* n,
lapack_complex_double* a, lapack_int* lda, double* w,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_int *info );
void LAPACK_ssyevd( char* jobz, char* uplo, lapack_int* n, float* a,
lapack_int* lda, float* w, float* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_dsyevd( char* jobz, char* uplo, lapack_int* n, double* a,
lapack_int* lda, double* w, double* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_cheevd( char* jobz, char* uplo, lapack_int* n,
lapack_complex_float* a, lapack_int* lda, float* w,
lapack_complex_float* work, lapack_int* lwork, float* rwork,
lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
lapack_int *info );
void LAPACK_zheevd( char* jobz, char* uplo, lapack_int* n,
lapack_complex_double* a, lapack_int* lda, double* w,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_int* lrwork, lapack_int* iwork,
lapack_int* liwork, lapack_int *info );
void LAPACK_ssyevx( char* jobz, char* range, char* uplo, lapack_int* n,
float* a, lapack_int* lda, float* vl, float* vu,
lapack_int* il, lapack_int* iu, float* abstol,
lapack_int* m, float* w, float* z, lapack_int* ldz,
float* work, lapack_int* lwork, lapack_int* iwork,
lapack_int* ifail, lapack_int *info );
void LAPACK_dsyevx( char* jobz, char* range, char* uplo, lapack_int* n,
double* a, lapack_int* lda, double* vl, double* vu,
lapack_int* il, lapack_int* iu, double* abstol,
lapack_int* m, double* w, double* z, lapack_int* ldz,
double* work, lapack_int* lwork, lapack_int* iwork,
lapack_int* ifail, lapack_int *info );
void LAPACK_cheevx( char* jobz, char* range, char* uplo, lapack_int* n,
lapack_complex_float* a, lapack_int* lda, float* vl,
float* vu, lapack_int* il, lapack_int* iu, float* abstol,
lapack_int* m, float* w, lapack_complex_float* z,
lapack_int* ldz, lapack_complex_float* work,
lapack_int* lwork, float* rwork, lapack_int* iwork,
lapack_int* ifail, lapack_int *info );
void LAPACK_zheevx( char* jobz, char* range, char* uplo, lapack_int* n,
lapack_complex_double* a, lapack_int* lda, double* vl,
double* vu, lapack_int* il, lapack_int* iu, double* abstol,
lapack_int* m, double* w, lapack_complex_double* z,
lapack_int* ldz, lapack_complex_double* work,
lapack_int* lwork, double* rwork, lapack_int* iwork,
lapack_int* ifail, lapack_int *info );
void LAPACK_ssyevr( char* jobz, char* range, char* uplo, lapack_int* n,
float* a, lapack_int* lda, float* vl, float* vu,
lapack_int* il, lapack_int* iu, float* abstol,
lapack_int* m, float* w, float* z, lapack_int* ldz,
lapack_int* isuppz, float* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_dsyevr( char* jobz, char* range, char* uplo, lapack_int* n,
double* a, lapack_int* lda, double* vl, double* vu,
lapack_int* il, lapack_int* iu, double* abstol,
lapack_int* m, double* w, double* z, lapack_int* ldz,
lapack_int* isuppz, double* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_cheevr( char* jobz, char* range, char* uplo, lapack_int* n,
lapack_complex_float* a, lapack_int* lda, float* vl,
float* vu, lapack_int* il, lapack_int* iu, float* abstol,
lapack_int* m, float* w, lapack_complex_float* z,
lapack_int* ldz, lapack_int* isuppz,
lapack_complex_float* work, lapack_int* lwork, float* rwork,
lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
lapack_int *info );
void LAPACK_zheevr( char* jobz, char* range, char* uplo, lapack_int* n,
lapack_complex_double* a, lapack_int* lda, double* vl,
double* vu, lapack_int* il, lapack_int* iu, double* abstol,
lapack_int* m, double* w, lapack_complex_double* z,
lapack_int* ldz, lapack_int* isuppz,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_int* lrwork, lapack_int* iwork,
lapack_int* liwork, lapack_int *info );
void LAPACK_sspev( char* jobz, char* uplo, lapack_int* n, float* ap, float* w,
float* z, lapack_int* ldz, float* work, lapack_int *info );
void LAPACK_dspev( char* jobz, char* uplo, lapack_int* n, double* ap, double* w,
double* z, lapack_int* ldz, double* work, lapack_int *info );
void LAPACK_chpev( char* jobz, char* uplo, lapack_int* n,
lapack_complex_float* ap, float* w, lapack_complex_float* z,
lapack_int* ldz, lapack_complex_float* work, float* rwork,
lapack_int *info );
void LAPACK_zhpev( char* jobz, char* uplo, lapack_int* n,
lapack_complex_double* ap, double* w,
lapack_complex_double* z, lapack_int* ldz,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_sspevd( char* jobz, char* uplo, lapack_int* n, float* ap, float* w,
float* z, lapack_int* ldz, float* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_dspevd( char* jobz, char* uplo, lapack_int* n, double* ap,
double* w, double* z, lapack_int* ldz, double* work,
lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
lapack_int *info );
void LAPACK_chpevd( char* jobz, char* uplo, lapack_int* n,
lapack_complex_float* ap, float* w, lapack_complex_float* z,
lapack_int* ldz, lapack_complex_float* work,
lapack_int* lwork, float* rwork, lapack_int* lrwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_zhpevd( char* jobz, char* uplo, lapack_int* n,
lapack_complex_double* ap, double* w,
lapack_complex_double* z, lapack_int* ldz,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_int* lrwork, lapack_int* iwork,
lapack_int* liwork, lapack_int *info );
void LAPACK_sspevx( char* jobz, char* range, char* uplo, lapack_int* n,
float* ap, float* vl, float* vu, lapack_int* il,
lapack_int* iu, float* abstol, lapack_int* m, float* w,
float* z, lapack_int* ldz, float* work, lapack_int* iwork,
lapack_int* ifail, lapack_int *info );
void LAPACK_dspevx( char* jobz, char* range, char* uplo, lapack_int* n,
double* ap, double* vl, double* vu, lapack_int* il,
lapack_int* iu, double* abstol, lapack_int* m, double* w,
double* z, lapack_int* ldz, double* work, lapack_int* iwork,
lapack_int* ifail, lapack_int *info );
void LAPACK_chpevx( char* jobz, char* range, char* uplo, lapack_int* n,
lapack_complex_float* ap, float* vl, float* vu,
lapack_int* il, lapack_int* iu, float* abstol,
lapack_int* m, float* w, lapack_complex_float* z,
lapack_int* ldz, lapack_complex_float* work, float* rwork,
lapack_int* iwork, lapack_int* ifail, lapack_int *info );
void LAPACK_zhpevx( char* jobz, char* range, char* uplo, lapack_int* n,
lapack_complex_double* ap, double* vl, double* vu,
lapack_int* il, lapack_int* iu, double* abstol,
lapack_int* m, double* w, lapack_complex_double* z,
lapack_int* ldz, lapack_complex_double* work, double* rwork,
lapack_int* iwork, lapack_int* ifail, lapack_int *info );
void LAPACK_ssbev( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
float* ab, lapack_int* ldab, float* w, float* z,
lapack_int* ldz, float* work, lapack_int *info );
void LAPACK_dsbev( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
double* ab, lapack_int* ldab, double* w, double* z,
lapack_int* ldz, double* work, lapack_int *info );
void LAPACK_chbev( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
lapack_complex_float* ab, lapack_int* ldab, float* w,
lapack_complex_float* z, lapack_int* ldz,
lapack_complex_float* work, float* rwork, lapack_int *info );
void LAPACK_zhbev( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
lapack_complex_double* ab, lapack_int* ldab, double* w,
lapack_complex_double* z, lapack_int* ldz,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_ssbevd( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
float* ab, lapack_int* ldab, float* w, float* z,
lapack_int* ldz, float* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_dsbevd( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
double* ab, lapack_int* ldab, double* w, double* z,
lapack_int* ldz, double* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_chbevd( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
lapack_complex_float* ab, lapack_int* ldab, float* w,
lapack_complex_float* z, lapack_int* ldz,
lapack_complex_float* work, lapack_int* lwork, float* rwork,
lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
lapack_int *info );
void LAPACK_zhbevd( char* jobz, char* uplo, lapack_int* n, lapack_int* kd,
lapack_complex_double* ab, lapack_int* ldab, double* w,
lapack_complex_double* z, lapack_int* ldz,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_int* lrwork, lapack_int* iwork,
lapack_int* liwork, lapack_int *info );
void LAPACK_ssbevx( char* jobz, char* range, char* uplo, lapack_int* n,
lapack_int* kd, float* ab, lapack_int* ldab, float* q,
lapack_int* ldq, float* vl, float* vu, lapack_int* il,
lapack_int* iu, float* abstol, lapack_int* m, float* w,
float* z, lapack_int* ldz, float* work, lapack_int* iwork,
lapack_int* ifail, lapack_int *info );
void LAPACK_dsbevx( char* jobz, char* range, char* uplo, lapack_int* n,
lapack_int* kd, double* ab, lapack_int* ldab, double* q,
lapack_int* ldq, double* vl, double* vu, lapack_int* il,
lapack_int* iu, double* abstol, lapack_int* m, double* w,
double* z, lapack_int* ldz, double* work, lapack_int* iwork,
lapack_int* ifail, lapack_int *info );
void LAPACK_chbevx( char* jobz, char* range, char* uplo, lapack_int* n,
lapack_int* kd, lapack_complex_float* ab, lapack_int* ldab,
lapack_complex_float* q, lapack_int* ldq, float* vl,
float* vu, lapack_int* il, lapack_int* iu, float* abstol,
lapack_int* m, float* w, lapack_complex_float* z,
lapack_int* ldz, lapack_complex_float* work, float* rwork,
lapack_int* iwork, lapack_int* ifail, lapack_int *info );
void LAPACK_zhbevx( char* jobz, char* range, char* uplo, lapack_int* n,
lapack_int* kd, lapack_complex_double* ab, lapack_int* ldab,
lapack_complex_double* q, lapack_int* ldq, double* vl,
double* vu, lapack_int* il, lapack_int* iu, double* abstol,
lapack_int* m, double* w, lapack_complex_double* z,
lapack_int* ldz, lapack_complex_double* work, double* rwork,
lapack_int* iwork, lapack_int* ifail, lapack_int *info );
void LAPACK_sstev( char* jobz, lapack_int* n, float* d, float* e, float* z,
lapack_int* ldz, float* work, lapack_int *info );
void LAPACK_dstev( char* jobz, lapack_int* n, double* d, double* e, double* z,
lapack_int* ldz, double* work, lapack_int *info );
void LAPACK_sstevd( char* jobz, lapack_int* n, float* d, float* e, float* z,
lapack_int* ldz, float* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_dstevd( char* jobz, lapack_int* n, double* d, double* e, double* z,
lapack_int* ldz, double* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_sstevx( char* jobz, char* range, lapack_int* n, float* d, float* e,
float* vl, float* vu, lapack_int* il, lapack_int* iu,
float* abstol, lapack_int* m, float* w, float* z,
lapack_int* ldz, float* work, lapack_int* iwork,
lapack_int* ifail, lapack_int *info );
void LAPACK_dstevx( char* jobz, char* range, lapack_int* n, double* d,
double* e, double* vl, double* vu, lapack_int* il,
lapack_int* iu, double* abstol, lapack_int* m, double* w,
double* z, lapack_int* ldz, double* work, lapack_int* iwork,
lapack_int* ifail, lapack_int *info );
void LAPACK_sstevr( char* jobz, char* range, lapack_int* n, float* d, float* e,
float* vl, float* vu, lapack_int* il, lapack_int* iu,
float* abstol, lapack_int* m, float* w, float* z,
lapack_int* ldz, lapack_int* isuppz, float* work,
lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
lapack_int *info );
void LAPACK_dstevr( char* jobz, char* range, lapack_int* n, double* d,
double* e, double* vl, double* vu, lapack_int* il,
lapack_int* iu, double* abstol, lapack_int* m, double* w,
double* z, lapack_int* ldz, lapack_int* isuppz,
double* work, lapack_int* lwork, lapack_int* iwork,
lapack_int* liwork, lapack_int *info );
void LAPACK_sgees( char* jobvs, char* sort, LAPACK_S_SELECT2 select,
lapack_int* n, float* a, lapack_int* lda, lapack_int* sdim,
float* wr, float* wi, float* vs, lapack_int* ldvs,
float* work, lapack_int* lwork, lapack_logical* bwork,
lapack_int *info );
void LAPACK_dgees( char* jobvs, char* sort, LAPACK_D_SELECT2 select,
lapack_int* n, double* a, lapack_int* lda, lapack_int* sdim,
double* wr, double* wi, double* vs, lapack_int* ldvs,
double* work, lapack_int* lwork, lapack_logical* bwork,
lapack_int *info );
void LAPACK_cgees( char* jobvs, char* sort, LAPACK_C_SELECT1 select,
lapack_int* n, lapack_complex_float* a, lapack_int* lda,
lapack_int* sdim, lapack_complex_float* w,
lapack_complex_float* vs, lapack_int* ldvs,
lapack_complex_float* work, lapack_int* lwork, float* rwork,
lapack_logical* bwork, lapack_int *info );
void LAPACK_zgees( char* jobvs, char* sort, LAPACK_Z_SELECT1 select,
lapack_int* n, lapack_complex_double* a, lapack_int* lda,
lapack_int* sdim, lapack_complex_double* w,
lapack_complex_double* vs, lapack_int* ldvs,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_logical* bwork, lapack_int *info );
void LAPACK_sgeesx( char* jobvs, char* sort, LAPACK_S_SELECT2 select,
char* sense, lapack_int* n, float* a, lapack_int* lda,
lapack_int* sdim, float* wr, float* wi, float* vs,
lapack_int* ldvs, float* rconde, float* rcondv, float* work,
lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
lapack_logical* bwork, lapack_int *info );
void LAPACK_dgeesx( char* jobvs, char* sort, LAPACK_D_SELECT2 select,
char* sense, lapack_int* n, double* a, lapack_int* lda,
lapack_int* sdim, double* wr, double* wi, double* vs,
lapack_int* ldvs, double* rconde, double* rcondv,
double* work, lapack_int* lwork, lapack_int* iwork,
lapack_int* liwork, lapack_logical* bwork,
lapack_int *info );
void LAPACK_cgeesx( char* jobvs, char* sort, LAPACK_C_SELECT1 select,
char* sense, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_int* sdim, lapack_complex_float* w,
lapack_complex_float* vs, lapack_int* ldvs, float* rconde,
float* rcondv, lapack_complex_float* work,
lapack_int* lwork, float* rwork, lapack_logical* bwork,
lapack_int *info );
void LAPACK_zgeesx( char* jobvs, char* sort, LAPACK_Z_SELECT1 select,
char* sense, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_int* sdim, lapack_complex_double* w,
lapack_complex_double* vs, lapack_int* ldvs, double* rconde,
double* rcondv, lapack_complex_double* work,
lapack_int* lwork, double* rwork, lapack_logical* bwork,
lapack_int *info );
void LAPACK_sgeev( char* jobvl, char* jobvr, lapack_int* n, float* a,
lapack_int* lda, float* wr, float* wi, float* vl,
lapack_int* ldvl, float* vr, lapack_int* ldvr, float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_dgeev( char* jobvl, char* jobvr, lapack_int* n, double* a,
lapack_int* lda, double* wr, double* wi, double* vl,
lapack_int* ldvl, double* vr, lapack_int* ldvr, double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_cgeev( char* jobvl, char* jobvr, lapack_int* n,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* w, lapack_complex_float* vl,
lapack_int* ldvl, lapack_complex_float* vr, lapack_int* ldvr,
lapack_complex_float* work, lapack_int* lwork, float* rwork,
lapack_int *info );
void LAPACK_zgeev( char* jobvl, char* jobvr, lapack_int* n,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* w, lapack_complex_double* vl,
lapack_int* ldvl, lapack_complex_double* vr,
lapack_int* ldvr, lapack_complex_double* work,
lapack_int* lwork, double* rwork, lapack_int *info );
void LAPACK_sgeevx( char* balanc, char* jobvl, char* jobvr, char* sense,
lapack_int* n, float* a, lapack_int* lda, float* wr,
float* wi, float* vl, lapack_int* ldvl, float* vr,
lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi,
float* scale, float* abnrm, float* rconde, float* rcondv,
float* work, lapack_int* lwork, lapack_int* iwork,
lapack_int *info );
void LAPACK_dgeevx( char* balanc, char* jobvl, char* jobvr, char* sense,
lapack_int* n, double* a, lapack_int* lda, double* wr,
double* wi, double* vl, lapack_int* ldvl, double* vr,
lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi,
double* scale, double* abnrm, double* rconde,
double* rcondv, double* work, lapack_int* lwork,
lapack_int* iwork, lapack_int *info );
void LAPACK_cgeevx( char* balanc, char* jobvl, char* jobvr, char* sense,
lapack_int* n, lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* w, lapack_complex_float* vl,
lapack_int* ldvl, lapack_complex_float* vr,
lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi,
float* scale, float* abnrm, float* rconde, float* rcondv,
lapack_complex_float* work, lapack_int* lwork, float* rwork,
lapack_int *info );
void LAPACK_zgeevx( char* balanc, char* jobvl, char* jobvr, char* sense,
lapack_int* n, lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* w, lapack_complex_double* vl,
lapack_int* ldvl, lapack_complex_double* vr,
lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi,
double* scale, double* abnrm, double* rconde,
double* rcondv, lapack_complex_double* work,
lapack_int* lwork, double* rwork, lapack_int *info );
void LAPACK_sgesvd( char* jobu, char* jobvt, lapack_int* m, lapack_int* n,
float* a, lapack_int* lda, float* s, float* u,
lapack_int* ldu, float* vt, lapack_int* ldvt, float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_dgesvd( char* jobu, char* jobvt, lapack_int* m, lapack_int* n,
double* a, lapack_int* lda, double* s, double* u,
lapack_int* ldu, double* vt, lapack_int* ldvt, double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_cgesvd( char* jobu, char* jobvt, lapack_int* m, lapack_int* n,
lapack_complex_float* a, lapack_int* lda, float* s,
lapack_complex_float* u, lapack_int* ldu,
lapack_complex_float* vt, lapack_int* ldvt,
lapack_complex_float* work, lapack_int* lwork, float* rwork,
lapack_int *info );
void LAPACK_zgesvd( char* jobu, char* jobvt, lapack_int* m, lapack_int* n,
lapack_complex_double* a, lapack_int* lda, double* s,
lapack_complex_double* u, lapack_int* ldu,
lapack_complex_double* vt, lapack_int* ldvt,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_int *info );
void LAPACK_sgesdd( char* jobz, lapack_int* m, lapack_int* n, float* a,
lapack_int* lda, float* s, float* u, lapack_int* ldu,
float* vt, lapack_int* ldvt, float* work, lapack_int* lwork,
lapack_int* iwork, lapack_int *info );
void LAPACK_dgesdd( char* jobz, lapack_int* m, lapack_int* n, double* a,
lapack_int* lda, double* s, double* u, lapack_int* ldu,
double* vt, lapack_int* ldvt, double* work,
lapack_int* lwork, lapack_int* iwork, lapack_int *info );
void LAPACK_cgesdd( char* jobz, lapack_int* m, lapack_int* n,
lapack_complex_float* a, lapack_int* lda, float* s,
lapack_complex_float* u, lapack_int* ldu,
lapack_complex_float* vt, lapack_int* ldvt,
lapack_complex_float* work, lapack_int* lwork, float* rwork,
lapack_int* iwork, lapack_int *info );
void LAPACK_zgesdd( char* jobz, lapack_int* m, lapack_int* n,
lapack_complex_double* a, lapack_int* lda, double* s,
lapack_complex_double* u, lapack_int* ldu,
lapack_complex_double* vt, lapack_int* ldvt,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_int* iwork, lapack_int *info );
void LAPACK_dgejsv( char* joba, char* jobu, char* jobv, char* jobr, char* jobt,
char* jobp, lapack_int* m, lapack_int* n, double* a,
lapack_int* lda, double* sva, double* u, lapack_int* ldu,
double* v, lapack_int* ldv, double* work, lapack_int* lwork,
lapack_int* iwork, lapack_int *info );
void LAPACK_sgejsv( char* joba, char* jobu, char* jobv, char* jobr, char* jobt,
char* jobp, lapack_int* m, lapack_int* n, float* a,
lapack_int* lda, float* sva, float* u, lapack_int* ldu,
float* v, lapack_int* ldv, float* work, lapack_int* lwork,
lapack_int* iwork, lapack_int *info );
void LAPACK_dgesvj( char* joba, char* jobu, char* jobv, lapack_int* m,
lapack_int* n, double* a, lapack_int* lda, double* sva,
lapack_int* mv, double* v, lapack_int* ldv, double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_sgesvj( char* joba, char* jobu, char* jobv, lapack_int* m,
lapack_int* n, float* a, lapack_int* lda, float* sva,
lapack_int* mv, float* v, lapack_int* ldv, float* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_sggsvd( char* jobu, char* jobv, char* jobq, lapack_int* m,
lapack_int* n, lapack_int* p, lapack_int* k, lapack_int* l,
float* a, lapack_int* lda, float* b, lapack_int* ldb,
float* alpha, float* beta, float* u, lapack_int* ldu,
float* v, lapack_int* ldv, float* q, lapack_int* ldq,
float* work, lapack_int* iwork, lapack_int *info );
void LAPACK_dggsvd( char* jobu, char* jobv, char* jobq, lapack_int* m,
lapack_int* n, lapack_int* p, lapack_int* k, lapack_int* l,
double* a, lapack_int* lda, double* b, lapack_int* ldb,
double* alpha, double* beta, double* u, lapack_int* ldu,
double* v, lapack_int* ldv, double* q, lapack_int* ldq,
double* work, lapack_int* iwork, lapack_int *info );
void LAPACK_cggsvd( char* jobu, char* jobv, char* jobq, lapack_int* m,
lapack_int* n, lapack_int* p, lapack_int* k, lapack_int* l,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb, float* alpha,
float* beta, lapack_complex_float* u, lapack_int* ldu,
lapack_complex_float* v, lapack_int* ldv,
lapack_complex_float* q, lapack_int* ldq,
lapack_complex_float* work, float* rwork, lapack_int* iwork,
lapack_int *info );
void LAPACK_zggsvd( char* jobu, char* jobv, char* jobq, lapack_int* m,
lapack_int* n, lapack_int* p, lapack_int* k, lapack_int* l,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb, double* alpha,
double* beta, lapack_complex_double* u, lapack_int* ldu,
lapack_complex_double* v, lapack_int* ldv,
lapack_complex_double* q, lapack_int* ldq,
lapack_complex_double* work, double* rwork,
lapack_int* iwork, lapack_int *info );
void LAPACK_ssygv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
float* a, lapack_int* lda, float* b, lapack_int* ldb,
float* w, float* work, lapack_int* lwork, lapack_int *info );
void LAPACK_dsygv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
double* a, lapack_int* lda, double* b, lapack_int* ldb,
double* w, double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_chegv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb, float* w,
lapack_complex_float* work, lapack_int* lwork, float* rwork,
lapack_int *info );
void LAPACK_zhegv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb, double* w,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_int *info );
void LAPACK_ssygvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
float* a, lapack_int* lda, float* b, lapack_int* ldb,
float* w, float* work, lapack_int* lwork, lapack_int* iwork,
lapack_int* liwork, lapack_int *info );
void LAPACK_dsygvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
double* a, lapack_int* lda, double* b, lapack_int* ldb,
double* w, double* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_chegvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb, float* w,
lapack_complex_float* work, lapack_int* lwork, float* rwork,
lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
lapack_int *info );
void LAPACK_zhegvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb, double* w,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_int* lrwork, lapack_int* iwork,
lapack_int* liwork, lapack_int *info );
void LAPACK_ssygvx( lapack_int* itype, char* jobz, char* range, char* uplo,
lapack_int* n, float* a, lapack_int* lda, float* b,
lapack_int* ldb, float* vl, float* vu, lapack_int* il,
lapack_int* iu, float* abstol, lapack_int* m, float* w,
float* z, lapack_int* ldz, float* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* ifail, lapack_int *info );
void LAPACK_dsygvx( lapack_int* itype, char* jobz, char* range, char* uplo,
lapack_int* n, double* a, lapack_int* lda, double* b,
lapack_int* ldb, double* vl, double* vu, lapack_int* il,
lapack_int* iu, double* abstol, lapack_int* m, double* w,
double* z, lapack_int* ldz, double* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* ifail, lapack_int *info );
void LAPACK_chegvx( lapack_int* itype, char* jobz, char* range, char* uplo,
lapack_int* n, lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb, float* vl,
float* vu, lapack_int* il, lapack_int* iu, float* abstol,
lapack_int* m, float* w, lapack_complex_float* z,
lapack_int* ldz, lapack_complex_float* work,
lapack_int* lwork, float* rwork, lapack_int* iwork,
lapack_int* ifail, lapack_int *info );
void LAPACK_zhegvx( lapack_int* itype, char* jobz, char* range, char* uplo,
lapack_int* n, lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb, double* vl,
double* vu, lapack_int* il, lapack_int* iu, double* abstol,
lapack_int* m, double* w, lapack_complex_double* z,
lapack_int* ldz, lapack_complex_double* work,
lapack_int* lwork, double* rwork, lapack_int* iwork,
lapack_int* ifail, lapack_int *info );
void LAPACK_sspgv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
float* ap, float* bp, float* w, float* z, lapack_int* ldz,
float* work, lapack_int *info );
void LAPACK_dspgv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
double* ap, double* bp, double* w, double* z,
lapack_int* ldz, double* work, lapack_int *info );
void LAPACK_chpgv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
lapack_complex_float* ap, lapack_complex_float* bp, float* w,
lapack_complex_float* z, lapack_int* ldz,
lapack_complex_float* work, float* rwork, lapack_int *info );
void LAPACK_zhpgv( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
lapack_complex_double* ap, lapack_complex_double* bp,
double* w, lapack_complex_double* z, lapack_int* ldz,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_sspgvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
float* ap, float* bp, float* w, float* z, lapack_int* ldz,
float* work, lapack_int* lwork, lapack_int* iwork,
lapack_int* liwork, lapack_int *info );
void LAPACK_dspgvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
double* ap, double* bp, double* w, double* z,
lapack_int* ldz, double* work, lapack_int* lwork,
lapack_int* iwork, lapack_int* liwork, lapack_int *info );
void LAPACK_chpgvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
lapack_complex_float* ap, lapack_complex_float* bp,
float* w, lapack_complex_float* z, lapack_int* ldz,
lapack_complex_float* work, lapack_int* lwork, float* rwork,
lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
lapack_int *info );
void LAPACK_zhpgvd( lapack_int* itype, char* jobz, char* uplo, lapack_int* n,
lapack_complex_double* ap, lapack_complex_double* bp,
double* w, lapack_complex_double* z, lapack_int* ldz,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_int* lrwork, lapack_int* iwork,
lapack_int* liwork, lapack_int *info );
void LAPACK_sspgvx( lapack_int* itype, char* jobz, char* range, char* uplo,
lapack_int* n, float* ap, float* bp, float* vl, float* vu,
lapack_int* il, lapack_int* iu, float* abstol,
lapack_int* m, float* w, float* z, lapack_int* ldz,
float* work, lapack_int* iwork, lapack_int* ifail,
lapack_int *info );
void LAPACK_dspgvx( lapack_int* itype, char* jobz, char* range, char* uplo,
lapack_int* n, double* ap, double* bp, double* vl,
double* vu, lapack_int* il, lapack_int* iu, double* abstol,
lapack_int* m, double* w, double* z, lapack_int* ldz,
double* work, lapack_int* iwork, lapack_int* ifail,
lapack_int *info );
void LAPACK_chpgvx( lapack_int* itype, char* jobz, char* range, char* uplo,
lapack_int* n, lapack_complex_float* ap,
lapack_complex_float* bp, float* vl, float* vu,
lapack_int* il, lapack_int* iu, float* abstol,
lapack_int* m, float* w, lapack_complex_float* z,
lapack_int* ldz, lapack_complex_float* work, float* rwork,
lapack_int* iwork, lapack_int* ifail, lapack_int *info );
void LAPACK_zhpgvx( lapack_int* itype, char* jobz, char* range, char* uplo,
lapack_int* n, lapack_complex_double* ap,
lapack_complex_double* bp, double* vl, double* vu,
lapack_int* il, lapack_int* iu, double* abstol,
lapack_int* m, double* w, lapack_complex_double* z,
lapack_int* ldz, lapack_complex_double* work, double* rwork,
lapack_int* iwork, lapack_int* ifail, lapack_int *info );
void LAPACK_ssbgv( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
lapack_int* kb, float* ab, lapack_int* ldab, float* bb,
lapack_int* ldbb, float* w, float* z, lapack_int* ldz,
float* work, lapack_int *info );
void LAPACK_dsbgv( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
lapack_int* kb, double* ab, lapack_int* ldab, double* bb,
lapack_int* ldbb, double* w, double* z, lapack_int* ldz,
double* work, lapack_int *info );
void LAPACK_chbgv( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
lapack_int* kb, lapack_complex_float* ab, lapack_int* ldab,
lapack_complex_float* bb, lapack_int* ldbb, float* w,
lapack_complex_float* z, lapack_int* ldz,
lapack_complex_float* work, float* rwork, lapack_int *info );
void LAPACK_zhbgv( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
lapack_int* kb, lapack_complex_double* ab, lapack_int* ldab,
lapack_complex_double* bb, lapack_int* ldbb, double* w,
lapack_complex_double* z, lapack_int* ldz,
lapack_complex_double* work, double* rwork,
lapack_int *info );
void LAPACK_ssbgvd( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
lapack_int* kb, float* ab, lapack_int* ldab, float* bb,
lapack_int* ldbb, float* w, float* z, lapack_int* ldz,
float* work, lapack_int* lwork, lapack_int* iwork,
lapack_int* liwork, lapack_int *info );
void LAPACK_dsbgvd( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
lapack_int* kb, double* ab, lapack_int* ldab, double* bb,
lapack_int* ldbb, double* w, double* z, lapack_int* ldz,
double* work, lapack_int* lwork, lapack_int* iwork,
lapack_int* liwork, lapack_int *info );
void LAPACK_chbgvd( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
lapack_int* kb, lapack_complex_float* ab, lapack_int* ldab,
lapack_complex_float* bb, lapack_int* ldbb, float* w,
lapack_complex_float* z, lapack_int* ldz,
lapack_complex_float* work, lapack_int* lwork, float* rwork,
lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
lapack_int *info );
void LAPACK_zhbgvd( char* jobz, char* uplo, lapack_int* n, lapack_int* ka,
lapack_int* kb, lapack_complex_double* ab, lapack_int* ldab,
lapack_complex_double* bb, lapack_int* ldbb, double* w,
lapack_complex_double* z, lapack_int* ldz,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_int* lrwork, lapack_int* iwork,
lapack_int* liwork, lapack_int *info );
void LAPACK_ssbgvx( char* jobz, char* range, char* uplo, lapack_int* n,
lapack_int* ka, lapack_int* kb, float* ab, lapack_int* ldab,
float* bb, lapack_int* ldbb, float* q, lapack_int* ldq,
float* vl, float* vu, lapack_int* il, lapack_int* iu,
float* abstol, lapack_int* m, float* w, float* z,
lapack_int* ldz, float* work, lapack_int* iwork,
lapack_int* ifail, lapack_int *info );
void LAPACK_dsbgvx( char* jobz, char* range, char* uplo, lapack_int* n,
lapack_int* ka, lapack_int* kb, double* ab,
lapack_int* ldab, double* bb, lapack_int* ldbb, double* q,
lapack_int* ldq, double* vl, double* vu, lapack_int* il,
lapack_int* iu, double* abstol, lapack_int* m, double* w,
double* z, lapack_int* ldz, double* work, lapack_int* iwork,
lapack_int* ifail, lapack_int *info );
void LAPACK_chbgvx( char* jobz, char* range, char* uplo, lapack_int* n,
lapack_int* ka, lapack_int* kb, lapack_complex_float* ab,
lapack_int* ldab, lapack_complex_float* bb,
lapack_int* ldbb, lapack_complex_float* q, lapack_int* ldq,
float* vl, float* vu, lapack_int* il, lapack_int* iu,
float* abstol, lapack_int* m, float* w,
lapack_complex_float* z, lapack_int* ldz,
lapack_complex_float* work, float* rwork, lapack_int* iwork,
lapack_int* ifail, lapack_int *info );
void LAPACK_zhbgvx( char* jobz, char* range, char* uplo, lapack_int* n,
lapack_int* ka, lapack_int* kb, lapack_complex_double* ab,
lapack_int* ldab, lapack_complex_double* bb,
lapack_int* ldbb, lapack_complex_double* q, lapack_int* ldq,
double* vl, double* vu, lapack_int* il, lapack_int* iu,
double* abstol, lapack_int* m, double* w,
lapack_complex_double* z, lapack_int* ldz,
lapack_complex_double* work, double* rwork,
lapack_int* iwork, lapack_int* ifail, lapack_int *info );
void LAPACK_sgges( char* jobvsl, char* jobvsr, char* sort,
LAPACK_S_SELECT3 selctg, lapack_int* n, float* a,
lapack_int* lda, float* b, lapack_int* ldb, lapack_int* sdim,
float* alphar, float* alphai, float* beta, float* vsl,
lapack_int* ldvsl, float* vsr, lapack_int* ldvsr,
float* work, lapack_int* lwork, lapack_logical* bwork,
lapack_int *info );
void LAPACK_dgges( char* jobvsl, char* jobvsr, char* sort,
LAPACK_D_SELECT3 selctg, lapack_int* n, double* a,
lapack_int* lda, double* b, lapack_int* ldb,
lapack_int* sdim, double* alphar, double* alphai,
double* beta, double* vsl, lapack_int* ldvsl, double* vsr,
lapack_int* ldvsr, double* work, lapack_int* lwork,
lapack_logical* bwork, lapack_int *info );
void LAPACK_cgges( char* jobvsl, char* jobvsr, char* sort,
LAPACK_C_SELECT2 selctg, lapack_int* n,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb, lapack_int* sdim,
lapack_complex_float* alpha, lapack_complex_float* beta,
lapack_complex_float* vsl, lapack_int* ldvsl,
lapack_complex_float* vsr, lapack_int* ldvsr,
lapack_complex_float* work, lapack_int* lwork, float* rwork,
lapack_logical* bwork, lapack_int *info );
void LAPACK_zgges( char* jobvsl, char* jobvsr, char* sort,
LAPACK_Z_SELECT2 selctg, lapack_int* n,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb, lapack_int* sdim,
lapack_complex_double* alpha, lapack_complex_double* beta,
lapack_complex_double* vsl, lapack_int* ldvsl,
lapack_complex_double* vsr, lapack_int* ldvsr,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_logical* bwork, lapack_int *info );
void LAPACK_sggesx( char* jobvsl, char* jobvsr, char* sort,
LAPACK_S_SELECT3 selctg, char* sense, lapack_int* n,
float* a, lapack_int* lda, float* b, lapack_int* ldb,
lapack_int* sdim, float* alphar, float* alphai, float* beta,
float* vsl, lapack_int* ldvsl, float* vsr,
lapack_int* ldvsr, float* rconde, float* rcondv,
float* work, lapack_int* lwork, lapack_int* iwork,
lapack_int* liwork, lapack_logical* bwork,
lapack_int *info );
void LAPACK_dggesx( char* jobvsl, char* jobvsr, char* sort,
LAPACK_D_SELECT3 selctg, char* sense, lapack_int* n,
double* a, lapack_int* lda, double* b, lapack_int* ldb,
lapack_int* sdim, double* alphar, double* alphai,
double* beta, double* vsl, lapack_int* ldvsl, double* vsr,
lapack_int* ldvsr, double* rconde, double* rcondv,
double* work, lapack_int* lwork, lapack_int* iwork,
lapack_int* liwork, lapack_logical* bwork,
lapack_int *info );
void LAPACK_cggesx( char* jobvsl, char* jobvsr, char* sort,
LAPACK_C_SELECT2 selctg, char* sense, lapack_int* n,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb, lapack_int* sdim,
lapack_complex_float* alpha, lapack_complex_float* beta,
lapack_complex_float* vsl, lapack_int* ldvsl,
lapack_complex_float* vsr, lapack_int* ldvsr, float* rconde,
float* rcondv, lapack_complex_float* work,
lapack_int* lwork, float* rwork, lapack_int* iwork,
lapack_int* liwork, lapack_logical* bwork,
lapack_int *info );
void LAPACK_zggesx( char* jobvsl, char* jobvsr, char* sort,
LAPACK_Z_SELECT2 selctg, char* sense, lapack_int* n,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb, lapack_int* sdim,
lapack_complex_double* alpha, lapack_complex_double* beta,
lapack_complex_double* vsl, lapack_int* ldvsl,
lapack_complex_double* vsr, lapack_int* ldvsr,
double* rconde, double* rcondv, lapack_complex_double* work,
lapack_int* lwork, double* rwork, lapack_int* iwork,
lapack_int* liwork, lapack_logical* bwork,
lapack_int *info );
void LAPACK_sggev( char* jobvl, char* jobvr, lapack_int* n, float* a,
lapack_int* lda, float* b, lapack_int* ldb, float* alphar,
float* alphai, float* beta, float* vl, lapack_int* ldvl,
float* vr, lapack_int* ldvr, float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_dggev( char* jobvl, char* jobvr, lapack_int* n, double* a,
lapack_int* lda, double* b, lapack_int* ldb, double* alphar,
double* alphai, double* beta, double* vl, lapack_int* ldvl,
double* vr, lapack_int* ldvr, double* work,
lapack_int* lwork, lapack_int *info );
void LAPACK_cggev( char* jobvl, char* jobvr, lapack_int* n,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* alpha, lapack_complex_float* beta,
lapack_complex_float* vl, lapack_int* ldvl,
lapack_complex_float* vr, lapack_int* ldvr,
lapack_complex_float* work, lapack_int* lwork, float* rwork,
lapack_int *info );
void LAPACK_zggev( char* jobvl, char* jobvr, lapack_int* n,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* alpha, lapack_complex_double* beta,
lapack_complex_double* vl, lapack_int* ldvl,
lapack_complex_double* vr, lapack_int* ldvr,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_int *info );
void LAPACK_sggevx( char* balanc, char* jobvl, char* jobvr, char* sense,
lapack_int* n, float* a, lapack_int* lda, float* b,
lapack_int* ldb, float* alphar, float* alphai, float* beta,
float* vl, lapack_int* ldvl, float* vr, lapack_int* ldvr,
lapack_int* ilo, lapack_int* ihi, float* lscale,
float* rscale, float* abnrm, float* bbnrm, float* rconde,
float* rcondv, float* work, lapack_int* lwork,
lapack_int* iwork, lapack_logical* bwork,
lapack_int *info );
void LAPACK_dggevx( char* balanc, char* jobvl, char* jobvr, char* sense,
lapack_int* n, double* a, lapack_int* lda, double* b,
lapack_int* ldb, double* alphar, double* alphai,
double* beta, double* vl, lapack_int* ldvl, double* vr,
lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi,
double* lscale, double* rscale, double* abnrm,
double* bbnrm, double* rconde, double* rcondv, double* work,
lapack_int* lwork, lapack_int* iwork, lapack_logical* bwork,
lapack_int *info );
void LAPACK_cggevx( char* balanc, char* jobvl, char* jobvr, char* sense,
lapack_int* n, lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* alpha, lapack_complex_float* beta,
lapack_complex_float* vl, lapack_int* ldvl,
lapack_complex_float* vr, lapack_int* ldvr, lapack_int* ilo,
lapack_int* ihi, float* lscale, float* rscale, float* abnrm,
float* bbnrm, float* rconde, float* rcondv,
lapack_complex_float* work, lapack_int* lwork, float* rwork,
lapack_int* iwork, lapack_logical* bwork,
lapack_int *info );
void LAPACK_zggevx( char* balanc, char* jobvl, char* jobvr, char* sense,
lapack_int* n, lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* alpha, lapack_complex_double* beta,
lapack_complex_double* vl, lapack_int* ldvl,
lapack_complex_double* vr, lapack_int* ldvr,
lapack_int* ilo, lapack_int* ihi, double* lscale,
double* rscale, double* abnrm, double* bbnrm,
double* rconde, double* rcondv, lapack_complex_double* work,
lapack_int* lwork, double* rwork, lapack_int* iwork,
lapack_logical* bwork, lapack_int *info );
void LAPACK_dsfrk( char* transr, char* uplo, char* trans, lapack_int* n,
lapack_int* k, double* alpha, const double* a,
lapack_int* lda, double* beta, double* c );
void LAPACK_ssfrk( char* transr, char* uplo, char* trans, lapack_int* n,
lapack_int* k, float* alpha, const float* a, lapack_int* lda,
float* beta, float* c );
void LAPACK_zhfrk( char* transr, char* uplo, char* trans, lapack_int* n,
lapack_int* k, double* alpha, const lapack_complex_double* a,
lapack_int* lda, double* beta, lapack_complex_double* c );
void LAPACK_chfrk( char* transr, char* uplo, char* trans, lapack_int* n,
lapack_int* k, float* alpha, const lapack_complex_float* a,
lapack_int* lda, float* beta, lapack_complex_float* c );
void LAPACK_dtfsm( char* transr, char* side, char* uplo, char* trans,
char* diag, lapack_int* m, lapack_int* n, double* alpha,
const double* a, double* b, lapack_int* ldb );
void LAPACK_stfsm( char* transr, char* side, char* uplo, char* trans,
char* diag, lapack_int* m, lapack_int* n, float* alpha,
const float* a, float* b, lapack_int* ldb );
void LAPACK_ztfsm( char* transr, char* side, char* uplo, char* trans,
char* diag, lapack_int* m, lapack_int* n,
lapack_complex_double* alpha, const lapack_complex_double* a,
lapack_complex_double* b, lapack_int* ldb );
void LAPACK_ctfsm( char* transr, char* side, char* uplo, char* trans,
char* diag, lapack_int* m, lapack_int* n,
lapack_complex_float* alpha, const lapack_complex_float* a,
lapack_complex_float* b, lapack_int* ldb );
void LAPACK_dtfttp( char* transr, char* uplo, lapack_int* n, const double* arf,
double* ap, lapack_int *info );
void LAPACK_stfttp( char* transr, char* uplo, lapack_int* n, const float* arf,
float* ap, lapack_int *info );
void LAPACK_ztfttp( char* transr, char* uplo, lapack_int* n,
const lapack_complex_double* arf, lapack_complex_double* ap,
lapack_int *info );
void LAPACK_ctfttp( char* transr, char* uplo, lapack_int* n,
const lapack_complex_float* arf, lapack_complex_float* ap,
lapack_int *info );
void LAPACK_dtfttr( char* transr, char* uplo, lapack_int* n, const double* arf,
double* a, lapack_int* lda, lapack_int *info );
void LAPACK_stfttr( char* transr, char* uplo, lapack_int* n, const float* arf,
float* a, lapack_int* lda, lapack_int *info );
void LAPACK_ztfttr( char* transr, char* uplo, lapack_int* n,
const lapack_complex_double* arf, lapack_complex_double* a,
lapack_int* lda, lapack_int *info );
void LAPACK_ctfttr( char* transr, char* uplo, lapack_int* n,
const lapack_complex_float* arf, lapack_complex_float* a,
lapack_int* lda, lapack_int *info );
void LAPACK_dtpttf( char* transr, char* uplo, lapack_int* n, const double* ap,
double* arf, lapack_int *info );
void LAPACK_stpttf( char* transr, char* uplo, lapack_int* n, const float* ap,
float* arf, lapack_int *info );
void LAPACK_ztpttf( char* transr, char* uplo, lapack_int* n,
const lapack_complex_double* ap, lapack_complex_double* arf,
lapack_int *info );
void LAPACK_ctpttf( char* transr, char* uplo, lapack_int* n,
const lapack_complex_float* ap, lapack_complex_float* arf,
lapack_int *info );
void LAPACK_dtpttr( char* uplo, lapack_int* n, const double* ap, double* a,
lapack_int* lda, lapack_int *info );
void LAPACK_stpttr( char* uplo, lapack_int* n, const float* ap, float* a,
lapack_int* lda, lapack_int *info );
void LAPACK_ztpttr( char* uplo, lapack_int* n, const lapack_complex_double* ap,
lapack_complex_double* a, lapack_int* lda,
lapack_int *info );
void LAPACK_ctpttr( char* uplo, lapack_int* n, const lapack_complex_float* ap,
lapack_complex_float* a, lapack_int* lda,
lapack_int *info );
void LAPACK_dtrttf( char* transr, char* uplo, lapack_int* n, const double* a,
lapack_int* lda, double* arf, lapack_int *info );
void LAPACK_strttf( char* transr, char* uplo, lapack_int* n, const float* a,
lapack_int* lda, float* arf, lapack_int *info );
void LAPACK_ztrttf( char* transr, char* uplo, lapack_int* n,
const lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* arf, lapack_int *info );
void LAPACK_ctrttf( char* transr, char* uplo, lapack_int* n,
const lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* arf, lapack_int *info );
void LAPACK_dtrttp( char* uplo, lapack_int* n, const double* a, lapack_int* lda,
double* ap, lapack_int *info );
void LAPACK_strttp( char* uplo, lapack_int* n, const float* a, lapack_int* lda,
float* ap, lapack_int *info );
void LAPACK_ztrttp( char* uplo, lapack_int* n, const lapack_complex_double* a,
lapack_int* lda, lapack_complex_double* ap,
lapack_int *info );
void LAPACK_ctrttp( char* uplo, lapack_int* n, const lapack_complex_float* a,
lapack_int* lda, lapack_complex_float* ap,
lapack_int *info );
void LAPACK_sgeqrfp( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
float* tau, float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_dgeqrfp( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
double* tau, double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_cgeqrfp( lapack_int* m, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_complex_float* tau,
lapack_complex_float* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_zgeqrfp( lapack_int* m, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_complex_double* tau,
lapack_complex_double* work, lapack_int* lwork,
lapack_int *info );
void LAPACK_clacgv( lapack_int* n, lapack_complex_float* x, lapack_int* incx );
void LAPACK_zlacgv( lapack_int* n, lapack_complex_double* x, lapack_int* incx );
void LAPACK_slarnv( lapack_int* idist, lapack_int* iseed, lapack_int* n,
float* x );
void LAPACK_dlarnv( lapack_int* idist, lapack_int* iseed, lapack_int* n,
double* x );
void LAPACK_clarnv( lapack_int* idist, lapack_int* iseed, lapack_int* n,
lapack_complex_float* x );
void LAPACK_zlarnv( lapack_int* idist, lapack_int* iseed, lapack_int* n,
lapack_complex_double* x );
void LAPACK_sgeqr2( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
float* tau, float* work, lapack_int *info );
void LAPACK_dgeqr2( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
double* tau, double* work, lapack_int *info );
void LAPACK_cgeqr2( lapack_int* m, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_complex_float* tau,
lapack_complex_float* work, lapack_int *info );
void LAPACK_zgeqr2( lapack_int* m, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_complex_double* tau,
lapack_complex_double* work, lapack_int *info );
void LAPACK_slacpy( char* uplo, lapack_int* m, lapack_int* n, const float* a,
lapack_int* lda, float* b, lapack_int* ldb );
void LAPACK_dlacpy( char* uplo, lapack_int* m, lapack_int* n, const double* a,
lapack_int* lda, double* b, lapack_int* ldb );
void LAPACK_clacpy( char* uplo, lapack_int* m, lapack_int* n,
const lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb );
void LAPACK_zlacpy( char* uplo, lapack_int* m, lapack_int* n,
const lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb );
void LAPACK_sgetf2( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
lapack_int* ipiv, lapack_int *info );
void LAPACK_dgetf2( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
lapack_int* ipiv, lapack_int *info );
void LAPACK_cgetf2( lapack_int* m, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_int* ipiv, lapack_int *info );
void LAPACK_zgetf2( lapack_int* m, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_int* ipiv, lapack_int *info );
void LAPACK_slaswp( lapack_int* n, float* a, lapack_int* lda, lapack_int* k1,
lapack_int* k2, const lapack_int* ipiv, lapack_int* incx );
void LAPACK_dlaswp( lapack_int* n, double* a, lapack_int* lda, lapack_int* k1,
lapack_int* k2, const lapack_int* ipiv, lapack_int* incx );
void LAPACK_claswp( lapack_int* n, lapack_complex_float* a, lapack_int* lda,
lapack_int* k1, lapack_int* k2, const lapack_int* ipiv,
lapack_int* incx );
void LAPACK_zlaswp( lapack_int* n, lapack_complex_double* a, lapack_int* lda,
lapack_int* k1, lapack_int* k2, const lapack_int* ipiv,
lapack_int* incx );
float LAPACK_slange( char* norm, lapack_int* m, lapack_int* n, const float* a,
lapack_int* lda, float* work );
double LAPACK_dlange( char* norm, lapack_int* m, lapack_int* n, const double* a,
lapack_int* lda, double* work );
float LAPACK_clange( char* norm, lapack_int* m, lapack_int* n,
const lapack_complex_float* a, lapack_int* lda, float* work );
double LAPACK_zlange( char* norm, lapack_int* m, lapack_int* n,
const lapack_complex_double* a, lapack_int* lda, double* work );
float LAPACK_clanhe( char* norm, char* uplo, lapack_int* n,
const lapack_complex_float* a, lapack_int* lda, float* work );
double LAPACK_zlanhe( char* norm, char* uplo, lapack_int* n,
const lapack_complex_double* a, lapack_int* lda, double* work );
float LAPACK_slansy( char* norm, char* uplo, lapack_int* n, const float* a,
lapack_int* lda, float* work );
double LAPACK_dlansy( char* norm, char* uplo, lapack_int* n, const double* a,
lapack_int* lda, double* work );
float LAPACK_clansy( char* norm, char* uplo, lapack_int* n,
const lapack_complex_float* a, lapack_int* lda, float* work );
double LAPACK_zlansy( char* norm, char* uplo, lapack_int* n,
const lapack_complex_double* a, lapack_int* lda, double* work );
float LAPACK_slantr( char* norm, char* uplo, char* diag, lapack_int* m,
lapack_int* n, const float* a, lapack_int* lda, float* work );
double LAPACK_dlantr( char* norm, char* uplo, char* diag, lapack_int* m,
lapack_int* n, const double* a, lapack_int* lda, double* work );
float LAPACK_clantr( char* norm, char* uplo, char* diag, lapack_int* m,
lapack_int* n, const lapack_complex_float* a, lapack_int* lda,
float* work );
double LAPACK_zlantr( char* norm, char* uplo, char* diag, lapack_int* m,
lapack_int* n, const lapack_complex_double* a, lapack_int* lda,
double* work );
float LAPACK_slamch( char* cmach );
double LAPACK_dlamch( char* cmach );
void LAPACK_sgelq2( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
float* tau, float* work, lapack_int *info );
void LAPACK_dgelq2( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
double* tau, double* work, lapack_int *info );
void LAPACK_cgelq2( lapack_int* m, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_complex_float* tau,
lapack_complex_float* work, lapack_int *info );
void LAPACK_zgelq2( lapack_int* m, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_complex_double* tau,
lapack_complex_double* work, lapack_int *info );
void LAPACK_slarfb( char* side, char* trans, char* direct, char* storev,
lapack_int* m, lapack_int* n, lapack_int* k, const float* v,
lapack_int* ldv, const float* t, lapack_int* ldt, float* c,
lapack_int* ldc, float* work, lapack_int* ldwork );
void LAPACK_dlarfb( char* side, char* trans, char* direct, char* storev,
lapack_int* m, lapack_int* n, lapack_int* k,
const double* v, lapack_int* ldv, const double* t,
lapack_int* ldt, double* c, lapack_int* ldc, double* work,
lapack_int* ldwork );
void LAPACK_clarfb( char* side, char* trans, char* direct, char* storev,
lapack_int* m, lapack_int* n, lapack_int* k,
const lapack_complex_float* v, lapack_int* ldv,
const lapack_complex_float* t, lapack_int* ldt,
lapack_complex_float* c, lapack_int* ldc,
lapack_complex_float* work, lapack_int* ldwork );
void LAPACK_zlarfb( char* side, char* trans, char* direct, char* storev,
lapack_int* m, lapack_int* n, lapack_int* k,
const lapack_complex_double* v, lapack_int* ldv,
const lapack_complex_double* t, lapack_int* ldt,
lapack_complex_double* c, lapack_int* ldc,
lapack_complex_double* work, lapack_int* ldwork );
void LAPACK_slarfg( lapack_int* n, float* alpha, float* x, lapack_int* incx,
float* tau );
void LAPACK_dlarfg( lapack_int* n, double* alpha, double* x, lapack_int* incx,
double* tau );
void LAPACK_clarfg( lapack_int* n, lapack_complex_float* alpha,
lapack_complex_float* x, lapack_int* incx,
lapack_complex_float* tau );
void LAPACK_zlarfg( lapack_int* n, lapack_complex_double* alpha,
lapack_complex_double* x, lapack_int* incx,
lapack_complex_double* tau );
void LAPACK_slarft( char* direct, char* storev, lapack_int* n, lapack_int* k,
const float* v, lapack_int* ldv, const float* tau, float* t,
lapack_int* ldt );
void LAPACK_dlarft( char* direct, char* storev, lapack_int* n, lapack_int* k,
const double* v, lapack_int* ldv, const double* tau,
double* t, lapack_int* ldt );
void LAPACK_clarft( char* direct, char* storev, lapack_int* n, lapack_int* k,
const lapack_complex_float* v, lapack_int* ldv,
const lapack_complex_float* tau, lapack_complex_float* t,
lapack_int* ldt );
void LAPACK_zlarft( char* direct, char* storev, lapack_int* n, lapack_int* k,
const lapack_complex_double* v, lapack_int* ldv,
const lapack_complex_double* tau, lapack_complex_double* t,
lapack_int* ldt );
void LAPACK_slarfx( char* side, lapack_int* m, lapack_int* n, const float* v,
float* tau, float* c, lapack_int* ldc, float* work );
void LAPACK_dlarfx( char* side, lapack_int* m, lapack_int* n, const double* v,
double* tau, double* c, lapack_int* ldc, double* work );
void LAPACK_clarfx( char* side, lapack_int* m, lapack_int* n,
const lapack_complex_float* v, lapack_complex_float* tau,
lapack_complex_float* c, lapack_int* ldc,
lapack_complex_float* work );
void LAPACK_zlarfx( char* side, lapack_int* m, lapack_int* n,
const lapack_complex_double* v, lapack_complex_double* tau,
lapack_complex_double* c, lapack_int* ldc,
lapack_complex_double* work );
void LAPACK_slatms( lapack_int* m, lapack_int* n, char* dist, lapack_int* iseed,
char* sym, float* d, lapack_int* mode, float* cond,
float* dmax, lapack_int* kl, lapack_int* ku, char* pack,
float* a, lapack_int* lda, float* work, lapack_int *info );
void LAPACK_dlatms( lapack_int* m, lapack_int* n, char* dist, lapack_int* iseed,
char* sym, double* d, lapack_int* mode, double* cond,
double* dmax, lapack_int* kl, lapack_int* ku, char* pack,
double* a, lapack_int* lda, double* work,
lapack_int *info );
void LAPACK_clatms( lapack_int* m, lapack_int* n, char* dist, lapack_int* iseed,
char* sym, float* d, lapack_int* mode, float* cond,
float* dmax, lapack_int* kl, lapack_int* ku, char* pack,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* work, lapack_int *info );
void LAPACK_zlatms( lapack_int* m, lapack_int* n, char* dist, lapack_int* iseed,
char* sym, double* d, lapack_int* mode, double* cond,
double* dmax, lapack_int* kl, lapack_int* ku, char* pack,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* work, lapack_int *info );
void LAPACK_slag2d( lapack_int* m, lapack_int* n, const float* sa,
lapack_int* ldsa, double* a, lapack_int* lda,
lapack_int *info );
void LAPACK_dlag2s( lapack_int* m, lapack_int* n, const double* a,
lapack_int* lda, float* sa, lapack_int* ldsa,
lapack_int *info );
void LAPACK_clag2z( lapack_int* m, lapack_int* n,
const lapack_complex_float* sa, lapack_int* ldsa,
lapack_complex_double* a, lapack_int* lda,
lapack_int *info );
void LAPACK_zlag2c( lapack_int* m, lapack_int* n,
const lapack_complex_double* a, lapack_int* lda,
lapack_complex_float* sa, lapack_int* ldsa,
lapack_int *info );
void LAPACK_slauum( char* uplo, lapack_int* n, float* a, lapack_int* lda,
lapack_int *info );
void LAPACK_dlauum( char* uplo, lapack_int* n, double* a, lapack_int* lda,
lapack_int *info );
void LAPACK_clauum( char* uplo, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_int *info );
void LAPACK_zlauum( char* uplo, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_int *info );
void LAPACK_slagge( lapack_int* m, lapack_int* n, lapack_int* kl,
lapack_int* ku, const float* d, float* a, lapack_int* lda,
lapack_int* iseed, float* work, lapack_int *info );
void LAPACK_dlagge( lapack_int* m, lapack_int* n, lapack_int* kl,
lapack_int* ku, const double* d, double* a, lapack_int* lda,
lapack_int* iseed, double* work, lapack_int *info );
void LAPACK_clagge( lapack_int* m, lapack_int* n, lapack_int* kl,
lapack_int* ku, const float* d, lapack_complex_float* a,
lapack_int* lda, lapack_int* iseed,
lapack_complex_float* work, lapack_int *info );
void LAPACK_zlagge( lapack_int* m, lapack_int* n, lapack_int* kl,
lapack_int* ku, const double* d, lapack_complex_double* a,
lapack_int* lda, lapack_int* iseed,
lapack_complex_double* work, lapack_int *info );
void LAPACK_slaset( char* uplo, lapack_int* m, lapack_int* n, float* alpha,
float* beta, float* a, lapack_int* lda );
void LAPACK_dlaset( char* uplo, lapack_int* m, lapack_int* n, double* alpha,
double* beta, double* a, lapack_int* lda );
void LAPACK_claset( char* uplo, lapack_int* m, lapack_int* n,
lapack_complex_float* alpha, lapack_complex_float* beta,
lapack_complex_float* a, lapack_int* lda );
void LAPACK_zlaset( char* uplo, lapack_int* m, lapack_int* n,
lapack_complex_double* alpha, lapack_complex_double* beta,
lapack_complex_double* a, lapack_int* lda );
void LAPACK_slasrt( char* id, lapack_int* n, float* d, lapack_int *info );
void LAPACK_dlasrt( char* id, lapack_int* n, double* d, lapack_int *info );
void LAPACK_claghe( lapack_int* n, lapack_int* k, const float* d,
lapack_complex_float* a, lapack_int* lda, lapack_int* iseed,
lapack_complex_float* work, lapack_int *info );
void LAPACK_zlaghe( lapack_int* n, lapack_int* k, const double* d,
lapack_complex_double* a, lapack_int* lda,
lapack_int* iseed, lapack_complex_double* work,
lapack_int *info );
void LAPACK_slagsy( lapack_int* n, lapack_int* k, const float* d, float* a,
lapack_int* lda, lapack_int* iseed, float* work,
lapack_int *info );
void LAPACK_dlagsy( lapack_int* n, lapack_int* k, const double* d, double* a,
lapack_int* lda, lapack_int* iseed, double* work,
lapack_int *info );
void LAPACK_clagsy( lapack_int* n, lapack_int* k, const float* d,
lapack_complex_float* a, lapack_int* lda, lapack_int* iseed,
lapack_complex_float* work, lapack_int *info );
void LAPACK_zlagsy( lapack_int* n, lapack_int* k, const double* d,
lapack_complex_double* a, lapack_int* lda,
lapack_int* iseed, lapack_complex_double* work,
lapack_int *info );
void LAPACK_slapmr( lapack_logical* forwrd, lapack_int* m, lapack_int* n,
float* x, lapack_int* ldx, lapack_int* k );
void LAPACK_dlapmr( lapack_logical* forwrd, lapack_int* m, lapack_int* n,
double* x, lapack_int* ldx, lapack_int* k );
void LAPACK_clapmr( lapack_logical* forwrd, lapack_int* m, lapack_int* n,
lapack_complex_float* x, lapack_int* ldx, lapack_int* k );
void LAPACK_zlapmr( lapack_logical* forwrd, lapack_int* m, lapack_int* n,
lapack_complex_double* x, lapack_int* ldx, lapack_int* k );
float LAPACK_slapy2( float* x, float* y );
double LAPACK_dlapy2( double* x, double* y );
float LAPACK_slapy3( float* x, float* y, float* z );
double LAPACK_dlapy3( double* x, double* y, double* z );
void LAPACK_slartgp( float* f, float* g, float* cs, float* sn, float* r );
void LAPACK_dlartgp( double* f, double* g, double* cs, double* sn, double* r );
void LAPACK_slartgs( float* x, float* y, float* sigma, float* cs, float* sn );
void LAPACK_dlartgs( double* x, double* y, double* sigma, double* cs,
double* sn );
// LAPACK 3.3.0
void LAPACK_cbbcsd( char* jobu1, char* jobu2,
char* jobv1t, char* jobv2t, char* trans,
lapack_int* m, lapack_int* p, lapack_int* q,
float* theta, float* phi,
lapack_complex_float* u1, lapack_int* ldu1,
lapack_complex_float* u2, lapack_int* ldu2,
lapack_complex_float* v1t, lapack_int* ldv1t,
lapack_complex_float* v2t, lapack_int* ldv2t,
float* b11d, float* b11e, float* b12d,
float* b12e, float* b21d, float* b21e,
float* b22d, float* b22e, float* rwork,
lapack_int* lrwork , lapack_int *info );
void LAPACK_cheswapr( char* uplo, lapack_int* n,
lapack_complex_float* a, lapack_int* i1,
lapack_int* i2 );
void LAPACK_chetri2( char* uplo, lapack_int* n,
lapack_complex_float* a, lapack_int* lda,
const lapack_int* ipiv,
lapack_complex_float* work, lapack_int* lwork , lapack_int *info );
void LAPACK_chetri2x( char* uplo, lapack_int* n,
lapack_complex_float* a, lapack_int* lda,
const lapack_int* ipiv,
lapack_complex_float* work, lapack_int* nb , lapack_int *info );
void LAPACK_chetrs2( char* uplo, lapack_int* n,
lapack_int* nrhs, const lapack_complex_float* a,
lapack_int* lda, const lapack_int* ipiv,
lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* work , lapack_int *info );
void LAPACK_csyconv( char* uplo, char* way,
lapack_int* n, lapack_complex_float* a,
lapack_int* lda, const lapack_int* ipiv,
lapack_complex_float* work , lapack_int *info );
void LAPACK_csyswapr( char* uplo, lapack_int* n,
lapack_complex_float* a, lapack_int* i1,
lapack_int* i2 );
void LAPACK_csytri2( char* uplo, lapack_int* n,
lapack_complex_float* a, lapack_int* lda,
const lapack_int* ipiv,
lapack_complex_float* work, lapack_int* lwork , lapack_int *info );
void LAPACK_csytri2x( char* uplo, lapack_int* n,
lapack_complex_float* a, lapack_int* lda,
const lapack_int* ipiv,
lapack_complex_float* work, lapack_int* nb , lapack_int *info );
void LAPACK_csytrs2( char* uplo, lapack_int* n,
lapack_int* nrhs, const lapack_complex_float* a,
lapack_int* lda, const lapack_int* ipiv,
lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* work , lapack_int *info );
void LAPACK_cunbdb( char* trans, char* signs,
lapack_int* m, lapack_int* p, lapack_int* q,
lapack_complex_float* x11, lapack_int* ldx11,
lapack_complex_float* x12, lapack_int* ldx12,
lapack_complex_float* x21, lapack_int* ldx21,
lapack_complex_float* x22, lapack_int* ldx22,
float* theta, float* phi,
lapack_complex_float* taup1,
lapack_complex_float* taup2,
lapack_complex_float* tauq1,
lapack_complex_float* tauq2,
lapack_complex_float* work, lapack_int* lwork , lapack_int *info );
void LAPACK_cuncsd( char* jobu1, char* jobu2,
char* jobv1t, char* jobv2t, char* trans,
char* signs, lapack_int* m, lapack_int* p,
lapack_int* q, lapack_complex_float* x11,
lapack_int* ldx11, lapack_complex_float* x12,
lapack_int* ldx12, lapack_complex_float* x21,
lapack_int* ldx21, lapack_complex_float* x22,
lapack_int* ldx22, float* theta,
lapack_complex_float* u1, lapack_int* ldu1,
lapack_complex_float* u2, lapack_int* ldu2,
lapack_complex_float* v1t, lapack_int* ldv1t,
lapack_complex_float* v2t, lapack_int* ldv2t,
lapack_complex_float* work, lapack_int* lwork,
float* rwork, lapack_int* lrwork,
lapack_int* iwork , lapack_int *info );
void LAPACK_dbbcsd( char* jobu1, char* jobu2,
char* jobv1t, char* jobv2t, char* trans,
lapack_int* m, lapack_int* p, lapack_int* q,
double* theta, double* phi, double* u1,
lapack_int* ldu1, double* u2, lapack_int* ldu2,
double* v1t, lapack_int* ldv1t, double* v2t,
lapack_int* ldv2t, double* b11d, double* b11e,
double* b12d, double* b12e, double* b21d,
double* b21e, double* b22d, double* b22e,
double* work, lapack_int* lwork , lapack_int *info );
void LAPACK_dorbdb( char* trans, char* signs,
lapack_int* m, lapack_int* p, lapack_int* q,
double* x11, lapack_int* ldx11, double* x12,
lapack_int* ldx12, double* x21, lapack_int* ldx21,
double* x22, lapack_int* ldx22, double* theta,
double* phi, double* taup1, double* taup2,
double* tauq1, double* tauq2, double* work,
lapack_int* lwork , lapack_int *info );
void LAPACK_dorcsd( char* jobu1, char* jobu2,
char* jobv1t, char* jobv2t, char* trans,
char* signs, lapack_int* m, lapack_int* p,
lapack_int* q, double* x11, lapack_int* ldx11,
double* x12, lapack_int* ldx12, double* x21,
lapack_int* ldx21, double* x22, lapack_int* ldx22,
double* theta, double* u1, lapack_int* ldu1,
double* u2, lapack_int* ldu2, double* v1t,
lapack_int* ldv1t, double* v2t, lapack_int* ldv2t,
double* work, lapack_int* lwork,
lapack_int* iwork , lapack_int *info );
void LAPACK_dsyconv( char* uplo, char* way,
lapack_int* n, double* a, lapack_int* lda,
const lapack_int* ipiv, double* work , lapack_int *info );
void LAPACK_dsyswapr( char* uplo, lapack_int* n,
double* a, lapack_int* i1, lapack_int* i2 );
void LAPACK_dsytri2( char* uplo, lapack_int* n,
double* a, lapack_int* lda,
const lapack_int* ipiv,
lapack_complex_double* work, lapack_int* lwork , lapack_int *info );
void LAPACK_dsytri2x( char* uplo, lapack_int* n,
double* a, lapack_int* lda,
const lapack_int* ipiv, double* work,
lapack_int* nb , lapack_int *info );
void LAPACK_dsytrs2( char* uplo, lapack_int* n,
lapack_int* nrhs, const double* a,
lapack_int* lda, const lapack_int* ipiv,
double* b, lapack_int* ldb, double* work , lapack_int *info );
void LAPACK_sbbcsd( char* jobu1, char* jobu2,
char* jobv1t, char* jobv2t, char* trans,
lapack_int* m, lapack_int* p, lapack_int* q,
float* theta, float* phi, float* u1,
lapack_int* ldu1, float* u2, lapack_int* ldu2,
float* v1t, lapack_int* ldv1t, float* v2t,
lapack_int* ldv2t, float* b11d, float* b11e,
float* b12d, float* b12e, float* b21d,
float* b21e, float* b22d, float* b22e,
float* work, lapack_int* lwork , lapack_int *info );
void LAPACK_sorbdb( char* trans, char* signs,
lapack_int* m, lapack_int* p, lapack_int* q,
float* x11, lapack_int* ldx11, float* x12,
lapack_int* ldx12, float* x21, lapack_int* ldx21,
float* x22, lapack_int* ldx22, float* theta,
float* phi, float* taup1, float* taup2,
float* tauq1, float* tauq2, float* work,
lapack_int* lwork , lapack_int *info );
void LAPACK_sorcsd( char* jobu1, char* jobu2,
char* jobv1t, char* jobv2t, char* trans,
char* signs, lapack_int* m, lapack_int* p,
lapack_int* q, float* x11, lapack_int* ldx11,
float* x12, lapack_int* ldx12, float* x21,
lapack_int* ldx21, float* x22, lapack_int* ldx22,
float* theta, float* u1, lapack_int* ldu1,
float* u2, lapack_int* ldu2, float* v1t,
lapack_int* ldv1t, float* v2t, lapack_int* ldv2t,
float* work, lapack_int* lwork,
lapack_int* iwork , lapack_int *info );
void LAPACK_ssyconv( char* uplo, char* way,
lapack_int* n, float* a, lapack_int* lda,
const lapack_int* ipiv, float* work , lapack_int *info );
void LAPACK_ssyswapr( char* uplo, lapack_int* n,
float* a, lapack_int* i1, lapack_int* i2 );
void LAPACK_ssytri2( char* uplo, lapack_int* n,
float* a, lapack_int* lda,
const lapack_int* ipiv,
lapack_complex_float* work, lapack_int* lwork , lapack_int *info );
void LAPACK_ssytri2x( char* uplo, lapack_int* n,
float* a, lapack_int* lda,
const lapack_int* ipiv, float* work,
lapack_int* nb , lapack_int *info );
void LAPACK_ssytrs2( char* uplo, lapack_int* n,
lapack_int* nrhs, const float* a,
lapack_int* lda, const lapack_int* ipiv,
float* b, lapack_int* ldb, float* work , lapack_int *info );
void LAPACK_zbbcsd( char* jobu1, char* jobu2,
char* jobv1t, char* jobv2t, char* trans,
lapack_int* m, lapack_int* p, lapack_int* q,
double* theta, double* phi,
lapack_complex_double* u1, lapack_int* ldu1,
lapack_complex_double* u2, lapack_int* ldu2,
lapack_complex_double* v1t, lapack_int* ldv1t,
lapack_complex_double* v2t, lapack_int* ldv2t,
double* b11d, double* b11e, double* b12d,
double* b12e, double* b21d, double* b21e,
double* b22d, double* b22e, double* rwork,
lapack_int* lrwork , lapack_int *info );
void LAPACK_zheswapr( char* uplo, lapack_int* n,
lapack_complex_double* a, lapack_int* i1,
lapack_int* i2 );
void LAPACK_zhetri2( char* uplo, lapack_int* n,
lapack_complex_double* a, lapack_int* lda,
const lapack_int* ipiv,
lapack_complex_double* work, lapack_int* lwork , lapack_int *info );
void LAPACK_zhetri2x( char* uplo, lapack_int* n,
lapack_complex_double* a, lapack_int* lda,
const lapack_int* ipiv,
lapack_complex_double* work, lapack_int* nb , lapack_int *info );
void LAPACK_zhetrs2( char* uplo, lapack_int* n,
lapack_int* nrhs,
const lapack_complex_double* a, lapack_int* lda,
const lapack_int* ipiv,
lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* work , lapack_int *info );
void LAPACK_zsyconv( char* uplo, char* way,
lapack_int* n, lapack_complex_double* a,
lapack_int* lda, const lapack_int* ipiv,
lapack_complex_double* work , lapack_int *info );
void LAPACK_zsyswapr( char* uplo, lapack_int* n,
lapack_complex_double* a, lapack_int* i1,
lapack_int* i2 );
void LAPACK_zsytri2( char* uplo, lapack_int* n,
lapack_complex_double* a, lapack_int* lda,
const lapack_int* ipiv,
lapack_complex_double* work, lapack_int* lwork , lapack_int *info );
void LAPACK_zsytri2x( char* uplo, lapack_int* n,
lapack_complex_double* a, lapack_int* lda,
const lapack_int* ipiv,
lapack_complex_double* work, lapack_int* nb , lapack_int *info );
void LAPACK_zsytrs2( char* uplo, lapack_int* n,
lapack_int* nrhs,
const lapack_complex_double* a, lapack_int* lda,
const lapack_int* ipiv,
lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* work , lapack_int *info );
void LAPACK_zunbdb( char* trans, char* signs,
lapack_int* m, lapack_int* p, lapack_int* q,
lapack_complex_double* x11, lapack_int* ldx11,
lapack_complex_double* x12, lapack_int* ldx12,
lapack_complex_double* x21, lapack_int* ldx21,
lapack_complex_double* x22, lapack_int* ldx22,
double* theta, double* phi,
lapack_complex_double* taup1,
lapack_complex_double* taup2,
lapack_complex_double* tauq1,
lapack_complex_double* tauq2,
lapack_complex_double* work, lapack_int* lwork , lapack_int *info );
void LAPACK_zuncsd( char* jobu1, char* jobu2,
char* jobv1t, char* jobv2t, char* trans,
char* signs, lapack_int* m, lapack_int* p,
lapack_int* q, lapack_complex_double* x11,
lapack_int* ldx11, lapack_complex_double* x12,
lapack_int* ldx12, lapack_complex_double* x21,
lapack_int* ldx21, lapack_complex_double* x22,
lapack_int* ldx22, double* theta,
lapack_complex_double* u1, lapack_int* ldu1,
lapack_complex_double* u2, lapack_int* ldu2,
lapack_complex_double* v1t, lapack_int* ldv1t,
lapack_complex_double* v2t, lapack_int* ldv2t,
lapack_complex_double* work, lapack_int* lwork,
double* rwork, lapack_int* lrwork,
lapack_int* iwork , lapack_int *info );
// LAPACK 3.4.0
void LAPACK_sgemqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, lapack_int* nb, const float* v,
lapack_int* ldv, const float* t, lapack_int* ldt, float* c,
lapack_int* ldc, float* work, lapack_int *info );
void LAPACK_dgemqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, lapack_int* nb, const double* v,
lapack_int* ldv, const double* t, lapack_int* ldt,
double* c, lapack_int* ldc, double* work,
lapack_int *info );
void LAPACK_cgemqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, lapack_int* nb,
const lapack_complex_float* v, lapack_int* ldv,
const lapack_complex_float* t, lapack_int* ldt,
lapack_complex_float* c, lapack_int* ldc,
lapack_complex_float* work, lapack_int *info );
void LAPACK_zgemqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, lapack_int* nb,
const lapack_complex_double* v, lapack_int* ldv,
const lapack_complex_double* t, lapack_int* ldt,
lapack_complex_double* c, lapack_int* ldc,
lapack_complex_double* work, lapack_int *info );
void LAPACK_sgeqrt( lapack_int* m, lapack_int* n, lapack_int* nb, float* a,
lapack_int* lda, float* t, lapack_int* ldt, float* work,
lapack_int *info );
void LAPACK_dgeqrt( lapack_int* m, lapack_int* n, lapack_int* nb, double* a,
lapack_int* lda, double* t, lapack_int* ldt, double* work,
lapack_int *info );
void LAPACK_cgeqrt( lapack_int* m, lapack_int* n, lapack_int* nb,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* t, lapack_int* ldt,
lapack_complex_float* work, lapack_int *info );
void LAPACK_zgeqrt( lapack_int* m, lapack_int* n, lapack_int* nb,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* t, lapack_int* ldt,
lapack_complex_double* work, lapack_int *info );
void LAPACK_sgeqrt2( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
float* t, lapack_int* ldt, lapack_int *info );
void LAPACK_dgeqrt2( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
double* t, lapack_int* ldt, lapack_int *info );
void LAPACK_cgeqrt2( lapack_int* m, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_complex_float* t, lapack_int* ldt,
lapack_int *info );
void LAPACK_zgeqrt2( lapack_int* m, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_complex_double* t, lapack_int* ldt,
lapack_int *info );
void LAPACK_sgeqrt3( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
float* t, lapack_int* ldt, lapack_int *info );
void LAPACK_dgeqrt3( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
double* t, lapack_int* ldt, lapack_int *info );
void LAPACK_cgeqrt3( lapack_int* m, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_complex_float* t, lapack_int* ldt,
lapack_int *info );
void LAPACK_zgeqrt3( lapack_int* m, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_complex_double* t, lapack_int* ldt,
lapack_int *info );
void LAPACK_stpmqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, lapack_int* l, lapack_int* nb,
const float* v, lapack_int* ldv, const float* t,
lapack_int* ldt, float* a, lapack_int* lda, float* b,
lapack_int* ldb, float* work, lapack_int *info );
void LAPACK_dtpmqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, lapack_int* l, lapack_int* nb,
const double* v, lapack_int* ldv, const double* t,
lapack_int* ldt, double* a, lapack_int* lda, double* b,
lapack_int* ldb, double* work, lapack_int *info );
void LAPACK_ctpmqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, lapack_int* l, lapack_int* nb,
const lapack_complex_float* v, lapack_int* ldv,
const lapack_complex_float* t, lapack_int* ldt,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* work, lapack_int *info );
void LAPACK_ztpmqrt( char* side, char* trans, lapack_int* m, lapack_int* n,
lapack_int* k, lapack_int* l, lapack_int* nb,
const lapack_complex_double* v, lapack_int* ldv,
const lapack_complex_double* t, lapack_int* ldt,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* work, lapack_int *info );
void LAPACK_dtpqrt( lapack_int* m, lapack_int* n, lapack_int* l, lapack_int* nb,
double* a, lapack_int* lda, double* b, lapack_int* ldb,
double* t, lapack_int* ldt, double* work,
lapack_int *info );
void LAPACK_ctpqrt( lapack_int* m, lapack_int* n, lapack_int* l, lapack_int* nb,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* t, lapack_complex_float* b,
lapack_int* ldb, lapack_int* ldt,
lapack_complex_float* work, lapack_int *info );
void LAPACK_ztpqrt( lapack_int* m, lapack_int* n, lapack_int* l, lapack_int* nb,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* t, lapack_int* ldt,
lapack_complex_double* work, lapack_int *info );
void LAPACK_stpqrt2( lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
float* b, lapack_int* ldb, float* t, lapack_int* ldt,
lapack_int *info );
void LAPACK_dtpqrt2( lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
double* b, lapack_int* ldb, double* t, lapack_int* ldt,
lapack_int *info );
void LAPACK_ctpqrt2( lapack_int* m, lapack_int* n, lapack_complex_float* a,
lapack_int* lda, lapack_complex_float* b, lapack_int* ldb,
lapack_complex_float* t, lapack_int* ldt,
lapack_int *info );
void LAPACK_ztpqrt2( lapack_int* m, lapack_int* n, lapack_complex_double* a,
lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
lapack_complex_double* t, lapack_int* ldt,
lapack_int *info );
void LAPACK_stprfb( char* side, char* trans, char* direct, char* storev,
lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l,
const float* v, lapack_int* ldv, const float* t,
lapack_int* ldt, float* a, lapack_int* lda, float* b,
lapack_int* ldb, const float* mywork,
lapack_int* myldwork );
void LAPACK_dtprfb( char* side, char* trans, char* direct, char* storev,
lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l,
const double* v, lapack_int* ldv, const double* t,
lapack_int* ldt, double* a, lapack_int* lda, double* b,
lapack_int* ldb, const double* mywork,
lapack_int* myldwork );
void LAPACK_ctprfb( char* side, char* trans, char* direct, char* storev,
lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l,
const lapack_complex_float* v, lapack_int* ldv,
const lapack_complex_float* t, lapack_int* ldt,
lapack_complex_float* a, lapack_int* lda,
lapack_complex_float* b, lapack_int* ldb,
const float* mywork, lapack_int* myldwork );
void LAPACK_ztprfb( char* side, char* trans, char* direct, char* storev,
lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l,
const lapack_complex_double* v, lapack_int* ldv,
const lapack_complex_double* t, lapack_int* ldt,
lapack_complex_double* a, lapack_int* lda,
lapack_complex_double* b, lapack_int* ldb,
const double* mywork, lapack_int* myldwork );
// LAPACK 3.X.X
void LAPACK_csyr( char* uplo, lapack_int* n, lapack_complex_float* alpha,
const lapack_complex_float* x, lapack_int* incx,
lapack_complex_float* a, lapack_int* lda );
void LAPACK_zsyr( char* uplo, lapack_int* n, lapack_complex_double* alpha,
const lapack_complex_double* x, lapack_int* incx,
lapack_complex_double* a, lapack_int* lda );
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* _LAPACKE_H_ */
#endif /* _MKL_LAPACKE_H_ */
| /*****************************************************************************
Copyright (c) 2010, Intel Corp.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of Intel Corporation nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
THE POSSIBILITY OF SUCH DAMAGE.
******************************************************************************
* Contents: Native C interface to LAPACK
* Author: Intel Corporation
* Generated November, 2011
*****************************************************************************/ |
dune |
(library (name ppx_jsonaf_conv_test)
(libraries base expect_test_helpers_core jsonaf_bignum jsonaf)
(flags :standard -w -30)
(preprocess (pps ppx_jane ppx_jsonaf_conv ppx_compare))) | |
persistent_connection.mli | include Persistent_connection_intf.Persistent_connection (** @inline *)
| include Persistent_connection_intf.Persistent_connection (** @inline *)
|
checkocaml.ml | (** Detection of OCaml tools and libraries. *)
(* $Id$ *)
(*c==m=[OCaml_conf]=0.12=t==*)
open Sys
open Unix
(** {2:configuration Configuration}
You can change these values to modify the behaviour of some functions. *)
(** The prefix of the temporary files created. *)
let temp_files_prefix = ref "config_check"
(** The default extension for the temporary files created. *)
let temp_files_ext = ref "ml"
(** Set this to [true] to enable debug mode.
Temporary files are not deleted when it is enabled. *)
let debug = ref false
(** The function used to print progress messages and other information. *)
let print = ref (fun s -> print_string s; flush Stdlib.stdout)
(** [!string_of_bool b] should return a message according to the given boolean.
Default are yes/no. *)
let string_of_bool = ref (function true -> "yes" | false -> "no")
(** The name of the log file. *)
let log_file = ref "config_check.log"
(** The function to print a given fatal error message. Should exit the
configuration process. *)
let fatal_error = ref
(fun s ->
prerr_endline s;
prerr_endline (Printf.sprintf "You way have a look at %s for details." !log_file);
exit 1
)
(** {2:utils Utilities functions} *)
let try_finalize f x finally y =
let res = try f x with exn -> finally y; raise exn in
finally y;
res;;
let rec restart_on_EINTR f x =
try f x with Unix_error (EINTR, _, _) -> restart_on_EINTR f x
(** [is_suffix ~suf s] returns [true] if the string [suf] is a suffix of [s]. *)
let is_suffix ~suf s =
let len_suf = String.length suf in
let len_s = String.length s in
len_s >= len_suf &&
String.sub s (len_s - len_suf) len_suf = suf
(** [create_temp_files ?ext ?contents ()] creates a temporary empty file and
returns its name. The prefix of the file is specified by {!temp_files_prefix}.
@param ext can be used to indicate a extension different from {!temp_files_ext}.
@param contents can be used to specify the content of the file.
*)
let create_temp_file ?(ext= !temp_files_ext) ?(contents="") () =
let (file,oc) = Filename.open_temp_file
!temp_files_prefix ("." ^ ext)
in
output_string oc contents;
close_out oc;
file
let remove_empty_strings = List.filter ((<>) "")
let string_of_includes l =
String.concat " " (List.map (fun s -> "-I "^(Filename.quote s)) (remove_empty_strings l))
(** If the given filename has a [.cmo] (resp. [.cma]) extension,
then return the same filename with a [.cmx] (resp. [.cmxa]) extension.*)
let byte_ext_to_opt f =
if Filename.check_suffix f ".cmo" then
Printf.sprintf "%s.cmx" (Filename.chop_extension f)
else
if Filename.check_suffix f ".cma" then
Printf.sprintf "%s.cmxa" (Filename.chop_extension f)
else
f
(** {2:path Handling PATH} *)
exception Path of string * string;;
let path_sep = ":";;
let path_sep_regexp = Str.regexp (Str.quote path_sep);;
(** [list_of_path string] returns the list of directories from the given string in path format. *)
let list_of_path = Str.split path_sep_regexp;;
(** [path_of_list paths] builds a string in path format.
@raise Path if a path contains the separator. *)
let path_of_list paths =
(* Un nom de fichier dans un chemin ne doit pas contenir le séparateur... *)
let check s =
if Str.string_match path_sep_regexp s 0 then
let pos = Str.match_beginning() in
let mes = Printf.sprintf "Separator string found at position %d" pos in
raise (Path (s, mes)) in
List.iter check paths;
String.concat path_sep paths;;
(** [get_path ()] returns the list of directories indicated by the [PATH] environement variable. *)
let get_path () = list_of_path (getenv "PATH");;
(** [find_in_path predicate paths file] returns the list of complete filenames build
from the directories and the filename, and verifying the given predicate. *)
let find_in_path p paths file =
List.find_all p (List.map (fun p -> Filename.concat p file) paths);;
(** {2:files Handling files} *)
(** Various tests of a file. *)
type filetest =
| Fexists (** file exists *)
| Freadable (** file exists and is readable *)
| Fwritable (** file exists and is writable *)
| Fexecutable (** file exists and is executable *)
| Fdir (** file exists and is a directory *)
| Freg (** file exists and is a regular file *)
| Flnk (** file exists and is a symbolic link *)
| Fnonempty (* file* exists and is non empty *)
| Fnewer of string (** files exists and is newer than *)
| Folder of string (** files exists and is older than *)
| Fequal of string (** files is identical (sams st_ino and st_dev) than *)
let access_map =
[ Freadable, R_OK; Fwritable, W_OK; Fexecutable, X_OK; Fexists, F_OK; ]
let access_ok_errors =
[ EACCES ; EROFS; ENOENT; ENOTDIR; ELOOP ]
;;
(** [testfile flags filename] tests whether the given file verifies the given properties. *)
let testfile flags filename =
let rec split ( (found, left) as both) = function
[] -> both
| h :: t ->
let found_left =
try List.assoc h access_map :: found, left
with Not_found -> found, h::left in
split found_left t
in
let access_flags, flags = split ([],[]) flags in
let access_flags = if access_flags = [] then [ F_OK ] else access_flags in
try
access filename access_flags;
flags = [] ||
begin
let st = (if List.mem Flnk flags then lstat else stat) filename in
let rec test = function
| Fdir -> st.st_kind = S_DIR
| Freg -> st.st_kind = S_REG
| Flnk -> st.st_kind = S_LNK
| Fnonempty -> st.st_size > 0
| Fnewer string -> st.st_mtime > (stat string).st_mtime
| Folder string -> st.st_mtime < (stat string).st_mtime
| Fequal string ->
let st' = stat string in
st.st_ino = st'.st_ino && st.st_dev = st'.st_dev
| _ -> assert false
in
List.for_all test flags
end;
with Unix.Unix_error (err, _, _) when List.mem err access_ok_errors ->
false
;;
let buffer_size = 4096
let string_from_descr fd =
let rec readfd accu =
let str = Bytes.make buffer_size '\000' in
match restart_on_EINTR (read fd str 0) buffer_size with
| 0 -> String.concat"" accu
| n ->
let str = if n < buffer_size then Bytes.sub str 0 n else str in
readfd (Bytes.to_string str :: accu)
in
readfd []
;;
let descr_from_string str fd =
let str = Bytes.of_string str in
let rec writefd offset left =
if left > 0 then
let n = restart_on_EINTR (single_write fd str offset) left in
writefd (offset + n) (left - n) in
writefd 0 (Bytes.length str)
;;
let perm = 0o640;;
(** [string_of_files] returns the contents of the given file as a string.
@raise Unix.Unix_error if an error occurs.
*)
let string_of_file file =
let fd = openfile file [ O_RDONLY ] 0 in
try_finalize string_from_descr fd close fd
;;
(** [file_of_string ~contents ~file] creates the given file with the given string [str] as contents.
@raise Unix.Unix_error if an error occurs.
*)
let file_of_string ~contents ~file =
let fd = openfile file [ O_WRONLY; O_CREAT; O_TRUNC ] perm in
try_finalize (descr_from_string contents) fd close fd
;;
(** [input_lines channel] return the list of lines from the given channel.
The function is tail-recursive.
*)
let input_lines chan =
let rec all lines =
(* intermediate result to be tail rec *)
match try Some (input_line chan) with End_of_file -> None with
Some l -> all (l::lines)
| None -> List.rev lines in
all []
(** [unlink_f file] removes the given [file] if it exists.
If the files is a [.ml] file (resp. a [.mli] file), then
it also removes the [.cmo], [.cmx], [.o] and [.cmi] files
(resp. the [.cmi] file) if they exist.
@raise Unix.Unix_error if an error occurs.
*)
let unlink_f file =
if !debug then ()
else
let files =
if Filename.check_suffix file ".mli" then
[file; (Filename.chop_extension file)^".cmi"]
else
if Filename.check_suffix file ".ml" then
let base = Filename.chop_extension file in
[file; base^".cmi" ; base^".cmo" ; base^".cmx"; base^".o" ]
else
[file]
in
let f file =
try unlink file with Unix_error (ENOENT, _, _) -> ()
in
List.iter f files
(** {2:exec Handling processes} *)
exception Exec_failure;;
let execvp_to_list cmd args =
let desc_read, desc_write = pipe () in
match fork() with
0 ->
let exec () =
close desc_read;
dup2 desc_write stdout;
close desc_write;
execvp cmd (Array.append [| cmd |] args) in
handle_unix_error exec ()
| pid ->
close desc_write;
let chan = in_channel_of_descr desc_read in
let after () =
close_in chan;
match restart_on_EINTR (waitpid []) pid with
_, WEXITED 0 -> ()
| _, _ -> raise Exec_failure in
try_finalize input_lines chan after ();;
type redirection =
| In_from_file of string (** < file *)
| Out_to_file of string (** > file *)
| Err_to_file of string (** 2> file *)
| Out_append_to_file of string (** >> file *)
| Err_to_out (** 2>&1 *)
| In_from_string of string (** <<END *)
| Err_null (** 2>/dev/null *)
| Out_null (** >/dev/null *)
| Silent (** >/dev/null 2>&1 *)
;;
let execvp_redirect redirections cmd args =
let perm = 0o640 in
let temp_file =
if List.exists (function In_from_string _ -> true | _ -> false)
redirections
then Some (create_temp_file ~ext: ".in" ())
else None in
let rec make_redirect rd =
match rd with
In_from_file file ->
let desc_file = openfile file [O_RDONLY] perm in
try_finalize (dup2 desc_file) stdin close desc_file
| Out_to_file file ->
let desc_file = openfile file [O_WRONLY;O_CREAT;O_TRUNC] perm in
try_finalize (dup2 desc_file) stdout close desc_file
| Err_to_file file ->
let desc_file = openfile file [O_WRONLY;O_CREAT;O_TRUNC] perm in
try_finalize (dup2 desc_file) stderr close desc_file
| Out_append_to_file file ->
let desc_file = openfile file [O_WRONLY;O_APPEND;O_CREAT] perm in
try_finalize (dup2 desc_file) stdout close desc_file
| Err_to_out -> dup2 stdout stderr
| In_from_string s ->
begin match temp_file with
Some tmp ->
file_of_string ~file: tmp ~contents: s;
make_redirect (In_from_file tmp);
| None -> assert false
end
| Out_null ->
make_redirect (Out_to_file "/dev/null")
| Err_null ->
make_redirect (Err_to_file "/dev/null")
| Silent ->
make_redirect Out_null;
make_redirect Err_to_out;
in
match fork () with
0 ->
let exec () =
List.iter make_redirect redirections;
execvp cmd (Array.append [|cmd|] args);
in
handle_unix_error exec ();
| pid ->
let res = snd (waitpid [] pid) in
begin match temp_file with
Some tmp -> unlink_f tmp
| _ -> ()
end;
res
;;
let execvp cmd arg =
match fork() with
| 0 -> Unix.execvp cmd (Array.concat [ [| cmd |]; arg ])
| p -> snd(waitpid [] p)
(** [exec_and_get_first_line com args] tries to execute the given command with
the given arguments, and read the first line printed by the commande on its
standard output. If any error occurs or the program doesn't print anything on stdout,
the function returns [""].*)
let exec_and_get_first_line com args =
match
handle_unix_error
(fun () -> execvp_to_list com args) ()
with
[] -> ""
| h :: _ -> h
(** [exec_status_ok st] returns [true] if the given return status is [Unix.WEXITED 0]. *)
let exec_status_ok = function
Unix.WEXITED 0 -> true
| _ -> false
(** {2 Writing to log file} *)
let string_of_date t =
let d = Unix.localtime t in
Printf.sprintf "%02d/%02d/%02d %02d:%02d:%02d"
(d.Unix.tm_year + 1900) (d.Unix.tm_mon+1) d.Unix.tm_mday
d.Unix.tm_hour d.Unix.tm_min d.Unix.tm_sec
(** [add_to_log str] writes the given string to the {!log_file},
with the date and time at the beginning of the line and an ending new line.*)
let add_to_log s =
let oc = open_out_gen
[Open_wronly ; Open_append ; Open_creat ; Open_text ]
0o644 !log_file
in
Printf.fprintf oc "%s: %s\n"
(string_of_date (Unix.time()))
s;
close_out oc
(** {2 Handling version numbers } *)
type version = int list
(** [v1 << v2] returns [true] if version [v1] is strictly inferior to version [v2]. *)
let (<<) v1 v2 =
let rec iter = function
([], []) -> false
| ([], _) -> true
| (_,[]) -> false
| (h1::q1, h2::q2) ->
(h1 < h2) ||
(h1 = h2 && (iter (q1,q2)))
in
iter (v1,v2)
(** The dummy version number = [[0]]. *)
let dummy_version = [0]
(** [version_of_string s] returns a version number from the given string [s].
[s] must b in the form [X[.Y[.Z[...]]]]. If the string is not correct,
then the dummy version is returned. When the version number is followed
by other characters (like '+'), then only the characters before are used
to create the version number.*)
let version_of_string =
let is_bad_char = function
'.' | '0'..'9' -> false
| _ -> true
in
let keep_good_chars s =
let len = String.length s in
let b = Buffer.create len in
let rec iter i =
if i >= len then
()
else
if i = 0 && String.get s i = 'v'
then
iter (i+1)
else
if is_bad_char (String.get s i) then
()
else
(Buffer.add_char b (String.get s i) ;
iter (i+1)
)
in
iter 0;
Buffer.contents b
in
fun s ->
let s = keep_good_chars s in
let l = Str.split (Str.regexp_string ".") s in
try List.map int_of_string l
with Failure _ -> dummy_version
(** [string_of_version v] returns a string to display the given version.
For example, [string_of_version [1;2;3] = "1.2.3"]. *)
let string_of_version v =
String.concat "." (List.map string_of_int v)
(** {2 Handling OCaml configuration} *)
(** Representation of the (locally detected) ocaml configuration. *)
type ocaml_conf =
{
ocaml : string ;
ocamlc : string ;
ocamlopt : string ;
ocamldep : string ;
ocamldoc : string ;
ocamldoc_opt : string ;
ocamllex : string ;
ocamlyacc : string ;
ocamlmklib : string ;
ocamlmktop : string ;
ocamlprof : string ;
camlp4 : string ;
ocamlfind : string ;
version_string : string ;
version : version ;
}
exception Program_not_found of string
(** [ocaml_prog file] return the first executable called [file] in
the directories of the PATH environment variable.
@param err can be used to indicate whether not finding the program
should raise the [Program_not_found] exception ([err=true], default)
or rather return an empty string ([err=false]).
The function prints messages indicating what program is searched, and the result,
using the {!print} function.
*)
let ocaml_prog ?(err=true) file =
!print (Printf.sprintf "checking for %s... " file);
match
handle_unix_error
(fun () -> find_in_path (testfile [Fexecutable;Freg]) (get_path()) file)
()
with
[] ->
!print "no\n";
if err then raise (Program_not_found file) else ""
| s :: _ ->
!print (s^"\n"); s
;;
(** [ocaml_libdir conf] uses the [ocamlc] program of the given configuration
to retrieve the library directory.
Return [""] if any error occurs.*)
let ocaml_libdir conf =
match
handle_unix_error
(fun () -> execvp_to_list conf.ocamlc [| "-v" |])
()
with
[] | [_] -> ""
| _ :: l :: _ ->
try
let p = String.index l ':' in
String.sub l (p+2) (String.length l - p - 2)
with
Invalid_argument _
| Not_found ->
""
;;
(** [version_of_ocaml_version_string str] returns a {!type:version} value from
the string representing an ocaml version (which can contain '+', a date, ...). *)
let version_of_ocaml_version_string s =
let len = String.length s in
let b = Buffer.create len in
let rec iter n =
if n < len then
match s.[n] with
'0'..'9' | '.' -> Buffer.add_char b s.[n]; iter (n+1)
| _ -> ()
in
iter 0;
version_of_string (Buffer.contents b)
(** [check_version version prog] tries to run [prog -version] and return
whether the given version string is a suffix of the first line printed.
This function is used to check that an ocaml program has the correct
version number.
@param on_err can be used to indicate another function to call it
the program is not in the correct version. Default is [!]{!fatal_error}.
*)
let check_version ?(on_err= !fatal_error) version prog =
match prog with
"" -> ()
| _ ->
match handle_unix_error
(fun () -> execvp_to_list prog [| "-version" |]) ()
with
[] ->
let s = Printf.sprintf "could not get version of %s" prog in
on_err s
| s :: _ ->
if not (is_suffix ~suf: version s) then
let s = Printf.sprintf "%s is not version %s" prog version in
on_err s
(** [check_conf_version conf] verifies that each program of the given configuration
is of the correct version.
If a program is not in the correct version, [!]{!fatal_error} is called.
*)
let check_conf_versions conf =
List.iter (check_version conf.version_string)
[ conf.ocamlopt ; conf.ocamldep ; conf.ocamldoc ;
conf.ocamllex ; conf.ocamlyacc ; conf.ocamlmklib ;
conf.ocamlmktop ;
(* not yet conf.ocamlprof ; *)
]
(** [check_for_opt_prog version prog] checks whether the [prog.opt] program
is in the required version, and if so returns this program name; else
it returns the given program name. *)
let check_for_opt_prog version prog =
match prog with
"" -> ""
| _ ->
let opt = Printf.sprintf "%s.opt" (Filename.basename prog) in
try
let opt = ocaml_prog opt in
check_version
~on_err:(fun m -> !print (m^"\n"); raise (Program_not_found ""))
version opt;
!print (Printf.sprintf "we can use %s\n" opt);
opt
with
Program_not_found _ -> prog
(** [get_opt_conf conf] returns the same configuration where some program
names have been replaced by the "opt" version (["..../ocamlc.opt"] instead
of ["..../ocamlc"] for example).
To do so, the function verifies if the ".opt" program found for each program
of the configuration is in the same version of the bytecode program.
For [ocamldoc], the program in the [ocamldoc] field is not replaced but the [ocamldoc_opt]
field is set to ["..../ocamldoc.opt"], because both bytecode and native versions
can be used (for example the bytecode version is required to use custom generators).*)
let get_opt_conf conf =
let f = check_for_opt_prog conf.version_string in
{ conf with
ocamlc = f conf.ocamlc ;
ocamlopt = f conf.ocamlopt ;
ocamldoc_opt = f conf.ocamldoc ;
ocamllex = f conf.ocamllex ;
ocamldep = f conf.ocamldep ;
}
(** [ocaml_conf ()] detects and returns the Objective Caml configuration found from the PATH.
The function checks that the programs found are in the same version (see {!check_conf_versions}),
and refer to the ".opt" programs when they are available (see {!get_opt_conf}).
@param withopt can be used to raise a {!Program_not_found} exception if the native code compiler is not found;
default is [false].
@param ocamlfind can be used to end up with a {!Program_not_found} exception if the [ocamlfind] tool is not found;
default is [false].
@raise Program_not found if a required program cannot be found.
*)
let ocaml_conf ?(withopt=false) ?(camlp4=false) ?(ocamlfind=true) () =
let ocamlc = ocaml_prog "ocamlc" in
let version_string = exec_and_get_first_line ocamlc [| "-version" |] in
let version = version_of_ocaml_version_string version_string in
!print (Printf.sprintf "found OCaml version %s (%s)\n" (string_of_version version) version_string);
let conf = {
ocamlc = ocamlc ;
version_string = version_string ;
version = version ;
ocaml = ocaml_prog "ocaml" ;
ocamlopt = ocaml_prog ~err: withopt "ocamlopt" ;
ocamldoc = ocaml_prog "ocamldoc" ;
ocamldoc_opt = "" ;
ocamlyacc = ocaml_prog "ocamlyacc" ;
ocamllex = ocaml_prog "ocamllex" ;
ocamldep = ocaml_prog "ocamldep" ;
ocamlmklib = ocaml_prog "ocamlmklib" ;
ocamlmktop = ocaml_prog "ocamlmktop" ;
ocamlprof = ocaml_prog "ocamlprof" ;
camlp4 = ocaml_prog ~err: camlp4 "camlp4" ;
ocamlfind = ocaml_prog ~err: ocamlfind "ocamlfind" ;
} in
check_conf_versions conf;
get_opt_conf conf
(** [print_conf conf] prints the given configuration using [!]{!print}. *)
let print_conf c =
let sp = Printf.sprintf in
!print (sp "Objective-Caml version %s (%s)\n" (string_of_version c.version) c.version_string);
!print (sp "interpreter: %s\n" c.ocaml);
!print (sp "bytecode compiler: %s\n" c.ocamlc);
!print (sp "native code compiler: %s\n" c.ocamlopt);
!print (sp "documentation generator(s): %s%s\n" c.ocamldoc
(if c.ocamldoc_opt <> "" && c.ocamldoc_opt <> c.ocamldoc then
sp ", %s" c.ocamldoc_opt else ""
)
);
!print (sp "lexer generator: %s\n" c.ocamllex);
!print (sp "parser generator: %s\n" c.ocamlyacc);
!print (sp "dependencies generator: %s\n" c.ocamldep);
!print (sp "library builder: %s\n" c.ocamlmklib);
!print (sp "toplevel builder: %s\n" c.ocamlmktop);
!print (sp "profiler: %s\n" c.ocamlprof);
(match c.camlp4 with "" -> () | s ->
!print (sp "camlp4: %s\n" s));
(match c.ocamlfind with "" -> () | s ->
!print (sp "ocamlfind: %s\n" s))
(** {2:compiling Testing compilation and link} *)
type compilation_mode = [ `Byte | `Opt ]
let string_of_mode = function
`Byte -> "byte"
| `Opt -> "opt"
let ocamlc_of_mode conf = function
`Byte -> conf.ocamlc
| `Opt -> conf.ocamlopt
let string_of_com_args com args =
Printf.sprintf "%s %s"
com
(String.concat " "
(List.map Filename.quote (Array.to_list args)))
let can_compile mode conf ?(includes=[]) ?(options=[]) file =
let ocamlc = ocamlc_of_mode conf mode in
let args = Array.of_list
(
"-c" ::
(List.flatten (List.map (fun s -> [ "-I" ; s]) (remove_empty_strings includes))) @
options @
[file]
)
in
add_to_log (string_of_com_args ocamlc args);
exec_status_ok (execvp_redirect [Out_append_to_file !log_file;Err_to_out] ocamlc args)
let can_compile_prog ?mes mode conf ?includes ?options prog =
(match mes with None -> () | Some s -> !print s);
let res =
handle_unix_error (fun () ->
let file = create_temp_file ~contents: prog () in
try_finalize (can_compile mode conf ?includes ?options) file unlink_f file) ()
in
(match mes with None -> () | Some _ -> !print ((!string_of_bool res)^"\n"));
res
;;
let ocaml_defined ?mes mode conf ?includes ?options v =
handle_unix_error (fun () ->
let prog = Printf.sprintf "let _ = %s;;\n" v in
can_compile_prog ?mes mode conf ?includes ?options prog) ()
;;
let ocaml_value_has_type ?mes mode conf ?includes ?options v t =
handle_unix_error (fun () ->
let prog = Printf.sprintf "let (_ : %s) = %s;;\n" t v in
can_compile_prog ?mes mode conf ?includes prog) ()
;;
let can_link ?mes mode conf ?out ?(includes=[]) ?(libs=[]) ?(options=[]) files =
(match mes with None -> () | Some s -> !print s);
let ocamlc = ocamlc_of_mode conf mode in
let libs = match mode with
`Byte -> libs
| `Opt -> List.map byte_ext_to_opt libs
in
let files = match mode with
`Byte -> files
| `Opt -> List.map byte_ext_to_opt files
in
let outfile = match out with
None -> create_temp_file ~ext: "out" ()
| Some f -> f
in
let args = Array.of_list
(
"-linkall" ::
"-o" :: outfile ::
(List.flatten (List.map (fun s -> ["-I"; s]) (remove_empty_strings includes))) @
libs @
options @
files
)
in
add_to_log (string_of_com_args ocamlc args);
let success =
exec_status_ok (execvp_redirect [Out_append_to_file !log_file; Err_to_out] ocamlc args)
in
(
match out with
None -> unlink_f outfile
| Some _ when not success -> unlink_f outfile
| _ -> ()
);
(match mes with None -> () | Some _ -> !print ((!string_of_bool success)^"\n"));
success
let try_run com = Sys.command com = 0
(** {2:ocamlfind OCamlfind queries} *)
(** [ocamlfind_query conf package] returns the first line printed by "ocamlfind query package".
If an error occurs (the package does not exist, ocamlfind cannot be executed, ...),
the function returns [None].
*)
let ocamlfind_query conf package =
match conf.ocamlfind with
"" -> None
| _ ->
try
match exec_and_get_first_line conf.ocamlfind [| "query"; package |] with
"" -> None
| s -> Some s
with
_ -> None
let ocamlfind_query_version conf package =
match conf.ocamlfind with
"" -> None
| _ ->
try
match exec_and_get_first_line conf.ocamlfind
[| "query" ; "-format" ; "%v" ; package |]
with
"" -> None
| s -> Some s
with
_ -> None
;;
let check_ocamlfind_package ?min_version ?max_version ?(fail=true) ?not_found conf name =
!print (Printf.sprintf "checking for %s... " name);
let not_found =
match not_found with
None ->
begin
function
| `Package_not_installed pkg ->
let msg = Printf.sprintf "Package %s not found\n" pkg in
if fail then
!fatal_error msg
else
!print msg
| `Package_bad_version version ->
let msg =
(Printf.sprintf "Package %s found with version %s, but wanted %s%s%s\n"
name version
(match min_version with
None -> ""
| Some v -> Printf.sprintf ">= %s" (string_of_version v)
)
(match min_version, max_version with
Some _, Some _ -> " and "
| _ -> ""
)
(match max_version with
None -> ""
| Some v -> Printf.sprintf "<= %s" (string_of_version v)
)
)
in
if fail then
!fatal_error msg
else
!print msg
end
| Some f -> f
in
match ocamlfind_query conf name with
None -> not_found (`Package_not_installed name); false
| Some s ->
match min_version, max_version with
None, None -> !print "ok\n"; true
| _ ->
match ocamlfind_query_version conf name with
None -> not_found (`Package_bad_version "<no version>"); false
| Some s ->
let version = version_of_string s in
let min = match min_version with None -> [] | Some v -> v in
let max = match max_version with None -> [max_int] | Some v -> v in
if version < min || version > max then
(
not_found (`Package_bad_version s);
false
)
else
( !print "ok\n" ; true )
;;
(** {2:substs Handling substitutions specification} *)
let substs = Hashtbl.create 37
let add_subst = Hashtbl.replace substs
let subst_val var =
try Hashtbl.find substs var
with Not_found -> ""
let get_substs_list () =
Hashtbl.fold (fun var v acc -> (var,v)::acc) substs []
let output_substs oc =
List.iter
(fun (var, v) -> Printf.fprintf oc "%s=\"%s\"\n" var v)
(get_substs_list ())
let output_substs_to_file file =
let contents = String.concat "\n"
(List.map (fun (var,v) -> Printf.sprintf "%s=\"%s\"" var v) (get_substs_list()))
in
file_of_string ~file ~contents
let add_conf_variables c =
let l =
[ "OCAML", c.ocaml ;
"OCAMLC", c.ocamlc ;
"OCAMLOPT", c.ocamlopt ;
"OCAMLDEP", c.ocamldep ;
"OCAMLDOC", c.ocamldoc ;
"OCAMLDOC_OPT", c.ocamldoc_opt ;
"OCAMLLEX", c.ocamllex ;
"OCAMLYACC", c.ocamlyacc ;
"OCAMLMKLIB", c.ocamlmklib ;
"OCAMLMKTOP", c.ocamlmktop ;
"OCAMLPROF", c.ocamlprof ;
"CAMLP4", c.camlp4 ;
"OCAMLFIND", c.ocamlfind ;
"OCAMLBIN", Filename.dirname c.ocamlc;
"OCAMLLIB", ocaml_libdir c ;
"OCAMLVERSION", string_of_version c.version ;
]
in
List.iter (fun (var,v) -> add_subst var v) l
(*/c==m=[OCaml_conf]=0.12=t==*)
let ocaml_required = [4;12;0]
let conf = ocaml_conf ~camlp4:false ~ocamlfind:true ();;
print_conf conf;;
let _ =
if conf.version << ocaml_required then
let msg = Printf.sprintf "Error: OCaml %s required, but found %s.\n"
(string_of_version ocaml_required) (string_of_version conf.version)
in
!print msg; exit 1
let modes = `Byte :: (if conf.ocamlopt = "" then [] else [`Opt])
let _ = !print "\n### checking required tools and libraries ###\n"
let () =
if check_ocamlfind_package conf ~fail: false "lablgtk3" then
begin
add_subst "GTK_PACKAGES" "lablgtk3";
add_subst "LIB_GTK" "odot_gtk.cmx";
add_subst "LIB_GTK_BYTE" "odot_gtk.cmo"
end
;;
let _ = !print "\n###\n"
let _ = add_conf_variables conf
let _ =
if Array.length Sys.argv < 2 then
!fatal_error "No output file given for substitutions!"
else
output_substs_to_file Sys.argv.(1)
| (*********************************************************************************)
(* OCamldot *)
(* *)
(* Copyright (C) 2005-2012 Institut National de Recherche en Informatique et *)
(* en Automatique. All rights reserved. *)
(* *)
(* This program is free software; you can redistribute it and/or modify *)
(* it under the terms of the GNU Lesser General Public License version *)
(* 3 as published by the Free Software Foundation. *)
(* *)
(* This program is distributed in the hope that it will be useful, *)
(* but WITHOUT ANY WARRANTY; without even the implied warranty of *)
(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *)
(* GNU Lesser General Public License for more details. *)
(* *)
(* You should have received a copy of the GNU Lesser Public License *)
(* along with this program; if not, write to the Free Software *)
(* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA *)
(* 02111-1307 USA *)
(* *)
(* Contact: Maxence.Guesdon@inria.fr *)
(*********************************************************************************)
|
ps_status.h | /*-------------------------------------------------------------------------
*
* ps_status.h
*
* Declarations for backend/utils/misc/ps_status.c
*
* src/include/utils/ps_status.h
*
*-------------------------------------------------------------------------
*/
#ifndef PS_STATUS_H
#define PS_STATUS_H
extern bool update_process_title;
extern char **save_ps_display_args(int argc, char **argv);
extern void init_ps_display(const char *fixed_part);
extern void set_ps_display(const char *activity);
extern const char *get_ps_display(int *displen);
#endif /* PS_STATUS_H */
| /*-------------------------------------------------------------------------
*
* ps_status.h
*
* Declarations for backend/utils/misc/ps_status.c
*
* src/include/utils/ps_status.h
*
*-------------------------------------------------------------------------
*/ |
counter_client.ml |
type counter
external counter_new : unit -> counter = "counter_new"
external counter_inc : counter -> unit = "counter_inc"
external counter_read : counter -> int = "counter_read"
let () = begin
print_endline "[counter_test][info]: start";
let counter = counter_new () in
assert (counter_read counter == 0);
counter_inc counter;
assert (counter_read counter == 1);
print_endline "[counter_test][info]: finish";
end
| (*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*) |
dune |
(executable
(name pp))
| |
polynomial.ml | module type Arith = sig
type t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val to_string : t -> string
end
module Make (T : Arith) = struct
type scalar = T.t
type monomial = { coef: T.t; degree: int }
type elt = monomial list
type t = elt
let make_monomial c d =
{ coef = c; degree = d }
let create () = []
let of_monomial m = [m]
let make (l : elt) : t = l
let get (p : t) : elt = p
let to_string p =
String.concat
" + "
(List.map
(fun m ->
(T.to_string m.coef) ^
if m.degree = 0 then
""
else
("x^{" ^ (string_of_int m.degree) ^ "}")
)
p
)
let const f =
make_monomial f 0
let scale p a =
List.map (fun m -> { m with coef = T.mul a m.coef }) p
let neg p =
List.map (fun m -> { coef = T.neg m.coef; degree = m.degree }) p
let add p1 p2 =
let rec add r p1 p2 =
match p1, p2 with
| [], [] -> List.rev r
| _, [] -> List.rev (List.rev_append p1 r)
| [], _ -> List.rev (List.rev_append p2 r)
| h1::t1, h2::t2 ->
if h1.degree = h2.degree then
let mono = { coef = T.add h1.coef h2.coef; degree = h1.degree } in
add (mono::r) t1 t2
else if h1.degree < h2.degree then
add (h1::r) t1 p2
else (* h2.degree < h1.degree *)
add (h2::r) p1 t2
in
add [] p1 p2
let translate p a =
add p [{coef = a; degree = 0}]
let sub p1 p2 =
add p1 (neg p2)
let mul p1 p2 =
let mul_mono m1 m2 =
{ coef = T.mul m1.coef m2.coef; degree = m1.degree + m2.degree }
in
let add_scale r p m =
add r (List.map (fun x -> mul_mono m x) p)
in
List.fold_left (fun r m -> add_scale r p2 m) [] p1
let div p1 p2 =
raise (Failure "Polynomial.div not implemented")
let ( ~+ ) p = p
let ( ~- ) = neg
let ( + ) = add
let ( - ) = sub
let ( * ) = mul
let ( / ) = div
end
| (**************************************************************************)
(* *)
(* FADBADml *)
(* *)
(* OCaml port by François Bidet and Ismail Bennani *)
(* Based on FADBAD++, written by Ole Stauning and Claus Bendtsen *)
(* *)
(* Copyright 2019-2020 *)
(* *)
(* This file is distributed under the terms of the CeCILL-C license. *)
(* *)
(**************************************************************************)
|
thing.c |
// thing.c
// strange casts to 'void' on pointer comparisons??
struct Thing *thing;
int test()
{
return thing == 0;
}
int main()
{
test();
return 0;
}
| |
container.mli |
type 'a t
(** The type for containers. *)
(*@ model capacity: int
mutable model contents: 'a set
invariant capacity > 0
invariant Set.cardinal contents <= capacity *)
exception Full
val create: int -> 'a t
(** [create capacity] is an empty container whose maximum capacity
is [capacity]. *)
(*@ t = create c
requires c > 0
ensures t.capacity = c
ensures t.contents = Set.empty *)
val is_empty: 'a t -> bool
(** [is_empty t] is [true] iff [t] contains no elements. *)
(*@ b = is_empty t
pure
ensures b <-> t.contents = Set.empty *)
val clear: 'a t -> unit
(** [clear t] removes all values in [t]. *)
(*@ clear t
modifies t.contents
ensures is_empty t *)
val add: 'a t -> 'a -> unit
(** [add t x] adds [x] to the container [t], or raises [Full] if
[t] has reached its maximum capacity. *)
(*@ add t x
modifies t.contents
ensures t.contents = Set.add x (old t.contents)
raises Full -> Set.cardinal (old t.contents) = t.capacity
/\ t.contents = old t.contents *)
val mem: 'a t -> 'a -> bool
(** [mem t x] is [true] iff [t] contains [x]. *)
(*@ b = mem t x
pure
ensures b <-> Set.mem x t.contents *)
| |
digamma.c |
#include "acb.h"
void acb_hypgeom_gamma_stirling_choose_param(int * reflect, slong * r, slong * n,
const acb_t x, int use_reflect, int digamma, slong prec);
void acb_gamma_stirling_eval(acb_t s, const acb_t z, slong nterms, int digamma, slong prec);
void
acb_digamma(acb_t y, const acb_t x, slong prec)
{
int reflect;
slong r, n, wp;
acb_t t, u, v;
if (acb_is_real(x))
{
arb_digamma(acb_realref(y), acb_realref(x), prec);
arb_zero(acb_imagref(y));
return;
}
wp = prec + FLINT_BIT_COUNT(prec);
acb_hypgeom_gamma_stirling_choose_param(&reflect, &r, &n, x, 1, 1, wp);
acb_init(t);
acb_init(u);
acb_init(v);
/* psi(x) = psi((1-x)+r) - h(1-x,r) - pi*cot(pi*x) */
if (reflect)
{
acb_sub_ui(t, x, 1, wp);
acb_neg(t, t);
acb_cot_pi(v, x, wp);
arb_const_pi(acb_realref(u), wp);
acb_mul_arb(v, v, acb_realref(u), wp);
acb_rising2_ui(y, u, t, r, wp);
acb_div(u, u, y, wp);
acb_add(v, v, u, wp);
acb_add_ui(t, t, r, wp);
acb_gamma_stirling_eval(u, t, n, 1, wp);
acb_sub(y, u, v, wp);
}
else
{
acb_add_ui(t, x, r, wp);
acb_gamma_stirling_eval(u, t, n, 1, wp);
acb_rising2_ui(y, t, x, r, wp);
acb_div(t, t, y, wp);
acb_sub(y, u, t, prec);
}
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
| /*
Copyright (C) 2013 Fredrik Johansson
This file is part of Arb.
Arb is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License (LGPL) as published
by the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version. See <http://www.gnu.org/licenses/>.
*/ |
http.curl.ml |
open Support
open Support.Common
let init = lazy (
Curl.(global_init CURLINIT_GLOBALALL);
)
let is_redirect connection =
let code = Curl.get_httpcode connection in
code >= 300 && code < 400
(** Download the contents of [url] into [ch].
* This runs in a separate (either Lwt or native) thread. *)
let download_no_follow ~cancelled ?size ?modification_time ?(start_offset=Int64.zero) ~progress connection ch url =
let skip_bytes = ref (Int64.to_int start_offset) in
let error_buffer = ref "" in
Lwt.catch (fun () ->
let redirect = ref None in
let check_header header =
if XString.starts_with (String.lowercase_ascii header) "location:" then (
redirect := Some (XString.tail header 9 |> String.trim)
);
String.length header in
if Support.Logging.will_log Support.Logging.Debug then Curl.set_verbose connection true;
Curl.set_errorbuffer connection error_buffer;
Curl.set_writefunction connection (fun data ->
if !cancelled then 0
else (
try
let l = String.length data in
if !skip_bytes >= l then (
skip_bytes := !skip_bytes - l
) else (
output ch (Bytes.unsafe_of_string data) !skip_bytes (l - !skip_bytes);
skip_bytes := 0
);
l
with ex ->
log_warning ~ex "Failed to write download data to temporary file";
error_buffer := !error_buffer ^ Printexc.to_string ex;
0
)
);
Curl.set_maxfilesizelarge connection (default Int64.zero size);
begin match modification_time with
| Some modification_time ->
Curl.set_timecondition connection Curl.TIMECOND_IFMODSINCE;
Curl.set_timevalue connection (Int32.of_float modification_time); (* Warning: 32-bit time *)
| None ->
(* ocurl won't let us unset timecondition, but at least we can make sure it never happens *)
Curl.set_timevalue connection (Int32.zero) end;
Curl.set_url connection url;
Curl.set_useragent connection ("0install/" ^ About.version);
Curl.set_headerfunction connection check_header;
Curl.set_progressfunction connection (fun dltotal dlnow _ultotal _ulnow ->
if !cancelled then true (* Don't override the finished=true signal *)
else (
let dlnow = Int64.of_float dlnow in
begin match size with
| Some _ -> progress (dlnow, size, false)
| None ->
let total = if dltotal = 0.0 then None else Some (Int64.of_float dltotal) in
progress (dlnow, total, false) end;
false (* (continue download) *)
)
);
Curl.set_noprogress connection false; (* progress = true *)
Curl_lwt.perform connection >|= fun result ->
(* Check for redirect header first because for large redirect bodies we
may get a size-exceeded error rather than CURLE_OK. *)
match !redirect with
| Some target when is_redirect connection ->
(* ocurl is missing CURLINFO_REDIRECT_URL, so we have to do this manually *)
let target = Support.Urlparse.join_url url target in
log_info "Redirect from '%s' to '%s'" url target;
`Redirect target
| _ ->
match result with
| Curl.CURLE_OK ->
begin
let actual_size = Curl.get_sizedownload connection in
(* Curl.cleanup connection; - leave it open for the next request *)
if modification_time <> None && actual_size = 0.0 then (
`Unmodified (* ocurl is missing CURLINFO_CONDITION_UNMET *)
) else (
size |> if_some (fun expected ->
let expected = Int64.to_float expected in
if expected <> actual_size then
Safe_exn.failf "Downloaded archive has incorrect size.\n\
URL: %s\n\
Expected: %.0f bytes\n\
Received: %.0f bytes" url expected actual_size
);
log_info "Download '%s' completed successfully (%.0f bytes)" url actual_size;
`Success
)
end
| code -> raise Curl.(CurlException (code, errno code, strerror code))
)
(function
| Curl.CurlException _ as ex ->
if !cancelled then Lwt.return `Aborted_by_user
else (
log_info ~ex "Curl error: %s" !error_buffer;
let msg = Printf.sprintf "Error downloading '%s': %s" url !error_buffer in
Lwt.return (`Network_failure msg)
)
| ex -> raise ex
)
let post ~data url =
let error_buffer = ref "" in
let connection = Curl.init () in
Curl.set_nosignal connection true; (* Can't use DNS timeouts when multi-threaded *)
Curl.set_failonerror connection true;
if Support.Logging.will_log Support.Logging.Debug then Curl.set_verbose connection true;
Curl.set_errorbuffer connection error_buffer;
let output_buffer = Buffer.create 256 in
Curl.set_writefunction connection (fun data ->
Buffer.add_string output_buffer data;
String.length data
);
Curl.set_url connection url;
Curl.set_post connection true;
Curl.set_postfields connection data;
Curl.set_postfieldsize connection (String.length data);
Lwt.finalize
(fun () -> Curl_lwt.perform connection)
(fun () -> Curl.cleanup connection; Lwt.return ())
>|= function
| Curl.CURLE_OK -> Ok (Buffer.contents output_buffer)
| code ->
let msg = Curl.strerror code in
log_info "Curl error: %s\n%s" msg !error_buffer;
Error (msg, !error_buffer)
module Connection = struct
type t = Curl.t
let create () =
Lazy.force init;
let t = Curl.init () in
Curl.set_nosignal t true; (* Can't use DNS timeouts when multi-threaded *)
Curl.set_failonerror t true;
Curl.set_followlocation t false;
Curl.set_netrc t Curl.CURL_NETRC_OPTIONAL;
t
let release = Curl.cleanup
let get = download_no_follow
end
let escape = Curl.escape
let variant = "libcurl (C)"
| |
hasher.ml |
open! Import
(** Signatures required of types which can be used in [[@@deriving hash]]. *)
module type S = sig
(** The type that is hashed. *)
type t
(** [hash_fold_t state x] mixes the content of [x] into the [state].
By default, all our [hash_fold_t] functions (derived or not) should satisfy the
following properties.
1. [hash_fold_t state x] should mix all the information present in [x] in the state.
That is, by default, [hash_fold_t] will traverse the full term [x] (this is a
significant change for Hashtbl.hash which by default stops traversing the term after
after considering a small number of "significant values"). [hash_fold_t] must not
discard the [state].
2. [hash_fold_t] must be compatible with the associated [compare] function: that is,
for all [x] [y] and [s], [compare x y = 0] must imply [hash_fold_t s x = hash_fold_t
s y].
3. To avoid avoid systematic collisions, [hash_fold_t] should expand to different
sequences of built-in mixing functions for different values of [x]. No such sequence
is allowed to be a prefix of another.
A common mistake is to implement [hash_fold_t] of a collection by just folding all
the elements. This makes the folding sequence of [a] be a prefix of [a @ b], thereby
violating the requirement. This creates large families of collisions: all of the
following collections would hash the same:
{v
[[]; [1;2;3]]
[[1]; [2;3]]
[[1; 2]; [3]]
[[1; 2; 3]; []]
[[1]; [2]; []; [3];]
...
v}
A good way to avoid this is to mix in the size of the collection to the beginning
([fold ~init:(hash_fold_int state length) ~f:hash_fold_elem]). The default in our
libraries is to mix the length of the structure before folding. To prevent the
aforementioned collisions, one should respect this ordering.
*)
val hash_fold_t : Hash.state -> t -> Hash.state
end
module type S1 = sig
type 'a t
val hash_fold_t : (Hash.state -> 'a -> Hash.state) -> Hash.state -> 'a t -> Hash.state
end
| |
events.c |
#include <mini-os/os.h>
#include <mini-os/mm.h>
#include <mini-os/events.h>
#if defined(__x86_64__)
char irqstack[2 * STACK_SIZE];
static struct pda
{
int irqcount; /* offset 0 (used in x86_64.S) */
char *irqstackptr; /* 8 */
} cpu0_pda;
#endif
void arch_init_events(void)
{
#if defined(__x86_64__)
asm volatile("movl %0,%%fs ; movl %0,%%gs" :: "r" (0));
wrmsrl(0xc0000101, &cpu0_pda); /* 0xc0000101 is MSR_GS_BASE */
cpu0_pda.irqcount = -1;
cpu0_pda.irqstackptr = (void*) (((unsigned long)irqstack + 2 * STACK_SIZE)
& ~(STACK_SIZE - 1));
#endif
}
void arch_unbind_ports(void)
{
}
void arch_fini_events(void)
{
#if defined(__x86_64__)
wrmsrl(0xc0000101, NULL); /* 0xc0000101 is MSR_GS_BASE */
#endif
}
| |
operation_hash.mli | include S.HASH
module Logging : sig
val tag : t Tag.def
end
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
accessor_set.mli |
open! Base
open! Import
(** Access whether a key is present in the set. [true] means the key is present, and
[false] means it is absent. *)
val mem : 'key -> (_, bool, ('key, _) Set.t, [< field ]) Accessor.t
val at : 'key -> (_, bool, ('key, _) Set.t, [< field ]) Accessor.t
[@@deprecated "[since 2020-09] Use [mem] instead of [at]"]
(** The indexed version of [mem] adds the given key to the index. *)
val memi : 'key -> ('key * _, bool, ('key, _) Set.t, [< field ]) Accessor.Indexed.t
val ati : 'key -> ('key * _, bool, ('key, _) Set.t, [< field ]) Accessor.Indexed.t
[@@deprecated "[since 2020-09] Use [memi] instead of [ati]"]
(** Access [()] iff the set contains the given key. *)
val found : 'key -> (_, unit, ('key, _) Set.t, [< optional ]) Accessor.t
(** The indexed version of [found] adds the given key to the index. *)
val foundi : 'key -> ('key * _, unit, ('key, _) Set.t, [< optional ]) Accessor.Indexed.t
(** Access every element in a set. *)
val each
: ('i -> 'key -> _, 'i -> ('key, 'cmp) Set.t -> _, [< many_getter ]) Accessor.General.t
(** Treat [None] equivalently with the empty set. This accessor is not well-behaved, as it
violates [construct (get at) = at]:
[construct (get (Some Foo.Set.empty)) = construct Foo.Set.empty = None] *)
val empty_default
: ('k1, 'cmp1) Comparator.Module.t
-> ( 'i -> ('k1, 'cmp1) Set.t -> ('k2, 'cmp2) Set.t
, 'i -> ('k1, 'cmp1) Set.t option -> ('k2, 'cmp2) Set.t option
, [< isomorphism ] )
Accessor.General.t
(** [of_accessor (module M) accessor x] is a [M.Set.t] that contains everything accessed
by [accessor] in [x]. *)
val of_accessor
: ('a, 'cmp) Comparator.Module.t
-> (unit -> 'a -> _, unit -> 'at -> _, [> many_getter ]) Accessor.General.t
-> 'at
-> ('a, 'cmp) Set.t
| |
bzlamodel.h |
#ifndef BZLAMODEL_H_INCLUDED
#define BZLAMODEL_H_INCLUDED
#include "bzlabv.h"
#include "bzlacore.h"
#include "bzlanode.h"
#include "utils/bzlahashint.h"
/*------------------------------------------------------------------------*/
/**
* Get AIG vector assignment of given node as bit-vector.
* Zero initialized if unconstrained.
*/
BzlaBitVector* bzla_model_get_bv_assignment(Bzla* bzla, BzlaNode* exp);
BzlaBitVector* bzla_model_recursively_compute_assignment(
Bzla* bzla,
BzlaIntHashTable* bv_model,
BzlaIntHashTable* fun_model,
BzlaNode* exp);
void bzla_model_generate(Bzla* bzla,
BzlaIntHashTable* bv_model,
BzlaIntHashTable* fun_model,
bool model_for_all_nodes);
/*------------------------------------------------------------------------*/
void bzla_model_delete(Bzla* bzla);
void bzla_model_delete_bv(Bzla* bzla, BzlaIntHashTable** bv_model);
/*------------------------------------------------------------------------*/
void bzla_model_init_bv(Bzla* bzla, BzlaIntHashTable** bv_model);
void bzla_model_init_fun(Bzla* bzla, BzlaIntHashTable** fun_model);
/*------------------------------------------------------------------------*/
BzlaIntHashTable* bzla_model_clone_bv(Bzla* bzla,
BzlaIntHashTable* bv_model,
bool inc_ref_cnt);
BzlaIntHashTable* bzla_model_clone_fun(Bzla* bzla,
BzlaIntHashTable* fun_model,
bool inc_ref_cnt);
/*------------------------------------------------------------------------*/
const BzlaBitVector* bzla_model_get_bv(Bzla* bzla, BzlaNode* exp);
const BzlaBitVector* bzla_model_get_bv_aux(Bzla* bzla,
BzlaIntHashTable* bv_model,
BzlaIntHashTable* fun_model,
BzlaNode* exp);
const BzlaPtrHashTable* bzla_model_get_fun(Bzla* bzla, BzlaNode* exp);
const BzlaPtrHashTable* bzla_model_get_fun_aux(Bzla* bzla,
BzlaIntHashTable* bv_model,
BzlaIntHashTable* fun_model,
BzlaNode* exp);
void bzla_model_get_array_model(Bzla* bzla,
BzlaNode* exp,
BzlaNodePtrStack* indices,
BzlaNodePtrStack* values,
BzlaNode** default_value);
void bzla_model_get_fun_model(Bzla* bzla,
BzlaNode* exp,
BzlaNodePtrStack* args,
BzlaNodePtrStack* values);
/**
* Get node representation of the model value of the given node.
*
* For bit-vector nodes, the returned node is a bit-vector const node.
* For arrays, the returned node is a write chain.
* For functions, the returned node is an ite chain over the argument values.
*/
BzlaNode* bzla_model_get_value(Bzla* bzla, BzlaNode* exp);
/*------------------------------------------------------------------------*/
void bzla_model_add_to_bv(Bzla* bzla,
BzlaIntHashTable* bv_model,
BzlaNode* exp,
const BzlaBitVector* assignment);
void bzla_model_remove_from_bv(Bzla* bzla,
BzlaIntHashTable* bv_model,
BzlaNode* exp);
/*------------------------------------------------------------------------*/
#endif
| /***
* Bitwuzla: Satisfiability Modulo Theories (SMT) solver.
*
* This file is part of Bitwuzla.
*
* Copyright (C) 2007-2021 by the authors listed in the AUTHORS file.
*
* See COPYING for more information on using this software.
*/ |
client_proto_utils_commands.ml | open Client_proto_utils
let group = {Clic.name = "utilities"; title = "Utility Commands"}
let commands () =
let open Clic in
let string_param ~name ~desc =
param ~name ~desc Client_proto_args.string_parameter
in
let block_arg =
default_arg
~long:"branch"
~short:'b'
~placeholder:"hash|tag"
~doc:
"Block hash used to create the no-op operation to sign (possible tags \
are 'head' and 'genesis'). Defaults to 'genesis'. Note that the the \
genesis block hash is network-dependent."
~default:(Block_services.to_string `Genesis)
(Client_config.block_parameter ())
in
[
command
~group
~desc:
"Sign a message and display it using the failing_noop operation. This \
operation is not executable in the protocol. Please note that \
signing/checking an arbitrary message in itself is not sufficient to \
verify a key ownership"
(args1 block_arg)
(prefixes ["sign"; "message"]
@@ string_param ~name:"message" ~desc:"message to sign"
@@ prefixes ["for"]
@@ Client_keys.Secret_key.source_param
~name:"src"
~desc:"name of the signer contract"
@@ stop)
(fun block_head message src_sk cctxt ->
Shell_services.Blocks.hash cctxt ~chain:cctxt#chain ~block:block_head ()
>>=? fun block ->
sign_message cctxt ~src_sk ~block ~message >>=? fun signature ->
cctxt#message "Signature: %a" Signature.pp signature >>= fun () ->
return_unit);
command
~group
~desc:
"Check the signature of an arbitrary message using the failing_noop \
operation. Please note that signing/checking an arbitrary message in \
itself is not sufficient to verify a key ownership."
(args2
block_arg
(switch ~doc:"Use only exit codes" ~short:'q' ~long:"quiet" ()))
(prefixes ["check"; "that"; "message"]
@@ string_param ~name:"message" ~desc:"signed message"
@@ prefixes ["was"; "signed"; "by"]
@@ Client_keys.Public_key.alias_param
~name:"signer"
~desc:"name of the signer contract"
@@ prefixes ["to"; "produce"]
@@ param
~name:"signature"
~desc:"the signature to check"
Client_proto_args.signature_parameter
@@ stop)
(fun (block_head, quiet)
message
(_, (key_locator, _))
signature
(cctxt : #Protocol_client_context.full) ->
Shell_services.Blocks.hash cctxt ~chain:cctxt#chain ~block:block_head ()
>>=? fun block ->
check_message cctxt ~key_locator ~block ~quiet ~message ~signature
>>=? function
| false -> cctxt#error "invalid signature"
| true ->
if quiet then return_unit
else
cctxt#message "Signature check successful" >>= fun () ->
return_unit);
]
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2020 Metastate AG <hello@metastate.ch> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
enum3f.c | /* test support for large constants in enums (gcc-specific)
if you ask me, gcc's behaviour is a bit weird, but... */
enum fun {
SMALL = 33,
STRANGE = 44LL,
LARGE = 22LL << 34
};
long long magic1 = 22LL << 34;
enum fun magic2 = LARGE;
int main()
{
int ok = 1;
ok = ok && (LARGE + 1 == magic1 + 1);
return ok ? 0 : 2;
}
| /* test support for large constants in enums (gcc-specific)
if you ask me, gcc's behaviour is a bit weird, but... */ |
dune |
(library
(name database)
(libraries sihl))
| |
helpers.ml |
open Internal_pervasives
open Console
let dump_connection =
let open EF in
let open Tezos_node in
function
| `Duplex (na, nb) ->
af "%s:%d <-> %s:%d" na.id na.p2p_port nb.id nb.p2p_port
| `From_to (na, nb) ->
haf "%s:%d --> %s:%d" na.id na.p2p_port nb.id nb.p2p_port
| `Missing (na, int) ->
ksprintf shout "%s:%d --> ???:%d" na.id na.p2p_port int
let dump_connections state nodes =
let conns = Tezos_node.connections nodes in
say state
(let open EF in
desc_list (haf "Connections:") (List.map conns ~f:dump_connection))
let clear_root state =
let root = Paths.(root state) in
System_error.catch
(fun () -> ksprintf Lwt_unix.system "rm -fr %s" (Caml.Filename.quote root))
()
>>= function
| Unix.WEXITED 0 -> return ()
| _ -> System_error.fail_fatalf "cannot delete root path (%S)" root
let wait_for ?(attempts_factor = 0.) state ~attempts ~seconds f =
let rec attempt nth =
let again () = attempt (nth + 1) in
f nth
>>= function
| `Done x -> return x
| `Not_done msg when nth < attempts ->
let sleep_time = Float.((attempts_factor * of_int nth) + seconds) in
say state
EF.(
wf "%s: attempt %d/%d, sleeping %.02f seconds" msg nth attempts
sleep_time)
>>= fun () -> System.sleep sleep_time >>= fun () -> again ()
| `Not_done msg -> fail (`Waiting_for (msg, `Time_out)) in
attempt 1
let kill_node state nod =
Running_processes.find_process_by_id ~only_running:true state
~f:(String.( = ) nod.Tezos_node.id)
>>= fun states ->
( match states with
| [one] -> return one
| _ ->
System_error.fail_fatalf "Expecting one state for node %s"
nod.Tezos_node.id )
>>= fun node_state_0 -> Running_processes.kill state node_state_0
let restart_node ~client_exec state nod =
Running_processes.start state (Tezos_node.process state nod)
>>= fun _ ->
let client = Tezos_client.of_node nod ~exec:client_exec in
say state
EF.(wf "Started node %s, waiting for bootstrap …" nod.Tezos_node.id)
>>= fun () -> Tezos_client.wait_for_node_bootstrap state client
module Counter_log = struct
type t = (string * int) list ref
let create () = ref []
let add t s n = t := (s, n) :: !t
let incr t s = add t s 1
let sum t = List.fold !t ~init:0 ~f:(fun prev (_, s) -> prev + s)
let to_table_string t =
let total = "**Total:**" in
let longest =
List.fold !t ~init:total ~f:(fun p (n, _) ->
if String.length p < String.length n then n else p) in
List.rev_map
((total, sum t) :: !t)
~f:(fun (cmt, n) ->
sprintf "| %s %s|% 8d|" cmt
(String.make (String.length longest - String.length cmt + 2) '.')
n)
|> String.concat ~sep:"\n"
end
module Netstat = struct
let check_version state =
Running_processes.run_cmdf state "netstat --version"
>>= fun version_res ->
match version_res#status with
| Unix.WEXITED 0 ->
(* This is a linux-ish netstat: *)
return `Fine
| _ -> return `Not_right
let netstat_dash_nut state =
check_version state
>>= function
| `Fine ->
Running_processes.run_cmdf state "netstat -nut"
>>= fun res ->
Process_result.Error.fail_if_non_zero res "netstat -nut command"
>>= fun () ->
let rows =
List.filter_mapi res#out ~f:(fun idx line ->
match
String.split line ~on:' '
|> List.filter_map ~f:(fun s ->
match String.strip s with "" -> None | s -> Some s)
with
| ("tcp" | "tcp6") :: _ as row -> Some (`Tcp (idx, row))
| _ -> Some (`Wrong (idx, line))) in
return rows
| `Not_right ->
Console.say state
EF.(
desc (shout "Warning:")
(wf
"This does not look like a linux-netstat; port-availability \
checks are hence disabled."))
>>= fun () -> return []
let all_listening_ports rows =
List.filter_map rows ~f:(function
| `Tcp (_, _ :: _ :: _ :: addr :: _) as row -> (
match String.split addr ~on:':' with
| [_; port] -> ( try Some (Int.of_string port, row) with _ -> None )
| _ -> None )
| _ -> None)
let used_listening_ports state =
netstat_dash_nut state
>>= fun rows ->
let all_used = all_listening_ports rows in
return all_used
end
module System_dependencies = struct
module Error = struct
type t = [`Precheck_failure of string]
let pp fmt (`Precheck_failure f) =
Caml.Format.fprintf fmt "Failed precheck: %S" f
let failf fmt =
Caml.Format.kasprintf (fun s -> fail (`Precheck_failure s)) fmt
end
open Error
let precheck ?(using_docker = false) ?(protocol_paths = [])
?(executables : Tezos_executable.t list = []) state how_to_react =
let commands_to_check =
(if using_docker then ["docker"] else [])
@ ["setsid"; "curl"; "netstat"]
@ List.map executables ~f:Tezos_executable.get in
List.fold ~init:(return []) commands_to_check ~f:(fun prev_m cmd ->
prev_m
>>= fun prev ->
Running_processes.run_cmdf state "type %s" (Caml.Filename.quote cmd)
>>= fun result ->
match result#status with
| Unix.WEXITED 0 -> return prev
| _ -> return (`Missing_exec (cmd, result) :: prev))
>>= fun errors_or_warnings ->
Netstat.check_version state
>>= (function
| `Fine -> return errors_or_warnings
| `Not_right -> return (`Wrong_netstat :: errors_or_warnings))
>>= fun errors_or_warnings ->
List.fold protocol_paths ~init:(return errors_or_warnings)
~f:(fun prev_m path ->
prev_m
>>= fun prev ->
System_error.catch Lwt_unix.file_exists (path // "TEZOS_PROTOCOL")
>>= function
| true -> return prev
| false -> return (`Not_a_protocol_path path :: prev))
>>= fun errors_or_warnings ->
match (errors_or_warnings, how_to_react) with
| [], _ -> return ()
| more, `Or_fail -> (
let is_not_just_a_warning = function
| `Wrong_netstat | `Missing_exec ("netstat", _) -> false
| `Missing_exec _ | `Not_a_protocol_path _ -> true in
Console.sayf state
Fmt.(
fun ppf () ->
vbox ~indent:2
(fun ppf () ->
string ppf "System dependencies failed precheck:" ;
List.iter more ~f:(fun item ->
cut ppf () ;
box ~indent:2
(fun ppf () ->
pf ppf "* %s "
( if is_not_just_a_warning item then "Fatal-error:"
else "Warning:" ) ;
match item with
| `Missing_exec (path, _) ->
(* pp_open_hovbox ppf 0 ; *)
kstr (text ppf) "Missing executable `%s`." path
| `Wrong_netstat -> text ppf "Wrong netstat version."
| `Not_a_protocol_path path ->
kstr (text ppf) "`%s` is not a protocol." path)
ppf ()))
ppf ())
>>= fun () ->
( if
List.exists more ~f:(function
| `Wrong_netstat | `Missing_exec ("setsid", _) -> true
| _ -> false)
then
Console.say state
EF.(
desc (shout "Warning:")
(wf
"This does not look like a standard Linux-ish environment. \
If you are on MacOSX, see \
https://gitlab.com/tezos/flextesa/blob/master/README.md#macosx-users "))
else return () )
>>= fun () ->
( if
List.exists more ~f:(function
| `Missing_exec ("tezos-node", _)
when Caml.Sys.file_exists ("." // "tezos-node") ->
true
| _ -> false)
then
Console.say state
EF.(
desc (prompt "Tip:")
(wf
"The `tezos-node` executable is missing but there seems to \
be one in the current directory, maybe you can pass \
`./tezos-node` with the right option (see `--help`) or \
simply add `export PATH=.:$PATH` to allow unix tools to \
find it."))
else return () )
>>= fun () ->
let non_warning_errors = List.filter more ~f:is_not_just_a_warning in
match non_warning_errors with
| [] ->
Console.say state
EF.(
wf "Pre-check noticed only %d warnings, no errors"
(List.length more))
| _ ->
failf "%d errors were raised during precheck."
(List.length non_warning_errors) )
end
module Shell_environment = struct
type t = {aliases: (string * string * string) list}
let make ~aliases = {aliases}
let build state ~clients =
let aliases =
List.concat_mapi clients ~f:(fun i c ->
let call =
List.map ~f:Caml.Filename.quote
(Tezos_client.client_call state c []) in
let cmd exec = String.concat ~sep:" " (exec :: call) in
let extra =
let help = "Call the tezos-client used by the sandbox." in
match Tezos_executable.get c.Tezos_client.exec with
| "tezos-client" -> []
| f when Caml.Filename.is_relative f ->
[(sprintf "c%d" i, cmd (Caml.Sys.getcwd () // f), help)]
| f -> [(sprintf "c%d" i, cmd (Caml.Sys.getcwd () // f), help)]
in
[ ( sprintf "tc%d" i
, cmd "tezos-client"
, "Call the `tezos-client` from the path." ) ]
@ extra) in
make ~aliases
let write state {aliases} ~path =
let content =
String.concat ~sep:"\n"
( ["# Shell-environment generated by a flextesa-sandbox"]
@ List.concat_map aliases ~f:(fun (k, v, doc) ->
[ sprintf "echo %s"
(sprintf "Defining alias %s: %s" k doc |> Caml.Filename.quote)
; sprintf "alias %s=%s" k (Caml.Filename.quote v) ]) ) in
System.write_file state path ~content
let help_command state t ~path =
Console.Prompt.unit_and_loop
~description:"Show help about the shell-environment." ["help-env"]
(fun _sexps ->
Console.sayf state
More_fmt.(
fun ppf () ->
let pick_and_alias ppf () =
let k, _, _ = List.random_element_exn t.aliases in
string ppf k in
vertical_box ~indent:2 ppf (fun ppf ->
tag "prompt" ppf (fun ppf -> wf ppf "Shell Environment") ;
cut ppf () ;
wf ppf "* A loadable shell environment is available at `%s`."
path ;
cut ppf () ;
wf ppf
"* It contains %d POSIX-shell aliases (compatible with \
`bash`, etc.)."
(List.length t.aliases) ;
cut ppf () ;
cut ppf () ;
wf ppf "Example:" ;
cut ppf () ;
cut ppf () ;
pf ppf " . %s" path ;
cut ppf () ;
pf ppf " %a list known addresses" pick_and_alias () ;
cut ppf () ;
pf ppf " %a rpc get /chains/main/blocks/head/metadata"
pick_and_alias () ;
cut ppf ())))
end
| |
voting_period_repr.ml | type kind = Proposal | Testing_vote | Testing | Promotion_vote | Adoption
let string_of_kind = function
| Proposal ->
"proposal"
| Testing_vote ->
"testing_vote"
| Testing ->
"testing"
| Promotion_vote ->
"promotion_vote"
| Adoption ->
"adoption"
let pp_kind ppf kind = Format.fprintf ppf "%s" @@ string_of_kind kind
let kind_encoding =
let open Data_encoding in
union
~tag_size:`Uint8
[ case
(Tag 0)
~title:"Proposal"
(constant "proposal")
(function Proposal -> Some () | _ -> None)
(fun () -> Proposal);
case
(Tag 1)
~title:"Testing_vote"
(constant "testing_vote")
(function Testing_vote -> Some () | _ -> None)
(fun () -> Testing_vote);
case
(Tag 2)
~title:"Testing"
(constant "testing")
(function Testing -> Some () | _ -> None)
(fun () -> Testing);
case
(Tag 3)
~title:"Promotion_vote"
(constant "promotion_vote")
(function Promotion_vote -> Some () | _ -> None)
(fun () -> Promotion_vote);
case
(Tag 4)
~title:"Adoption"
(constant "adoption")
(function Adoption -> Some () | _ -> None)
(fun () -> Adoption) ]
let succ_kind = function
| Proposal ->
Testing_vote
| Testing_vote ->
Testing
| Testing ->
Promotion_vote
| Promotion_vote ->
Adoption
| Adoption ->
Proposal
type voting_period = {index : int32; kind : kind; start_position : int32}
type t = voting_period
type info = {voting_period : t; position : int32; remaining : int32}
let root ~start_position = {index = 0l; kind = Proposal; start_position}
let pp ppf {index; kind; start_position} =
Format.fprintf
ppf
"@[<hv 2>index: %ld@ ,kind:%a@, start_position: %ld@]"
index
pp_kind
kind
start_position
let pp_info ppf {voting_period; position; remaining} =
Format.fprintf
ppf
"@[<hv 2>voting_period: %a@ ,position:%ld@, remaining: %ld@]"
pp
voting_period
position
remaining
let encoding =
let open Data_encoding in
conv
(fun {index; kind; start_position} -> (index, kind, start_position))
(fun (index, kind, start_position) -> {index; kind; start_position})
(obj3
(req
"index"
~description:
"The voting period's index. Starts at 0 with the first block of \
protocol alpha."
int32)
(req "kind" kind_encoding)
(req "start_position" int32))
let info_encoding =
let open Data_encoding in
conv
(fun {voting_period; position; remaining} ->
(voting_period, position, remaining))
(fun (voting_period, position, remaining) ->
{voting_period; position; remaining})
(obj3
(req "voting_period" encoding)
(req "position" int32)
(req "remaining" int32))
include Compare.Make (struct
type nonrec t = t
let compare p p' = Compare.Int32.compare p.index p'.index
end)
let reset period ~start_position =
let index = Int32.succ period.index in
let kind = Proposal in
{index; kind; start_position}
let succ period ~start_position =
let index = Int32.succ period.index in
let kind = succ_kind period.kind in
{index; kind; start_position}
let position_since (level : Level_repr.t) (voting_period : t) =
Int32.(sub level.level_position voting_period.start_position)
let remaining_blocks (level : Level_repr.t) (voting_period : t)
~blocks_per_voting_period =
let position = position_since level voting_period in
Int32.(sub blocks_per_voting_period (succ position))
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
maybe_bound.ml |
open! Import
type 'a t =
| Incl of 'a
| Excl of 'a
| Unbounded
[@@deriving_inline enumerate, sexp, sexp_grammar]
let all : 'a. 'a list -> 'a t list =
fun _all_of_a ->
Ppx_enumerate_lib.List.append
(let rec map l acc =
match l with
| [] -> Ppx_enumerate_lib.List.rev acc
| enumerate__001_ :: l -> map l (Incl enumerate__001_ :: acc)
in
map _all_of_a [])
(Ppx_enumerate_lib.List.append
(let rec map l acc =
match l with
| [] -> Ppx_enumerate_lib.List.rev acc
| enumerate__002_ :: l -> map l (Excl enumerate__002_ :: acc)
in
map _all_of_a [])
[ Unbounded ])
;;
let t_of_sexp : 'a. (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a t =
fun (type a__018_) : ((Sexplib0.Sexp.t -> a__018_) -> Sexplib0.Sexp.t -> a__018_ t) ->
let error_source__006_ = "maybe_bound.ml.t" in
fun _of_a__003_ -> function
| Sexplib0.Sexp.List
(Sexplib0.Sexp.Atom (("incl" | "Incl") as _tag__009_) :: sexp_args__010_) as
_sexp__008_ ->
(match sexp_args__010_ with
| [ arg0__011_ ] ->
let res0__012_ = _of_a__003_ arg0__011_ in
Incl res0__012_
| _ ->
Sexplib0.Sexp_conv_error.stag_incorrect_n_args
error_source__006_
_tag__009_
_sexp__008_)
| Sexplib0.Sexp.List
(Sexplib0.Sexp.Atom (("excl" | "Excl") as _tag__014_) :: sexp_args__015_) as
_sexp__013_ ->
(match sexp_args__015_ with
| [ arg0__016_ ] ->
let res0__017_ = _of_a__003_ arg0__016_ in
Excl res0__017_
| _ ->
Sexplib0.Sexp_conv_error.stag_incorrect_n_args
error_source__006_
_tag__014_
_sexp__013_)
| Sexplib0.Sexp.Atom ("unbounded" | "Unbounded") -> Unbounded
| Sexplib0.Sexp.Atom ("incl" | "Incl") as sexp__007_ ->
Sexplib0.Sexp_conv_error.stag_takes_args error_source__006_ sexp__007_
| Sexplib0.Sexp.Atom ("excl" | "Excl") as sexp__007_ ->
Sexplib0.Sexp_conv_error.stag_takes_args error_source__006_ sexp__007_
| Sexplib0.Sexp.List (Sexplib0.Sexp.Atom ("unbounded" | "Unbounded") :: _) as
sexp__007_ -> Sexplib0.Sexp_conv_error.stag_no_args error_source__006_ sexp__007_
| Sexplib0.Sexp.List (Sexplib0.Sexp.List _ :: _) as sexp__005_ ->
Sexplib0.Sexp_conv_error.nested_list_invalid_sum error_source__006_ sexp__005_
| Sexplib0.Sexp.List [] as sexp__005_ ->
Sexplib0.Sexp_conv_error.empty_list_invalid_sum error_source__006_ sexp__005_
| sexp__005_ ->
Sexplib0.Sexp_conv_error.unexpected_stag error_source__006_ sexp__005_
;;
let sexp_of_t : 'a. ('a -> Sexplib0.Sexp.t) -> 'a t -> Sexplib0.Sexp.t =
fun (type a__024_) : ((a__024_ -> Sexplib0.Sexp.t) -> a__024_ t -> Sexplib0.Sexp.t) ->
fun _of_a__019_ -> function
| Incl arg0__020_ ->
let res0__021_ = _of_a__019_ arg0__020_ in
Sexplib0.Sexp.List [ Sexplib0.Sexp.Atom "Incl"; res0__021_ ]
| Excl arg0__022_ ->
let res0__023_ = _of_a__019_ arg0__022_ in
Sexplib0.Sexp.List [ Sexplib0.Sexp.Atom "Excl"; res0__023_ ]
| Unbounded -> Sexplib0.Sexp.Atom "Unbounded"
;;
let (t_sexp_grammar : 'a Sexplib0.Sexp_grammar.t -> 'a t Sexplib0.Sexp_grammar.t) =
fun _'a_sexp_grammar ->
{ untyped =
Variant
{ case_sensitivity = Case_sensitive_except_first_character
; clauses =
[ No_tag
{ name = "Incl"
; clause_kind =
List_clause { args = Cons (_'a_sexp_grammar.untyped, Empty) }
}
; No_tag
{ name = "Excl"
; clause_kind =
List_clause { args = Cons (_'a_sexp_grammar.untyped, Empty) }
}
; No_tag { name = "Unbounded"; clause_kind = Atom_clause }
]
}
}
;;
[@@@end]
type interval_comparison =
| Below_lower_bound
| In_range
| Above_upper_bound
[@@deriving_inline sexp, sexp_grammar, compare, hash]
let interval_comparison_of_sexp =
(let error_source__027_ = "maybe_bound.ml.interval_comparison" in
function
| Sexplib0.Sexp.Atom ("below_lower_bound" | "Below_lower_bound") -> Below_lower_bound
| Sexplib0.Sexp.Atom ("in_range" | "In_range") -> In_range
| Sexplib0.Sexp.Atom ("above_upper_bound" | "Above_upper_bound") -> Above_upper_bound
| Sexplib0.Sexp.List
(Sexplib0.Sexp.Atom ("below_lower_bound" | "Below_lower_bound") :: _) as sexp__028_
-> Sexplib0.Sexp_conv_error.stag_no_args error_source__027_ sexp__028_
| Sexplib0.Sexp.List (Sexplib0.Sexp.Atom ("in_range" | "In_range") :: _) as sexp__028_
-> Sexplib0.Sexp_conv_error.stag_no_args error_source__027_ sexp__028_
| Sexplib0.Sexp.List
(Sexplib0.Sexp.Atom ("above_upper_bound" | "Above_upper_bound") :: _) as sexp__028_
-> Sexplib0.Sexp_conv_error.stag_no_args error_source__027_ sexp__028_
| Sexplib0.Sexp.List (Sexplib0.Sexp.List _ :: _) as sexp__026_ ->
Sexplib0.Sexp_conv_error.nested_list_invalid_sum error_source__027_ sexp__026_
| Sexplib0.Sexp.List [] as sexp__026_ ->
Sexplib0.Sexp_conv_error.empty_list_invalid_sum error_source__027_ sexp__026_
| sexp__026_ -> Sexplib0.Sexp_conv_error.unexpected_stag error_source__027_ sexp__026_
: Sexplib0.Sexp.t -> interval_comparison)
;;
let sexp_of_interval_comparison =
(function
| Below_lower_bound -> Sexplib0.Sexp.Atom "Below_lower_bound"
| In_range -> Sexplib0.Sexp.Atom "In_range"
| Above_upper_bound -> Sexplib0.Sexp.Atom "Above_upper_bound"
: interval_comparison -> Sexplib0.Sexp.t)
;;
let (interval_comparison_sexp_grammar : interval_comparison Sexplib0.Sexp_grammar.t) =
{ untyped =
Variant
{ case_sensitivity = Case_sensitive_except_first_character
; clauses =
[ No_tag { name = "Below_lower_bound"; clause_kind = Atom_clause }
; No_tag { name = "In_range"; clause_kind = Atom_clause }
; No_tag { name = "Above_upper_bound"; clause_kind = Atom_clause }
]
}
}
;;
let compare_interval_comparison =
(Ppx_compare_lib.polymorphic_compare
: interval_comparison -> interval_comparison -> int)
;;
let (hash_fold_interval_comparison :
Ppx_hash_lib.Std.Hash.state -> interval_comparison -> Ppx_hash_lib.Std.Hash.state)
=
(fun hsv arg ->
match arg with
| Below_lower_bound -> Ppx_hash_lib.Std.Hash.fold_int hsv 0
| In_range -> Ppx_hash_lib.Std.Hash.fold_int hsv 1
| Above_upper_bound -> Ppx_hash_lib.Std.Hash.fold_int hsv 2
: Ppx_hash_lib.Std.Hash.state -> interval_comparison -> Ppx_hash_lib.Std.Hash.state)
;;
let (hash_interval_comparison : interval_comparison -> Ppx_hash_lib.Std.Hash.hash_value) =
let func arg =
Ppx_hash_lib.Std.Hash.get_hash_value
(let hsv = Ppx_hash_lib.Std.Hash.create () in
hash_fold_interval_comparison hsv arg)
in
fun x -> func x
;;
[@@@end]
let map t ~f =
match t with
| Incl incl -> Incl (f incl)
| Excl excl -> Excl (f excl)
| Unbounded -> Unbounded
;;
let is_lower_bound t ~of_:a ~compare =
match t with
| Incl incl -> compare incl a <= 0
| Excl excl -> compare excl a < 0
| Unbounded -> true
;;
let is_upper_bound t ~of_:a ~compare =
match t with
| Incl incl -> compare a incl <= 0
| Excl excl -> compare a excl < 0
| Unbounded -> true
;;
let bounds_crossed ~lower ~upper ~compare =
match lower with
| Unbounded -> false
| Incl lower | Excl lower ->
(match upper with
| Unbounded -> false
| Incl upper | Excl upper -> compare lower upper > 0)
;;
let check_interval_exn ~lower ~upper ~compare =
if bounds_crossed ~lower ~upper ~compare
then failwith "Maybe_bound.compare_to_interval_exn: lower bound > upper bound"
;;
let compare_to_interval_exn ~lower ~upper a ~compare =
check_interval_exn ~lower ~upper ~compare;
if not (is_lower_bound lower ~of_:a ~compare)
then Below_lower_bound
else if not (is_upper_bound upper ~of_:a ~compare)
then Above_upper_bound
else In_range
;;
let interval_contains_exn ~lower ~upper a ~compare =
match compare_to_interval_exn ~lower ~upper a ~compare with
| In_range -> true
| Below_lower_bound | Above_upper_bound -> false
;;
| |
Indexing.ml | (* A suspension is used to represent a cardinal-that-may-still-be-unknown. *)
type 'n cardinal =
int Lazy.t
(* The function [cardinal] forces the cardinal to become fixed. *)
let cardinal =
Lazy.force
type 'n index =
int
module type CARDINAL = sig type n val n : n cardinal end
(* [Empty] and [Const] produce sets whose cardinal is known. *)
module Empty : CARDINAL = struct
type n
let n = lazy 0
end
module Const (X : sig val cardinal : int end) : CARDINAL = struct
type n
let () = assert (X.cardinal >= 0)
let n = lazy X.cardinal
end
let const c : (module CARDINAL) =
assert (c >= 0);
(module struct type n let n = lazy c end)
(* [Gensym] produces a set whose cardinal is a priori unknown. A new reference
stores the current cardinal, which grows when [fresh()] is invoked. [fresh]
fails if the suspension [n] has been forced. *)
module Gensym () = struct
type n
let counter = ref 0
let n = lazy !counter
let fresh () =
assert (not (Lazy.is_val n));
let result = !counter in
incr counter;
result
end
type ('l, 'r) either =
| L of 'l
| R of 'r
module type SUM = sig
type l and r
include CARDINAL
val inj_l : l index -> n index
val inj_r : r index -> n index
val prj : n index -> (l index, r index) either
end
module Sum (L : CARDINAL)(R : CARDINAL) = struct
type n
type l = L.n
type r = R.n
(* The cardinal [l] of the left-hand set becomes fixed now (if it
wasn't already). We need it to be fixed for our injections and
projections to make sense. *)
let l : int = cardinal L.n
(* The right-hand set can remain open-ended. *)
let r : int cardinal = R.n
let n =
(* We optimize the case where [r] is fixed already, but the code
in the [else] branch would work always. *)
if Lazy.is_val r then
let n = l + cardinal r in
lazy n
else
lazy (l + cardinal r)
(* Injections. The two sets are numbered side by side. *)
let inj_l x = x
let inj_r y = l + y
(* Projection. *)
let prj x = if x < l then L x else R (x - l)
end
let sum (type l r) (l : l cardinal) (r : r cardinal) =
let module L = struct type n = l let n = l end in
let module R = struct type n = r let n = r end in
(module Sum(L)(R) : SUM with type l = l and type r = r)
module Index = struct
type 'n t = 'n index
let of_int (n : 'n cardinal) i : 'n index =
let n = cardinal n in
assert (0 <= i && i < n);
i
let to_int i = i
let iter (n : 'n cardinal) (yield : 'n index -> unit) =
let n = cardinal n in
for i = 0 to n - 1 do
yield i
done
exception End_of_set
let enumerate (n : 'n cardinal) : unit -> 'n index =
let n = cardinal n in
let next = ref 0 in
fun () ->
let i = !next in
if n <= i then raise End_of_set;
incr next;
i
end
type ('n, 'a) vector =
'a array
module Vector = struct
type ('n, 'a) t = ('n, 'a) vector
let get = Array.unsafe_get
let set = Array.unsafe_set
let set_cons t i x =
set t i (x :: get t i)
let length a =
let n = Array.length a in
lazy n
let empty = [||]
let make (n : _ cardinal) x =
let n = cardinal n in
Array.make n x
let make' (n : _ cardinal) f =
let n = cardinal n in
if n = 0 then
empty
else
Array.make n (f())
let init (n : _ cardinal) f =
let n = cardinal n in
Array.init n f
let map = Array.map
end
| (******************************************************************************)
(* *)
(* Fix *)
(* *)
(* François Pottier, Inria Paris *)
(* *)
(* Copyright Inria. All rights reserved. This file is distributed under the *)
(* terms of the GNU Library General Public License version 2, with a *)
(* special exception on linking, as described in the file LICENSE. *)
(* *)
(******************************************************************************)
|
opamDarcs.mli | (** Darcs repository backend (based on OpamVCS) *)
module VCS: OpamVCS.VCS
module B: OpamRepositoryBackend.S
| (**************************************************************************)
(* *)
(* Copyright 2012-2016 OCamlPro *)
(* Copyright 2012 INRIA *)
(* *)
(* All rights reserved. This file is distributed under the terms of the *)
(* GNU Lesser General Public License version 2.1, with the special *)
(* exception on linking described in the file LICENSE. *)
(* *)
(**************************************************************************)
|
roll_storage.ml | open Misc
type error +=
| Consume_roll_change (* `Permanent *)
| No_roll_for_delegate (* `Permanent *)
| No_roll_snapshot_for_cycle of Cycle_repr.t (* `Permanent *)
| Unregistered_delegate of Signature.Public_key_hash.t (* `Permanent *)
let () =
let open Data_encoding in
(* Consume roll change *)
register_error_kind
`Permanent
~id:"contract.manager.consume_roll_change"
~title:"Consume roll change"
~description:"Change is not enough to consume a roll."
~pp:(fun ppf () ->
Format.fprintf ppf "Not enough change to consume a roll.")
empty
(function Consume_roll_change -> Some () | _ -> None)
(fun () -> Consume_roll_change) ;
(* No roll for delegate *)
register_error_kind
`Permanent
~id:"contract.manager.no_roll_for_delegate"
~title:"No roll for delegate"
~description:"Delegate has no roll."
~pp:(fun ppf () -> Format.fprintf ppf "Delegate has no roll.")
empty
(function No_roll_for_delegate -> Some () | _ -> None)
(fun () -> No_roll_for_delegate) ;
(* No roll snapshot for cycle *)
register_error_kind
`Permanent
~id:"contract.manager.no_roll_snapshot_for_cycle"
~title:"No roll snapshot for cycle"
~description:"A snapshot of the rolls distribution does not exist for this cycle."
~pp:(fun ppf c ->
Format.fprintf ppf
"A snapshot of the rolls distribution does not exist for cycle %a" Cycle_repr.pp c)
(obj1 (req "cycle" Cycle_repr.encoding))
(function No_roll_snapshot_for_cycle c-> Some c | _ -> None)
(fun c -> No_roll_snapshot_for_cycle c) ;
(* Unregistered delegate *)
register_error_kind
`Permanent
~id:"contract.manager.unregistered_delegate"
~title:"Unregistered delegate"
~description:"A contract cannot be delegated to an unregistered delegate"
~pp:(fun ppf k->
Format.fprintf ppf "The provided public key (with hash %a) is \
\ not registered as valid delegate key."
Signature.Public_key_hash.pp k)
(obj1 (req "hash" Signature.Public_key_hash.encoding))
(function Unregistered_delegate k -> Some k | _ -> None)
(fun k -> Unregistered_delegate k)
let get_contract_delegate c contract =
Storage.Contract.Delegate.get_option c contract
let delegate_pubkey ctxt delegate =
Storage.Contract.Manager.get_option ctxt
(Contract_repr.implicit_contract delegate) >>=? function
| None | Some (Manager_repr.Hash _) ->
fail (Unregistered_delegate delegate)
| Some (Manager_repr.Public_key pk) ->
return pk
let clear_cycle c cycle =
Storage.Roll.Snapshot_for_cycle.get c cycle >>=? fun index ->
Storage.Roll.Snapshot_for_cycle.delete c cycle >>=? fun c ->
Storage.Roll.Last_for_snapshot.delete (c, cycle) index >>=? fun c ->
Storage.Roll.Owner.delete_snapshot c (cycle, index) >>= fun c ->
return c
let fold ctxt ~f init =
Storage.Roll.Next.get ctxt >>=? fun last ->
let rec loop ctxt roll acc =
acc >>=? fun acc ->
if Roll_repr.(roll = last) then
return acc
else
Storage.Roll.Owner.get_option ctxt roll >>=? function
| None ->
loop ctxt (Roll_repr.succ roll) (return acc)
| Some delegate ->
loop ctxt (Roll_repr.succ roll) (f roll delegate acc) in
loop ctxt Roll_repr.first (return init)
let snapshot_rolls_for_cycle ctxt cycle =
Storage.Roll.Snapshot_for_cycle.get ctxt cycle >>=? fun index ->
Storage.Roll.Snapshot_for_cycle.set ctxt cycle (index + 1) >>=? fun ctxt ->
Storage.Roll.Owner.snapshot ctxt (cycle, index) >>=? fun ctxt ->
Storage.Roll.Next.get ctxt >>=? fun last ->
Storage.Roll.Last_for_snapshot.init (ctxt, cycle) index last >>=? fun ctxt ->
return ctxt
let freeze_rolls_for_cycle ctxt cycle =
Storage.Roll.Snapshot_for_cycle.get ctxt cycle >>=? fun max_index ->
Storage.Seed.For_cycle.get ctxt cycle >>=? fun seed ->
let rd = Seed_repr.initialize_new seed [MBytes.of_string "roll_snapshot"] in
let seq = Seed_repr.sequence rd 0l in
let selected_index =
Seed_repr.take_int32 seq (Int32.of_int max_index) |> fst |> Int32.to_int in
Storage.Roll.Snapshot_for_cycle.set ctxt cycle selected_index >>=? fun ctxt ->
fold_left_s
(fun ctxt index ->
if Compare.Int.(index = selected_index) then
return ctxt
else
Storage.Roll.Owner.delete_snapshot ctxt (cycle, index) >>= fun ctxt ->
Storage.Roll.Last_for_snapshot.delete (ctxt, cycle) index >>=? fun ctxt ->
return ctxt
)
ctxt
Misc.(0 --> (max_index - 1)) >>=? fun ctxt ->
return ctxt
(* Roll selection *)
module Random = struct
let int32_to_bytes i =
let b = MBytes.create 4 in
MBytes.set_int32 b 0 i;
b
let level_random seed use level =
let position = level.Level_repr.cycle_position in
Seed_repr.initialize_new seed
[MBytes.of_string ("level "^use^":");
int32_to_bytes position]
let owner c kind level offset =
let cycle = level.Level_repr.cycle in
Seed_storage.for_cycle c cycle >>=? fun random_seed ->
let rd = level_random random_seed kind level in
let sequence = Seed_repr.sequence rd (Int32.of_int offset) in
Storage.Roll.Snapshot_for_cycle.get c cycle >>=? fun index ->
Storage.Roll.Last_for_snapshot.get (c, cycle) index >>=? fun bound ->
let rec loop sequence =
let roll, sequence = Roll_repr.random sequence ~bound in
Storage.Roll.Owner.Snapshot.get_option c ((cycle, index), roll) >>=? function
| None ->
loop sequence
| Some delegate ->
return delegate in
Storage.Roll.Owner.snapshot_exists c (cycle, index) >>= fun snapshot_exists ->
fail_unless snapshot_exists (No_roll_snapshot_for_cycle cycle) >>=? fun () ->
loop sequence
end
let baking_rights_owner c level ~priority =
Random.owner c "baking" level priority
let endorsement_rights_owner c level ~slot =
Random.owner c "endorsement" level slot
let traverse_rolls ctxt head =
let rec loop acc roll =
Storage.Roll.Successor.get_option ctxt roll >>=? function
| None -> return (List.rev acc)
| Some next -> loop (next :: acc) next in
loop [head] head
let get_rolls ctxt delegate =
Storage.Roll.Delegate_roll_list.get_option ctxt delegate >>=? function
| None -> return_nil
| Some head_roll -> traverse_rolls ctxt head_roll
let count_rolls ctxt delegate =
Storage.Roll.Delegate_roll_list.get_option ctxt delegate >>=? function
| None -> return 0
| Some head_roll ->
let rec loop acc roll =
Storage.Roll.Successor.get_option ctxt roll >>=? function
| None -> return acc
| Some next -> loop (succ acc) next in
loop 1 head_roll
let get_change c delegate =
Storage.Roll.Delegate_change.get_option c delegate >>=? function
| None -> return Tez_repr.zero
| Some change -> return change
module Delegate = struct
let fresh_roll c =
Storage.Roll.Next.get c >>=? fun roll ->
Storage.Roll.Next.set c (Roll_repr.succ roll) >>=? fun c ->
return (roll, c)
let get_limbo_roll c =
Storage.Roll.Limbo.get_option c >>=? function
| None ->
fresh_roll c >>=? fun (roll, c) ->
Storage.Roll.Limbo.init c roll >>=? fun c ->
return (roll, c)
| Some roll ->
return (roll, c)
let consume_roll_change c delegate =
let tokens_per_roll = Constants_storage.tokens_per_roll c in
Storage.Roll.Delegate_change.get c delegate >>=? fun change ->
trace Consume_roll_change
(Lwt.return Tez_repr.(change -? tokens_per_roll)) >>=? fun new_change ->
Storage.Roll.Delegate_change.set c delegate new_change
let recover_roll_change c delegate =
let tokens_per_roll = Constants_storage.tokens_per_roll c in
Storage.Roll.Delegate_change.get c delegate >>=? fun change ->
Lwt.return Tez_repr.(change +? tokens_per_roll) >>=? fun new_change ->
Storage.Roll.Delegate_change.set c delegate new_change
let pop_roll_from_delegate c delegate =
recover_roll_change c delegate >>=? fun c ->
(* beginning:
delegate : roll -> successor_roll -> ...
limbo : limbo_head -> ...
*)
Storage.Roll.Limbo.get_option c >>=? fun limbo_head ->
Storage.Roll.Delegate_roll_list.get_option c delegate >>=? function
| None -> fail No_roll_for_delegate
| Some roll ->
Storage.Roll.Owner.delete c roll >>=? fun c ->
Storage.Roll.Successor.get_option c roll >>=? fun successor_roll ->
Storage.Roll.Delegate_roll_list.set_option c delegate successor_roll >>= fun c ->
(* delegate : successor_roll -> ...
roll ------^
limbo : limbo_head -> ... *)
Storage.Roll.Successor.set_option c roll limbo_head >>= fun c ->
(* delegate : successor_roll -> ...
roll ------v
limbo : limbo_head -> ... *)
Storage.Roll.Limbo.init_set c roll >>= fun c ->
(* delegate : successor_roll -> ...
limbo : roll -> limbo_head -> ... *)
return (roll, c)
let create_roll_in_delegate c delegate delegate_pk =
consume_roll_change c delegate >>=? fun c ->
(* beginning:
delegate : delegate_head -> ...
limbo : roll -> limbo_successor -> ...
*)
Storage.Roll.Delegate_roll_list.get_option c delegate >>=? fun delegate_head ->
get_limbo_roll c >>=? fun (roll, c) ->
Storage.Roll.Owner.init c roll delegate_pk >>=? fun c ->
Storage.Roll.Successor.get_option c roll >>=? fun limbo_successor ->
Storage.Roll.Limbo.set_option c limbo_successor >>= fun c ->
(* delegate : delegate_head -> ...
roll ------v
limbo : limbo_successor -> ... *)
Storage.Roll.Successor.set_option c roll delegate_head >>= fun c ->
(* delegate : delegate_head -> ...
roll ------^
limbo : limbo_successor -> ... *)
Storage.Roll.Delegate_roll_list.init_set c delegate roll >>= fun c ->
(* delegate : roll -> delegate_head -> ...
limbo : limbo_successor -> ... *)
return c
let ensure_inited c delegate =
Storage.Roll.Delegate_change.mem c delegate >>= function
| true -> return c
| false ->
Storage.Roll.Delegate_change.init c delegate Tez_repr.zero
let is_inactive c delegate =
Storage.Contract.Inactive_delegate.mem c
(Contract_repr.implicit_contract delegate) >>= fun inactive ->
if inactive then
return inactive
else
Storage.Contract.Delegate_desactivation.get_option c
(Contract_repr.implicit_contract delegate) >>=? function
| Some last_active_cycle ->
let { Level_repr.cycle = current_cycle } = Raw_context.current_level c in
return Cycle_repr.(last_active_cycle < current_cycle)
| None ->
(* This case is only when called from `set_active`, when creating
a contract. *)
return_false
let add_amount c delegate amount =
ensure_inited c delegate >>=? fun c ->
let tokens_per_roll = Constants_storage.tokens_per_roll c in
Storage.Roll.Delegate_change.get c delegate >>=? fun change ->
Lwt.return Tez_repr.(amount +? change) >>=? fun change ->
Storage.Roll.Delegate_change.set c delegate change >>=? fun c ->
delegate_pubkey c delegate >>=? fun delegate_pk ->
let rec loop c change =
if Tez_repr.(change < tokens_per_roll) then
return c
else
Lwt.return Tez_repr.(change -? tokens_per_roll) >>=? fun change ->
create_roll_in_delegate c delegate delegate_pk >>=? fun c ->
loop c change in
is_inactive c delegate >>=? fun inactive ->
if inactive then
return c
else
loop c change >>=? fun c ->
Storage.Roll.Delegate_roll_list.get_option c delegate >>=? fun rolls ->
match rolls with
| None ->
return c
| Some _ ->
Storage.Active_delegates_with_rolls.add c delegate >>= fun c ->
return c
let remove_amount c delegate amount =
let tokens_per_roll = Constants_storage.tokens_per_roll c in
let rec loop c change =
if Tez_repr.(amount <= change)
then return (c, change)
else
pop_roll_from_delegate c delegate >>=? fun (_, c) ->
Lwt.return Tez_repr.(change +? tokens_per_roll) >>=? fun change ->
loop c change in
Storage.Roll.Delegate_change.get c delegate >>=? fun change ->
is_inactive c delegate >>=? fun inactive ->
begin
if inactive then
return (c, change)
else
loop c change >>=? fun (c, change) ->
Storage.Roll.Delegate_roll_list.get_option c delegate >>=? fun rolls ->
match rolls with
| None ->
Storage.Active_delegates_with_rolls.del c delegate >>= fun c ->
return (c, change)
| Some _ ->
return (c, change)
end >>=? fun (c, change) ->
Lwt.return Tez_repr.(change -? amount) >>=? fun change ->
Storage.Roll.Delegate_change.set c delegate change
let set_inactive ctxt delegate =
ensure_inited ctxt delegate >>=? fun ctxt ->
let tokens_per_roll = Constants_storage.tokens_per_roll ctxt in
Storage.Roll.Delegate_change.get ctxt delegate >>=? fun change ->
Storage.Contract.Inactive_delegate.add ctxt
(Contract_repr.implicit_contract delegate) >>= fun ctxt ->
Storage.Active_delegates_with_rolls.del ctxt delegate >>= fun ctxt ->
let rec loop ctxt change =
Storage.Roll.Delegate_roll_list.get_option ctxt delegate >>=? function
| None -> return (ctxt, change)
| Some _roll ->
pop_roll_from_delegate ctxt delegate >>=? fun (_, ctxt) ->
Lwt.return Tez_repr.(change +? tokens_per_roll) >>=? fun change ->
loop ctxt change in
loop ctxt change >>=? fun (ctxt, change) ->
Storage.Roll.Delegate_change.set ctxt delegate change >>=? fun ctxt ->
return ctxt
let set_active ctxt delegate =
is_inactive ctxt delegate >>=? fun inactive ->
let current_cycle = (Raw_context.current_level ctxt).cycle in
let preserved_cycles = Constants_storage.preserved_cycles ctxt in
(* When the delegate is new or inactive, she will become active in
`1+preserved_cycles`, and we allow `preserved_cycles` for the
delegate to start baking. When the delegate is active, we only
give her at least `preserved_cycles` after the current cycle
before to be deactivated. *)
Storage.Contract.Delegate_desactivation.get_option ctxt
(Contract_repr.implicit_contract delegate) >>=? fun current_expiration ->
let expiration = match current_expiration with
| None ->
Cycle_repr.add current_cycle (1+2*preserved_cycles)
| Some current_expiration ->
let delay =
if inactive then (1+2*preserved_cycles) else 1+preserved_cycles in
let updated =
Cycle_repr.add current_cycle delay in
Cycle_repr.max current_expiration updated in
Storage.Contract.Delegate_desactivation.init_set ctxt
(Contract_repr.implicit_contract delegate)
expiration >>= fun ctxt ->
if not inactive then
return ctxt
else begin
ensure_inited ctxt delegate >>=? fun ctxt ->
let tokens_per_roll = Constants_storage.tokens_per_roll ctxt in
Storage.Roll.Delegate_change.get ctxt delegate >>=? fun change ->
Storage.Contract.Inactive_delegate.del ctxt
(Contract_repr.implicit_contract delegate) >>= fun ctxt ->
delegate_pubkey ctxt delegate >>=? fun delegate_pk ->
let rec loop ctxt change =
if Tez_repr.(change < tokens_per_roll) then
return ctxt
else
Lwt.return Tez_repr.(change -? tokens_per_roll) >>=? fun change ->
create_roll_in_delegate ctxt delegate delegate_pk >>=? fun ctxt ->
loop ctxt change in
loop ctxt change >>=? fun ctxt ->
Storage.Roll.Delegate_roll_list.get_option ctxt delegate >>=? fun rolls ->
match rolls with
| None ->
return ctxt
| Some _ ->
Storage.Active_delegates_with_rolls.add ctxt delegate >>= fun ctxt ->
return ctxt
end
end
module Contract = struct
let add_amount c contract amount =
get_contract_delegate c contract >>=? function
| None -> return c
| Some delegate ->
Delegate.add_amount c delegate amount
let remove_amount c contract amount =
get_contract_delegate c contract >>=? function
| None -> return c
| Some delegate ->
Delegate.remove_amount c delegate amount
end
let init ctxt =
Storage.Roll.Next.init ctxt Roll_repr.first
let init_first_cycles ctxt =
let preserved = Constants_storage.preserved_cycles ctxt in
(* Precompute rolls for cycle (0 --> preserved_cycles) *)
List.fold_left
(fun ctxt c ->
ctxt >>=? fun ctxt ->
let cycle = Cycle_repr.of_int32_exn (Int32.of_int c) in
Storage.Roll.Snapshot_for_cycle.init ctxt cycle 0 >>=? fun ctxt ->
snapshot_rolls_for_cycle ctxt cycle >>=? fun ctxt ->
freeze_rolls_for_cycle ctxt cycle)
(return ctxt) (0 --> preserved) >>=? fun ctxt ->
let cycle = Cycle_repr.of_int32_exn (Int32.of_int (preserved + 1)) in
(* Precomputed a snapshot for cycle (preserved_cycles + 1) *)
Storage.Roll.Snapshot_for_cycle.init ctxt cycle 0 >>=? fun ctxt ->
snapshot_rolls_for_cycle ctxt cycle >>=? fun ctxt ->
(* Prepare storage for storing snapshots for cycle (preserved_cycles+2) *)
let cycle = Cycle_repr.of_int32_exn (Int32.of_int (preserved + 2)) in
Storage.Roll.Snapshot_for_cycle.init ctxt cycle 0 >>=? fun ctxt ->
return ctxt
let snapshot_rolls ctxt =
let current_level = Raw_context.current_level ctxt in
let preserved = Constants_storage.preserved_cycles ctxt in
let cycle = Cycle_repr.add current_level.cycle (preserved+2) in
snapshot_rolls_for_cycle ctxt cycle
let cycle_end ctxt last_cycle =
let preserved = Constants_storage.preserved_cycles ctxt in
begin
match Cycle_repr.sub last_cycle preserved with
| None -> return ctxt
| Some cleared_cycle ->
clear_cycle ctxt cleared_cycle
end >>=? fun ctxt ->
let frozen_roll_cycle = Cycle_repr.add last_cycle (preserved+1) in
freeze_rolls_for_cycle ctxt frozen_roll_cycle >>=? fun ctxt ->
Storage.Roll.Snapshot_for_cycle.init
ctxt (Cycle_repr.succ (Cycle_repr.succ frozen_roll_cycle)) 0 >>=? fun ctxt ->
return ctxt
let update_tokens_per_roll ctxt new_tokens_per_roll =
let constants = Raw_context.constants ctxt in
let old_tokens_per_roll = constants.tokens_per_roll in
Raw_context.patch_constants ctxt begin fun constants ->
{ constants with Constants_repr.tokens_per_roll = new_tokens_per_roll }
end >>= fun ctxt ->
let decrease = Tez_repr.(new_tokens_per_roll < old_tokens_per_roll) in
begin
if decrease then
Lwt.return Tez_repr.(old_tokens_per_roll -? new_tokens_per_roll)
else
Lwt.return Tez_repr.(new_tokens_per_roll -? old_tokens_per_roll)
end >>=? fun abs_diff ->
Storage.Delegates.fold ctxt (Ok ctxt) begin fun pkh ctxt ->
Lwt.return ctxt >>=? fun ctxt ->
count_rolls ctxt pkh >>=? fun rolls ->
Lwt.return Tez_repr.(abs_diff *? Int64.of_int rolls) >>=? fun amount ->
if decrease then
Delegate.add_amount ctxt pkh amount
else
Delegate.remove_amount ctxt pkh amount
end
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
test_p2p_io_scheduler.ml | (** Testing
-------
Component: P2P
Invocation: dune build @src/lib_p2p/test/runtest_p2p_io_scheduler_ipv4
Dependencies: src/lib_p2p/test/process.ml
Subject: On I/O scheduling of client-server connections.
*)
include Internal_event.Legacy_logging.Make (struct
let name = "test-p2p-io-scheduler"
end)
exception Error of error list
let rec listen ?port addr =
let open Lwt_syntax in
let tentative_port =
match port with None -> 49152 + Random.int 16384 | Some port -> port
in
let uaddr = Ipaddr_unix.V6.to_inet_addr addr in
let main_socket = Lwt_unix.(socket PF_INET6 SOCK_STREAM 0) in
Lwt_unix.(setsockopt main_socket SO_REUSEADDR true) ;
Lwt.catch
(fun () ->
let* () = Lwt_unix.bind main_socket (ADDR_INET (uaddr, tentative_port)) in
Lwt_unix.listen main_socket 50 ;
return (main_socket, tentative_port))
(function
| Unix.Unix_error ((Unix.EADDRINUSE | Unix.EADDRNOTAVAIL), _, _)
when port = None ->
listen addr
| exn -> Lwt.fail exn)
let accept main_socket =
let open Lwt_syntax in
let* (fd, _sockaddr) = P2p_fd.accept main_socket in
return_ok fd
let rec accept_n main_socket n =
let open Lwt_result_syntax in
if n <= 0 then return_nil
else
let* acc = accept_n main_socket (n - 1) in
let* conn = accept main_socket in
return (conn :: acc)
let connect addr port =
let open Lwt_syntax in
let* fd = P2p_fd.socket PF_INET6 SOCK_STREAM 0 in
let uaddr = Lwt_unix.ADDR_INET (Ipaddr_unix.V6.to_inet_addr addr, port) in
let* () = P2p_fd.connect fd uaddr in
return_ok fd
let simple_msgs =
[|
Bytes.create (1 lsl 6);
Bytes.create (1 lsl 7);
Bytes.create (1 lsl 8);
Bytes.create (1 lsl 9);
Bytes.create (1 lsl 10);
Bytes.create (1 lsl 11);
Bytes.create (1 lsl 12);
Bytes.create (1 lsl 13);
Bytes.create (1 lsl 14);
Bytes.create (1 lsl 15);
Bytes.create (1 lsl 16);
|]
let nb_simple_msgs = Array.length simple_msgs
let receive conn =
let open Lwt_syntax in
let buf = Bytes.create (1 lsl 16) in
let rec loop () =
let open P2p_buffer_reader in
let* r = read conn (mk_buffer_safe buf) in
match r with
| Ok _ -> loop ()
| Error (Tezos_p2p_services.P2p_errors.Connection_closed :: _) ->
return_unit
| Error err -> Lwt.fail (Error err)
in
loop ()
let server ?(display_client_stat = true) ?max_download_speed ?read_queue_size
~read_buffer_size main_socket n =
let open Lwt_result_syntax in
let sched =
P2p_io_scheduler.create
?max_download_speed
?read_queue_size
~read_buffer_size
()
in
Moving_average.on_update (P2p_io_scheduler.ma_state sched) (fun () ->
log_notice "Stat: %a" P2p_stat.pp (P2p_io_scheduler.global_stat sched) ;
if display_client_stat then
P2p_io_scheduler.iter_connection sched (fun conn ->
log_notice
" client(%d) %a"
(P2p_io_scheduler.id conn)
P2p_stat.pp
(P2p_io_scheduler.stat conn))) ;
(* Accept and read message until the connection is closed. *)
let* conns = accept_n main_socket n in
let conns = List.map (P2p_io_scheduler.register sched) conns in
let*! () =
List.iter_p receive (List.map P2p_io_scheduler.to_readable conns)
in
let* () = List.iter_ep P2p_io_scheduler.close conns in
log_notice "OK %a" P2p_stat.pp (P2p_io_scheduler.global_stat sched) ;
return_unit
let max_size ?max_upload_speed () =
match max_upload_speed with
| None -> nb_simple_msgs
| Some max_upload_speed ->
let rec loop n =
if n <= 1 then 1
else if Bytes.length simple_msgs.(n - 1) <= max_upload_speed then n
else loop (n - 1)
in
loop nb_simple_msgs
let rec send conn nb_simple_msgs =
let open Lwt_result_syntax in
let*! () = Lwt.pause () in
let msg = simple_msgs.(Random.int nb_simple_msgs) in
let* () = P2p_io_scheduler.write conn msg in
send conn nb_simple_msgs
let client ?max_upload_speed ?write_queue_size addr port time _n =
let open Lwt_result_syntax in
let sched =
P2p_io_scheduler.create
?max_upload_speed
?write_queue_size
~read_buffer_size:(1 lsl 12)
()
in
let* conn = connect addr port in
let conn = P2p_io_scheduler.register sched conn in
let nb_simple_msgs = max_size ?max_upload_speed () in
let* () =
Lwt.pick
[
send conn nb_simple_msgs;
(let*! () = Lwt_unix.sleep time in
return_unit);
]
in
let* () = P2p_io_scheduler.close conn in
let stat = P2p_io_scheduler.stat conn in
let*! () = lwt_log_notice "Client OK %a" P2p_stat.pp stat in
return_unit
(** Listens to address [addr] on port [port] to open a socket [main_socket].
Spawns a server on it, and [n] clients connecting to the server. Then,
the server will close all connections.
*)
let run ?display_client_stat ?max_download_speed ?max_upload_speed
~read_buffer_size ?read_queue_size ?write_queue_size addr port time n =
let open Lwt_result_syntax in
let*! () = Tezos_base_unix.Internal_event_unix.init () in
let*! (main_socket, port) = listen ?port addr in
let* server_node =
Process.detach
~prefix:"server: "
(fun (_ : (unit, unit) Process.Channel.t) ->
server
?display_client_stat
?max_download_speed
~read_buffer_size
?read_queue_size
main_socket
n)
in
let client n =
let prefix = Printf.sprintf "client(%d): " n in
Process.detach ~prefix (fun _ ->
let*! () =
let*! r = Lwt_utils_unix.safe_close main_socket in
Result.iter_error
(Format.eprintf "Uncaught error: %a\n%!" pp_print_trace)
r ;
Lwt.return_unit
in
client ?max_upload_speed ?write_queue_size addr port time n)
in
let* client_nodes = List.map_es client (1 -- n) in
Process.wait_all (server_node :: client_nodes)
let () = Random.self_init ()
let addr = ref Ipaddr.V6.localhost
let port = ref None
let max_download_speed = ref None
let max_upload_speed = ref None
let read_buffer_size = ref (1 lsl 14)
let read_queue_size = ref (Some (1 lsl 14))
let write_queue_size = ref (Some (1 lsl 14))
let delay = ref 60.
let clients = ref 8
let display_client_stat = ref None
let spec =
Arg.
[
("--port", Int (fun p -> port := Some p), " Listening port");
( "--addr",
String (fun p -> addr := Ipaddr.V6.of_string_exn p),
" Listening addr" );
( "--max-download-speed",
Int (fun i -> max_download_speed := Some i),
" Max download speed in B/s (default: unbounded)" );
( "--max-upload-speed",
Int (fun i -> max_upload_speed := Some i),
" Max upload speed in B/s (default: unbounded)" );
( "--read-buffer-size",
Set_int read_buffer_size,
" Size of the read buffers" );
( "--read-queue-size",
Int (fun i -> read_queue_size := if i <= 0 then None else Some i),
" Size of the read queue (0=unbounded)" );
( "--write-queue-size",
Int (fun i -> write_queue_size := if i <= 0 then None else Some i),
" Size of the write queue (0=unbounded)" );
("--delay", Set_float delay, " Client execution time.");
("--clients", Set_int clients, " Number of concurrent clients.");
( "--hide-clients-stat",
Unit (fun () -> display_client_stat := Some false),
" Hide the client bandwidth statistic." );
( "--display_clients_stat",
Unit (fun () -> display_client_stat := Some true),
" Display the client bandwidth statistic." );
]
let () =
let anon_fun _num_peers = raise (Arg.Bad "No anonymous argument.") in
let usage_msg = "Usage: %s <num_peers>.\nArguments are:" in
Arg.parse spec anon_fun usage_msg
let init_logs = lazy (Tezos_base_unix.Internal_event_unix.init ())
let wrap n f =
Alcotest_lwt.test_case n `Quick (fun _lwt_switch () ->
let open Lwt_syntax in
let* () = Lazy.force init_logs in
let* r = f () in
match r with
| Ok () -> return_unit
| Error error ->
Format.kasprintf Stdlib.failwith "%a" pp_print_trace error)
let () =
Lwt_main.run
@@ Alcotest_lwt.run
~argv:[|""|]
"tezos-p2p"
[
( "p2p.io-scheduler",
[
wrap "trivial-quota" (fun () ->
run
?display_client_stat:!display_client_stat
?max_download_speed:!max_download_speed
?max_upload_speed:!max_upload_speed
~read_buffer_size:!read_buffer_size
?read_queue_size:!read_queue_size
?write_queue_size:!write_queue_size
!addr
!port
!delay
!clients);
] );
]
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* Copyright (c) 2020 Nomadic Labs, <contact@nomadic-labs.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
eliom_client_core.client.ml |
open Js_of_ocaml
open Eliom_lib
module Xml = Eliom_content_core.Xml
(* Logs *)
let section = Lwt_log.Section.make "eliom:client"
(* == Auxiliaries *)
let create_buffer () =
let stack = ref [] in
let elts = ref [] in
let add x = elts := x :: !elts and get () = List.rev !elts in
let push () =
stack := !elts :: !stack;
elts := []
in
let flush () =
let res = get () in
(match !stack with
| l :: r ->
elts := l;
stack := r
| [] -> elts := []);
res
in
add, get, flush, push
(* == Closure *)
module Client_closure : sig
val register : closure_id:string -> closure:(_ -> _) -> unit
val find : closure_id:string -> poly -> poly
end = struct
let client_closures = Jstable.create ()
let register ~closure_id ~closure =
Jstable.add client_closures (Js.string closure_id)
(from_poly (to_poly closure))
let find ~closure_id =
Js.Optdef.get
(Jstable.find client_closures (Js.string closure_id))
(fun () -> raise Not_found)
end
module Client_value : sig
val find : instance_id:int -> poly option
val initialize : Eliom_runtime.client_value_datum -> unit
end = struct
let table = new%js Js.array_empty
let find ~instance_id =
if instance_id = 0
then (* local client value *) None
else Js.Optdef.to_option (Js.array_get table instance_id)
let initialize {Eliom_runtime.closure_id; args; value = server_value} =
let closure =
try Client_closure.find ~closure_id
with Not_found ->
let pos =
match Eliom_runtime.Client_value_server_repr.loc server_value with
| None -> ""
| Some p -> Printf.sprintf "(%s)" (Eliom_lib.pos_to_string p)
in
Lwt_log.raise_error_f ~section
"Client closure %s not found %s (is the module linked on the client?)"
closure_id pos
in
let value = closure args in
Eliom_unwrap.late_unwrap_value server_value value;
(* Only register global client values *)
let instance_id =
Eliom_runtime.Client_value_server_repr.instance_id server_value
in
if instance_id <> 0 then Js.array_set table instance_id value
end
let middleClick ev =
match Dom_html.taggedEvent ev with
| Dom_html.MouseEvent ev ->
Dom_html.buttonPressed ev = Dom_html.Middle_button
|| Js.to_bool ev##.ctrlKey
|| Js.to_bool ev##.shiftKey
|| Js.to_bool ev##.altKey
|| Js.to_bool ev##.metaKey
| _ -> false
module Injection : sig
val get : ?ident:string -> ?pos:pos -> name:string -> _
val initialize
: compilation_unit_id:string
-> Eliom_client_value.injection_datum
-> unit
end = struct
let table = Jstable.create ()
let get ?ident ?pos ~name =
Lwt_log.ign_debug_f ~section "Get injection %s" name;
from_poly
(Js.Optdef.get
(Jstable.find table (Js.string name))
(fun () ->
let name =
match ident, pos with
| None, None -> Printf.sprintf "%s" name
| None, Some pos ->
Printf.sprintf "%s at %s" name (Eliom_lib.pos_to_string pos)
| Some i, None -> Printf.sprintf "%s (%s)" name i
| Some i, Some pos ->
Printf.sprintf "%s (%s at %s)" name i
(Eliom_lib.pos_to_string pos)
in
Lwt_log.raise_error_f "Did not find injection %s" name))
let initialize ~compilation_unit_id
{Eliom_runtime.injection_id; injection_value}
=
Lwt_log.ign_debug_f ~section "Initialize injection %d" injection_id;
(* BBB One should assert that injection_value doesn't contain any
value marked for late unwrapping. How to do this efficiently? *)
Jstable.add table
(Js.string (compilation_unit_id ^ string_of_int injection_id))
injection_value
end
(* == Populating client values and injections by global data *)
type compilation_unit_global_data =
{ mutable server_section : Eliom_runtime.client_value_datum array list
; mutable client_section : Eliom_runtime.injection_datum array list }
let global_data = ref String_map.empty
let do_next_server_section_data ~compilation_unit_id =
Lwt_log.ign_debug_f ~section
"Do next client value data section in compilation unit %s"
compilation_unit_id;
try
let data = String_map.find compilation_unit_id !global_data in
match data.server_section with
| l :: r ->
data.server_section <- r;
Array.iter Client_value.initialize l
| [] ->
Lwt_log.raise_error_f ~section
"Queue of client value data for compilation unit %s is empty (is it linked on the server?)"
compilation_unit_id
with Not_found -> ()
(* Client-only compilation unit *)
let do_next_client_section_data ~compilation_unit_id =
Lwt_log.ign_debug_f ~section
"Do next injection data section in compilation unit %s" compilation_unit_id;
try
let data = String_map.find compilation_unit_id !global_data in
match data.client_section with
| l :: r ->
data.client_section <- r;
Array.iter (fun i -> Injection.initialize ~compilation_unit_id i) l
| [] ->
Lwt_log.raise_error_f ~section
"Queue of injection data for compilation unit %s is empty (is it linked on the server?)"
compilation_unit_id
with Not_found -> ()
(* Client-only compilation unit *)
(*******************************************************************************)
let register_unwrapped_elt, force_unwrapped_elts =
let suspended_nodes = ref [] in
( (fun elt -> suspended_nodes := elt :: !suspended_nodes)
, fun () ->
Lwt_log.ign_debug ~section "Force unwrapped elements";
List.iter Xml.force_lazy !suspended_nodes;
suspended_nodes := [] )
(* == Process nodes
(a.k.a. nodes with a unique Dom instance on each client process) *)
let register_process_node, find_process_node =
let process_nodes : Dom.node Js.t Jstable.t = Jstable.create () in
let find id =
Lwt_log.ign_debug_f ~section "Find process node %a"
(fun () -> Js.to_string)
id;
Jstable.find process_nodes id
in
let register id node =
Lwt_log.ign_debug_f ~section "Register process node %a"
(fun () -> Js.to_string)
id;
let node =
if node##.nodeName##toLowerCase == Js.string "script"
then
(* We don't want to reexecute global scripts. *)
(Dom_html.document ## (createTextNode (Js.string "")) :> Dom.node Js.t)
else node
in
Jstable.add process_nodes id node
in
register, find
let registered_process_node id = Js.Optdef.test (find_process_node id)
let getElementById id =
Js.Optdef.case
(find_process_node (Js.string id))
(fun () ->
Lwt_log.ign_warning_f ~section "getElementById %s: Not_found" id;
raise Not_found)
(fun pnode -> pnode)
(* == Request nodes
(a.k.a. nodes with a unique Dom instance in the current request) *)
let register_request_node, find_request_node, reset_request_nodes =
let request_nodes : Dom.node Js.t Jstable.t ref = ref (Jstable.create ()) in
let find id = Jstable.find !request_nodes id in
let register id node =
Lwt_log.ign_debug_f ~section "Register request node %a"
(fun () -> Js.to_string)
id;
Jstable.add !request_nodes id node
in
let reset () =
Lwt_log.ign_debug ~section "Reset request nodes";
(* Unwrapped elements must be forced
before resetting the request node table. *)
force_unwrapped_elts ();
request_nodes := Jstable.create ()
in
register, find, reset
(* == Organize the phase of loading or change_page
In the following functions, onload referrers the initial loading phase
*and* to the change_page phase
*and* to the loading phase after caml services (added 2016-03 --V). *)
let load_mutex = Lwt_mutex.create ()
let _ = ignore (Lwt_mutex.lock load_mutex)
let in_onload, broadcast_load_end, wait_load_end, set_loading_phase =
let loading_phase = ref true in
let load_end = Lwt_condition.create () in
let set () = loading_phase := true in
let in_onload () = !loading_phase in
let broadcast_load_end () =
loading_phase := false;
Lwt_condition.broadcast load_end ()
in
let wait_load_end () =
if !loading_phase then Lwt_condition.wait load_end else Lwt.return_unit
in
in_onload, broadcast_load_end, wait_load_end, set
(* == Helper's functions for Eliom's event handler.
Allow conversion of Xml.event_handler to javascript closure and
their registration in Dom node.
*)
(* forward declaration... *)
let change_page_uri_
: (?cookies_info:bool * string list -> ?tmpl:string -> string -> unit) ref
=
ref (fun ?cookies_info:_ ?tmpl:_ _href -> assert false)
let change_page_get_form_
: (?cookies_info:bool * string list
-> ?tmpl:string
-> Dom_html.formElement Js.t
-> string
-> unit)
ref
=
ref (fun ?cookies_info:_ ?tmpl:_ _form _href -> assert false)
let change_page_post_form_ =
ref (fun ?cookies_info:_ ?tmpl:_ _form _href -> assert false)
type client_form_handler = Dom_html.event Js.t -> bool Lwt.t
let raw_a_handler node cookies_info tmpl ev =
let href = (Js.Unsafe.coerce node : Dom_html.anchorElement Js.t)##.href in
let https = Url.get_ssl (Js.to_string href) in
(* Returns true when the default link behaviour is to be kept: *)
middleClick ev
|| (not !Eliom_common.is_client_app)
&& ((https = Some true && not Eliom_request_info.ssl_)
|| (https = Some false && Eliom_request_info.ssl_))
||
((* If a link is clicked, we do not want to continue propagation
(for example if the link is in a wider clickable area) *)
Dom_html.stopPropagation ev;
!change_page_uri_ ?cookies_info ?tmpl (Js.to_string href);
false)
let raw_form_handler form kind cookies_info tmpl ev client_form_handler =
let action = Js.to_string form##.action in
let https = Url.get_ssl action in
let change_page_form =
match kind with
| `Form_get -> !change_page_get_form_
| `Form_post -> !change_page_post_form_
in
let f () =
Lwt.async @@ fun () ->
let%lwt b = client_form_handler ev in
if not b then change_page_form ?cookies_info ?tmpl form action;
Lwt.return_unit
in
(not !Eliom_common.is_client_app)
&& ((https = Some true && not Eliom_request_info.ssl_)
|| (https = Some false && Eliom_request_info.ssl_))
|| (f (); false)
let raw_event_handler value =
let handler =
(*XXX???*)
(Eliom_lib.from_poly (Eliom_lib.to_poly value)
: #Dom_html.event Js.t -> unit)
in
fun ev -> try handler ev; true with Eliom_client_value.False -> false
let closure_name_prefix = Eliom_runtime.RawXML.closure_name_prefix
let closure_name_prefix_len = String.length closure_name_prefix
let reify_caml_event name node ce =
match ce with
| Xml.CE_call_service None -> name, `Other (fun _ -> true)
| Xml.CE_call_service (Some (`A, cookies_info, tmpl, _)) ->
( name
, `Other
(fun ev ->
let node =
Js.Opt.get (Dom_html.CoerceTo.a node) (fun () ->
Lwt_log.raise_error ~section "not an anchor element")
in
raw_a_handler node cookies_info tmpl ev) )
| Xml.CE_call_service
(Some
(((`Form_get | `Form_post) as kind), cookies_info, tmpl, client_hdlr))
->
( name
, `Other
(fun ev ->
let form =
Js.Opt.get (Dom_html.CoerceTo.form node) (fun () ->
Lwt_log.raise_error ~section "not a form element")
in
raw_form_handler form kind cookies_info tmpl ev
(Eliom_lib.from_poly client_hdlr : client_form_handler)) )
| Xml.CE_client_closure f ->
( name
, `Other
(fun ev -> try f ev; true with Eliom_client_value.False -> false) )
| Xml.CE_client_closure_keyboard f ->
( name
, `Keyboard
(fun ev -> try f ev; true with Eliom_client_value.False -> false) )
| Xml.CE_client_closure_touch f ->
( name
, `Touch
(fun ev -> try f ev; true with Eliom_client_value.False -> false) )
| Xml.CE_client_closure_mouse f ->
( name
, `Mouse
(fun ev -> try f ev; true with Eliom_client_value.False -> false) )
| Xml.CE_registered_closure (_, cv) ->
let name =
let len = String.length name in
if len > closure_name_prefix_len
&& String.sub name 0 closure_name_prefix_len = closure_name_prefix
then
String.sub name closure_name_prefix_len (len - closure_name_prefix_len)
else name
in
name, `Other (raw_event_handler cv)
let register_event_handler, flush_load_script =
let add, _, flush, _ = create_buffer () in
let register node (name, ev) =
match reify_caml_event name node ev with
| "onload", `Other f -> add f
| "onload", `Keyboard _ -> failwith "keyboard event handler for onload"
| "onload", `Touch _ -> failwith "touch event handler for onload"
| "onload", `Mouse _ -> failwith "mouse event handler for onload"
| name, `Other f ->
Js.Unsafe.set node (Js.bytestring name)
(Dom_html.handler (fun ev -> Js.bool (f ev)))
| name, `Keyboard f ->
Js.Unsafe.set node (Js.bytestring name)
(Dom_html.handler (fun ev -> Js.bool (f ev)))
| name, `Touch f ->
Js.Unsafe.set node (Js.bytestring name)
(Dom_html.handler (fun ev -> Js.bool (f ev)))
| name, `Mouse f ->
Js.Unsafe.set node (Js.bytestring name)
(Dom_html.handler (fun ev -> Js.bool (f ev)))
in
let flush () =
let fs = flush () in
let ev = Eliommod_dom.createEvent (Js.string "load") in
ignore (List.for_all (fun f -> f ev) fs)
in
register, flush
let rebuild_attrib_val = function
| Xml.AFloat f -> (Js.number_of_float f)##toString
| Xml.AInt i -> (Js.number_of_float (float_of_int i))##toString
| Xml.AStr s -> Js.string s
| Xml.AStrL (Xml.Space, sl) -> Js.string (String.concat " " sl)
| Xml.AStrL (Xml.Comma, sl) -> Js.string (String.concat "," sl)
let class_list_of_racontent = function
| Xml.AStr s -> [s]
| Xml.AStrL (_space, l) -> l
| _ -> failwith "attribute class is not a string"
let class_list_of_racontent_o = function
| Some c -> class_list_of_racontent c
| None -> []
let rebuild_class_list l1 l2 l3 =
let f s =
(not (List.exists (( = ) s) l2)) && not (List.exists (( = ) s) l3)
in
l3 @ List.filter f l1
let rebuild_class_string l1 l2 l3 =
rebuild_class_list l1 l2 l3 |> String.concat " " |> Js.string
(* html attributes and dom properties use different names
**example**: maxlength vs maxLenght (case sensitive).
- Before dom react, it was enough to set html attributes only as
there were no update after creation.
- Dom React may update attributes later.
Html attrib changes are not taken into account if the corresponding
Dom property is defined.
**example**: updating html attribute `value` has no effect
if the dom property `value` has be set by the user.
=WE NEED TO SET DOM PROPERTIES=
-Tyxml only gives us html attribute names and we can set them safely.
-The name for dom properties is maybe different.
We set it only if we find out that the property
match_the_attribute_name / is_already_defined (get_prop).
*)
(* TODO: fix get_prop
it only work when html attribute and dom property names correspond.
find a way to get dom property name corresponding to html attribute
*)
let get_prop node name =
if Js.Optdef.test (Js.Unsafe.get node name) then Some name else None
let iter_prop node name f =
match get_prop node name with Some n -> f n | None -> ()
let iter_prop_protected node name f =
match get_prop node name with
| Some n -> ( try f n with _ -> ())
| None -> ()
let space_re = Regexp.regexp " "
let current_classes node =
let name = Js.string "class" in
Js.Opt.case
node ## (getAttribute name)
(fun () -> [])
(fun s -> Js.to_string s |> Regexp.(split space_re))
let rebuild_reactive_class_rattrib node s =
let name = Js.string "class" in
let e = React.S.diff (fun v v' -> v', v) s
and f (v, v') =
let l1 = current_classes node
and l2 = class_list_of_racontent_o v
and l3 = class_list_of_racontent_o v' in
let s = rebuild_class_string l1 l2 l3 in
node ## (setAttribute name s);
iter_prop node name (fun name -> Js.Unsafe.set node name s)
in
f (None, React.S.value s);
React.E.map f e |> ignore
let rec rebuild_rattrib node ra =
match Xml.racontent ra with
| Xml.RA a when Xml.aname ra = "class" ->
let l1 = current_classes node and l2 = class_list_of_racontent a in
let name = Js.string "class" and s = rebuild_class_string l1 l2 l2 in
node ## (setAttribute name s)
| Xml.RA a ->
let name = Js.string (Xml.aname ra) in
let v = rebuild_attrib_val a in
node ## (setAttribute name v)
| Xml.RAReact s when Xml.aname ra = "class" ->
rebuild_reactive_class_rattrib node s
| Xml.RAReact s ->
let name = Js.string (Xml.aname ra) in
let _ =
React.S.map
(function
| None ->
node ## (removeAttribute name);
iter_prop_protected node name (fun name ->
Js.Unsafe.set node name Js.null)
| Some v ->
let v = rebuild_attrib_val v in
node ## (setAttribute name v);
iter_prop_protected node name (fun name ->
Js.Unsafe.set node name v))
s
in
()
| Xml.RACamlEventHandler ev -> register_event_handler node (Xml.aname ra, ev)
| Xml.RALazyStr s ->
node ## (setAttribute (Js.string (Xml.aname ra)) (Js.string s))
| Xml.RALazyStrL (Xml.Space, l) ->
node
## (setAttribute
(Js.string (Xml.aname ra))
(Js.string (String.concat " " l)))
| Xml.RALazyStrL (Xml.Comma, l) ->
node
## (setAttribute
(Js.string (Xml.aname ra))
(Js.string (String.concat "," l)))
| Xml.RAClient (_, _, value) ->
rebuild_rattrib node
(Eliom_lib.from_poly (Eliom_lib.to_poly value) : Xml.attrib)
(* TODO: Registering a global "onunload" event handler breaks the
'bfcache' mechanism of Firefox and Safari. We may try to use
"pagehide" whenever this event exists. See:
https://developer.mozilla.org/En/Using_Firefox_1.5_caching
http://www.webkit.org/blog/516/webkit-page-cache-ii-the-unload-event/
and the function [Eliommod_dom.test_pageshow_pagehide]. *)
let delay f =
Lwt.ignore_result (Lwt.pause () >>= fun () -> f (); Lwt.return_unit)
module ReactState : sig
type t
val get_node : t -> Dom.node Js.t
val change_dom : t -> Dom.node Js.t -> bool
val init_or_update : ?state:t -> Eliom_content_core.Xml.elt -> t
end = struct
(*
ISSUE
=====
There is a conflict when many dom react are inside each other.
let s_lvl1 = S.map (function
| case1 -> ..
| case2 -> let s_lvl2 = ... in R.node s_lvl2) ...
in R.node s_lvl1
both dom react will update the same dom element (call it `dom_elt`) and
we have to prevent an (outdated) s_lvl2 signal
to replace `dom_elt` (updated last by a s_lvl1 signal)
SOLUTION
========
- an array to track versions of updates - a dom react store its version at a specify position (computed from the depth).
- a child can only update `dom_elt` if versions of its parents haven't changed.
- every time a dom react update `dom_elt`, it increment its version.
*)
type t =
{ elt : Eliom_content_core.Xml.elt
; (* top element that will store the dom *)
global_version : int Js.js_array Js.t
; (* global versions array *)
version_copy : int Js.js_array Js.t
; (* versions when the signal started *)
pos : int (* equal the depth *) }
let get_node t =
match Xml.get_node t.elt with Xml.DomNode d -> d | _ -> assert false
let change_dom state dom =
let pos = state.pos in
let outdated = ref false in
for i = 0 to pos - 1 do
if Js.array_get state.version_copy i
!= Js.array_get state.global_version i
(* a parent changed *)
then outdated := true
done;
if not !outdated
then (
if dom != get_node state
then (
(* new version *)
let nv =
Js.Optdef.get (Js.array_get state.global_version pos) (fun _ -> 0) + 1
in
Js.array_set state.global_version pos nv;
(* Js.array_set state.version_copy pos nv; *)
Js.Opt.case
(get_node state)##.parentNode
(fun () -> (* no parent -> no replace needed *) ())
(fun parent ->
Js.Opt.iter (Dom.CoerceTo.element parent) (fun parent ->
(* really update the dom *)
ignore
(Dom_html.element parent)
## (replaceChild dom (get_node state))));
Xml.set_dom_node state.elt dom);
false)
else
(* a parent signal changed,
this dom react is outdated, do not update the dom *)
true
let clone_array a = a ## (slice_end 0)
let init_or_update ?state elt =
match state with
| None ->
(* top dom react, create a state *)
let global_version = new%js Js.array_empty in
let pos = 0 in
ignore (Js.array_set global_version pos 0);
let node =
(Dom_html.document ## (createElement (Js.string "span"))
:> Dom.node Js.t)
in
Xml.set_dom_node elt node;
{pos; global_version; version_copy = clone_array global_version; elt}
| Some p ->
(* child dom react, compute a state from the previous one *)
let pos = p.pos + 1 in
ignore (Js.array_set p.global_version pos 0);
{p with pos; version_copy = clone_array p.global_version}
end
type content_ns = [`HTML5 | `SVG]
let rec rebuild_node_with_state ns ?state elt =
match Xml.get_node elt with
| Xml.DomNode node ->
(* assert (Xml.get_node_id node <> NoId); *)
node
| Xml.ReactChildren (node, elts) ->
let dom = raw_rebuild_node ns node in
Js_of_ocaml_tyxml.Tyxml_js.Util.update_children dom
(ReactiveData.RList.map (rebuild_node' ns) elts);
Xml.set_dom_node elt dom;
dom
| Xml.ReactNode signal ->
let state = ReactState.init_or_update ?state elt in
let clear = ref None in
let update_signal =
React.S.map
(fun elt' ->
let dom = rebuild_node_with_state ns ~state elt' in
let need_cleaning = ReactState.change_dom state dom in
if need_cleaning
then
match !clear with
| None -> ()
| Some s ->
delay (fun () ->
React.S.stop s (* clear/stop the signal we created *));
clear := None)
signal
in
clear := Some update_signal;
ReactState.get_node state
| Xml.TyXMLNode raw_elt -> (
match Xml.get_node_id elt with
| Xml.NoId -> raw_rebuild_node ns raw_elt
| Xml.RequestId _ ->
(* Do not look in request_nodes hashtbl: such elements have
been bind while unwrapping nodes. *)
let node = raw_rebuild_node ns raw_elt in
Xml.set_dom_node elt node; node
| Xml.ProcessId id ->
let id = Js.string id in
Js.Optdef.case (find_process_node id)
(fun () ->
let node = raw_rebuild_node ns (Xml.content elt) in
register_process_node id node;
node)
(fun n -> (n :> Dom.node Js.t)))
and rebuild_node' ns e = rebuild_node_with_state ns e
and raw_rebuild_node ns = function
| Xml.Empty | Xml.Comment _ ->
(* FIXME *)
(Dom_html.document ## (createTextNode (Js.string "")) :> Dom.node Js.t)
| Xml.EncodedPCDATA s | Xml.PCDATA s ->
(Dom_html.document ## (createTextNode (Js.string s)) :> Dom.node Js.t)
| Xml.Entity s ->
let entity = Dom_html.decode_html_entities (Js.string ("&" ^ s ^ ";")) in
(Dom_html.document ## (createTextNode entity) :> Dom.node Js.t)
| Xml.Leaf (name, attribs) ->
let node = Dom_html.document ## (createElement (Js.string name)) in
List.iter (rebuild_rattrib node) attribs;
(node :> Dom.node Js.t)
| Xml.Node (name, attribs, childrens) ->
let ns = if name = "svg" then `SVG else ns in
let node =
match ns with
| `HTML5 -> Dom_html.document ## (createElement (Js.string name))
| `SVG ->
let svg_ns = "http://www.w3.org/2000/svg" in
Dom_html.document
## (createElementNS (Js.string svg_ns) (Js.string name))
in
List.iter (rebuild_rattrib node) attribs;
List.iter (fun c -> Dom.appendChild node (rebuild_node' ns c)) childrens;
(node :> Dom.node Js.t)
(* [is_before_initial_load] tests whether it is executed before the
loading of the initial document, e.g. during the initialization of the
(OCaml) module, i.e. before [Eliom_client_main.onload]. *)
let is_before_initial_load, set_initial_load =
let before_load = ref true in
(fun () -> !before_load), fun () -> before_load := false
let rebuild_node_ns ns context elt' =
Lwt_log.ign_debug_f ~section "Rebuild node %a (%s)"
(fun () e -> Eliom_content_core.Xml.string_of_node_id (Xml.get_node_id e))
elt' context;
if is_before_initial_load ()
then
Lwt_log.raise_error_f ~section ~inspect:(rebuild_node' ns elt')
"Cannot apply %s%s before the document is initially loaded" context
Xml.(
match get_node_id elt' with
| NoId -> " "
| RequestId id -> " on request node " ^ id
| ProcessId id -> " on global node " ^ id);
let node = Js.Unsafe.coerce (rebuild_node' ns elt') in
flush_load_script (); node
let rebuild_node_svg context elt =
let elt' = Eliom_content_core.Svg.F.toelt elt in
rebuild_node_ns `SVG context elt'
(** The first argument describes the calling function (if any) in case
of an error. *)
let rebuild_node context elt =
let elt' = Eliom_content_core.Html.F.toelt elt in
rebuild_node_ns `HTML5 context elt'
(******************************************************************************)
module Syntax_helpers = struct
let register_client_closure closure_id closure =
Client_closure.register ~closure_id ~closure
let open_client_section compilation_unit_id =
do_next_server_section_data ~compilation_unit_id;
do_next_client_section_data ~compilation_unit_id
let close_server_section compilation_unit_id =
do_next_server_section_data ~compilation_unit_id
let get_escaped_value = from_poly
let get_injection ?ident ?pos name = Injection.get ?ident ?pos ~name
end
| (* Ocsigen
* http://www.ocsigen.org
* Copyright (C) 2010 Vincent Balat
* Copyright (C) 2011 Jérôme Vouillon, Grégoire Henry, Pierre Chambart
* Copyright (C) 2012 Benedikt Becker
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, with linking exception;
* either version 2.1 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*) |
test_bigstringaf.ml |
let of_string () =
let open Bigstringaf in
let exn = Invalid_argument "Bigstringaf.of_string invalid range: { buffer_len: 3, off: 4611686018427387903, len: 2 }" in
Alcotest.check_raises "safe overflow" exn (fun () -> ignore (of_string ~off:max_int ~len:2 "abc"))
;;
let constructors =
[ "of_string", `Quick, of_string ]
let index_out_of_bounds () =
let open Bigstringaf in
let exn = Invalid_argument "index out of bounds" in
let string = "\xde\xad\xbe\xef" in
let buffer = of_string ~off:0 ~len:(String.length string) string in
Alcotest.check_raises "get empty 0" exn (fun () -> ignore (get empty 0));
let check_safe_getter name get =
Alcotest.check_raises name exn (fun () -> ignore (get buffer (-1)));
Alcotest.check_raises name exn (fun () -> ignore (get buffer (length buffer)));
in
check_safe_getter "get" get;
check_safe_getter "get_int16_le" get_int16_le;
check_safe_getter "get_int16_be" get_int16_be;
check_safe_getter "get_int16_sign_extended_le" get_int16_sign_extended_le;
check_safe_getter "get_int16_sign_extended_be" get_int16_sign_extended_be;
check_safe_getter "get_int32_le" get_int32_le;
check_safe_getter "get_int32_be" get_int32_be;
check_safe_getter "get_int64_le" get_int64_le;
check_safe_getter "get_int64_be" get_int64_be;
;;
let getters m () =
let module Getters = (val m : S.Getters) in
let open Getters in
let string = "\xde\xad\xbe\xef\x8b\xad\xf0\x0d" in
let buffer = Bigstringaf.of_string ~off:0 ~len:(String.length string) string in
Alcotest.(check char "get" '\xde' (get buffer 0));
Alcotest.(check char "get" '\xbe' (get buffer 2));
Alcotest.(check int "get_int16_be" 0xdead (get_int16_be buffer 0));
Alcotest.(check int "get_int16_be" 0xbeef (get_int16_be buffer 2));
Alcotest.(check int "get_int16_le" 0xadde (get_int16_le buffer 0));
Alcotest.(check int "get_int16_le" 0xefbe (get_int16_le buffer 2));
Alcotest.(check int "get_int16_sign_extended_be" 0x7fffffffffffdead (get_int16_sign_extended_be buffer 0));
Alcotest.(check int "get_int16_sign_extended_le" 0x7fffffffffffadde (get_int16_sign_extended_le buffer 0));
Alcotest.(check int "get_int16_sign_extended_le" 0x0df0 (get_int16_sign_extended_le buffer 6));
Alcotest.(check int32 "get_int32_be" 0xdeadbeefl (get_int32_be buffer 0));
Alcotest.(check int32 "get_int32_be" 0xbeef8badl (get_int32_be buffer 2));
Alcotest.(check int32 "get_int32_le" 0xefbeaddel (get_int32_le buffer 0));
Alcotest.(check int32 "get_int32_le" 0xad8befbel (get_int32_le buffer 2));
Alcotest.(check int64 "get_int64_be" 0xdeadbeef8badf00dL (get_int64_be buffer 0));
Alcotest.(check int64 "get_int64_le" 0x0df0ad8befbeaddeL (get_int64_le buffer 0));
;;
let setters m () =
let module Setters = (val m : S.Setters) in
let open Setters in
let string = Bytes.make 16 '_' |> Bytes.unsafe_to_string in
let with_buffer ~f =
let buffer = Bigstringaf.of_string ~off:0 ~len:(String.length string) string in
f buffer
in
let substring ~len buffer = Bigstringaf.substring ~off:0 ~len buffer in
with_buffer ~f:(fun buffer ->
set buffer 0 '\xde';
Alcotest.(check string "set" "\xde___" (substring ~len:4 buffer)));
with_buffer ~f:(fun buffer ->
set buffer 2 '\xbe';
Alcotest.(check string "set" "__\xbe_" (substring ~len:4 buffer)));
with_buffer ~f:(fun buffer ->
set_int16_be buffer 0 0xdead;
Alcotest.(check string "set_int16_be" "\xde\xad__" (substring ~len:4 buffer)));
with_buffer ~f:(fun buffer ->
set_int16_be buffer 2 0xbeef;
Alcotest.(check string "set_int16_be" "__\xbe\xef" (substring ~len:4 buffer)));
with_buffer ~f:(fun buffer ->
set_int16_le buffer 0 0xdead;
Alcotest.(check string "set_int16_le" "\xad\xde__" (substring ~len:4 buffer)));
with_buffer ~f:(fun buffer ->
set_int16_le buffer 2 0xbeef;
Alcotest.(check string "set_int16_le" "__\xef\xbe" (substring ~len:4 buffer)));
with_buffer ~f:(fun buffer ->
set_int32_be buffer 0 0xdeadbeefl;
Alcotest.(check string "set_int32_be" "\xde\xad\xbe\xef____" (substring ~len:8 buffer)));
with_buffer ~f:(fun buffer ->
set_int32_le buffer 0 0xdeadbeefl;
Alcotest.(check string "set_int32_le" "\xef\xbe\xad\xde____" (substring ~len:8 buffer)));
with_buffer ~f:(fun buffer ->
set_int32_be buffer 2 0xbeef8badl;
Alcotest.(check string "set_int32_be" "__\xbe\xef\x8b\xad__" (substring ~len:8 buffer)));
with_buffer ~f:(fun buffer ->
set_int32_le buffer 2 0xbeef8badl;
Alcotest.(check string "set_int32_le" "__\xad\x8b\xef\xbe__" (substring ~len:8 buffer)));
with_buffer ~f:(fun buffer ->
set_int64_be buffer 0 0xdeadbeef8badf00dL;
Alcotest.(check string "set_int64_be" "\xde\xad\xbe\xef\x8b\xad\xf0\x0d" (substring ~len:8 buffer)));
with_buffer ~f:(fun buffer ->
set_int64_le buffer 0 0xdeadbeef8badf00dL;
Alcotest.(check string "set_int64_le" "\x0d\xf0\xad\x8b\xef\xbe\xad\xde" (substring ~len:8 buffer)));
;;
let string1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
let string2 = "abcdefghijklmnopqrstuvwxyz"
let blit m () =
let module Blit = (val m : S.Blit) in
let open Blit in
let with_buffers ~f =
let buffer1 = Bigstringaf.of_string string1 ~off:0 ~len:(String.length string1) in
let buffer2 = Bigstringaf.of_string string2 ~off:0 ~len:(String.length string2) in
f buffer1 buffer2
in
with_buffers ~f:(fun buf1 buf2 ->
blit buf1 ~src_off:0 buf2 ~dst_off:0 ~len:0;
let new_string2 = Bigstringaf.substring buf2 ~off:0 ~len:(Bigstringaf.length buf2) in
Alcotest.(check string "empty blit" string2 new_string2));
with_buffers ~f:(fun buf1 buf2 ->
blit buf1 ~src_off:0 buf2 ~dst_off:0 ~len:(Bigstringaf.length buf2);
let new_string2 = Bigstringaf.substring buf2 ~off:0 ~len:(Bigstringaf.length buf2) in
Alcotest.(check string "full blit to another buffer" string1 new_string2));
with_buffers ~f:(fun buf1 _buf2 ->
blit buf1 ~src_off:0 buf1 ~dst_off:0 ~len:(Bigstringaf.length buf1);
let new_string1 = Bigstringaf.substring buf1 ~off:0 ~len:(Bigstringaf.length buf1) in
Alcotest.(check string "entirely overlapping blit (unchanged)" string1 new_string1));
with_buffers ~f:(fun buf1 buf2 ->
blit buf1 ~src_off:0 buf2 ~dst_off:4 ~len:8;
let new_string2 = Bigstringaf.substring buf2 ~off:0 ~len:(Bigstringaf.length buf2) in
Alcotest.(check string "partial blit to another buffer" "abcdABCDEFGHmnopqrstuvwxyz" new_string2));
with_buffers ~f:(fun buf1 _buf2 ->
blit buf1 ~src_off:0 buf1 ~dst_off:4 ~len:8;
let new_string1 = Bigstringaf.substring buf1 ~off:0 ~len:(Bigstringaf.length buf1) in
Alcotest.(check string "partially overlapping" "ABCDABCDEFGHMNOPQRSTUVWXYZ" new_string1));
;;
let blit_to_bytes m () =
let module Blit = (val m : S.Blit) in
let open Blit in
let with_buffers ~f =
let buffer1 = string1 in
let buffer2 = Bigstringaf.of_string string2 ~off:0 ~len:(String.length string2) in
f buffer1 buffer2
in
with_buffers ~f:(fun buf1 buf2 ->
blit_from_string buf1 ~src_off:0 buf2 ~dst_off:0 ~len:0;
let new_string2 = Bigstringaf.substring buf2 ~off:0 ~len:(Bigstringaf.length buf2) in
Alcotest.(check string "empty blit" string2 new_string2));
with_buffers ~f:(fun buf1 buf2 ->
blit_from_string buf1 ~src_off:0 buf2 ~dst_off:0 ~len:(Bigstringaf.length buf2);
let new_string2 = Bigstringaf.substring buf2 ~off:0 ~len:(Bigstringaf.length buf2) in
Alcotest.(check string "full blit to another buffer" string1 new_string2));
with_buffers ~f:(fun buf1 buf2 ->
blit_from_string buf1 ~src_off:0 buf2 ~dst_off:4 ~len:8;
let new_string2 = Bigstringaf.substring buf2 ~off:0 ~len:(Bigstringaf.length buf2) in
Alcotest.(check string "partial blit to another buffer" "abcdABCDEFGHmnopqrstuvwxyz" new_string2));
;;
let blit_from_bytes m () =
let module Blit = (val m : S.Blit) in
let open Blit in
let with_buffers ~f =
let buffer1 = Bytes.of_string string1 in
let buffer2 = Bigstringaf.of_string string2 ~off:0 ~len:(String.length string2) in
f buffer1 buffer2
in
with_buffers ~f:(fun buf1 buf2 ->
blit_from_bytes buf1 ~src_off:0 buf2 ~dst_off:0 ~len:0;
let new_string2 = Bigstringaf.substring buf2 ~off:0 ~len:(Bigstringaf.length buf2) in
Alcotest.(check string "empty blit" string2 new_string2));
with_buffers ~f:(fun buf1 buf2 ->
blit_from_bytes buf1 ~src_off:0 buf2 ~dst_off:0 ~len:(Bigstringaf.length buf2);
let new_string2 = Bigstringaf.substring buf2 ~off:0 ~len:(Bigstringaf.length buf2) in
Alcotest.(check string "full blit to another buffer" string1 new_string2));
with_buffers ~f:(fun buf1 buf2 ->
blit_from_bytes buf1 ~src_off:0 buf2 ~dst_off:4 ~len:8;
let new_string2 = Bigstringaf.substring buf2 ~off:0 ~len:(Bigstringaf.length buf2) in
Alcotest.(check string "partial blit to another buffer" "abcdABCDEFGHmnopqrstuvwxyz" new_string2));
;;
let memcmp m () =
let module Memcmp = (val m : S.Memcmp) in
let open Memcmp in
let buffer1 = Bigstringaf.of_string ~off:0 ~len:(String.length string1) string1 in
let buffer2 = Bigstringaf.of_string ~off:0 ~len:(String.length string2) string2 in
Alcotest.(check bool "identical buffers are equal" true
(memcmp buffer1 0 buffer1 0 (Bigstringaf.length buffer1) = 0));
Alcotest.(check bool "prefix of identical buffers are equal" true
(memcmp buffer1 0 buffer1 0 (Bigstringaf.length buffer1 - 10 ) = 0));
Alcotest.(check bool "suffix of identical buffers are equal" true
(memcmp buffer1 10 buffer1 10 (Bigstringaf.length buffer1 - 10) = 0));
Alcotest.(check bool "uppercase is less than uppercase" true
(memcmp buffer1 0 buffer2 0 (Bigstringaf.length buffer1) < 0));
Alcotest.(check bool "lowercase is greater than uppercase" true
(memcmp buffer2 0 buffer1 0 (Bigstringaf.length buffer1) > 0));
;;
let memcmp_string m () =
let module Memcmp = (val m : S.Memcmp) in
let open Memcmp in
let buffer1 = Bigstringaf.of_string ~off:0 ~len:(String.length string1) string1 in
let buffer2 = Bigstringaf.of_string ~off:0 ~len:(String.length string2) string2 in
Alcotest.(check bool "of_string'd and original buffer are equal" true
(memcmp_string buffer1 0 string1 0 (Bigstringaf.length buffer1) = 0));
Alcotest.(check bool "prefix of of_string'd and original buffer are equal" true
(memcmp_string buffer1 10 string1 10 (Bigstringaf.length buffer1 - 10) = 0));
Alcotest.(check bool "suffix of identical buffers are equal" true
(memcmp_string buffer1 10 string1 10 (Bigstringaf.length buffer1 - 10) = 0));
Alcotest.(check bool "uppercase is less than uppercase" true
(memcmp_string buffer1 0 string2 0 (Bigstringaf.length buffer1) < 0));
Alcotest.(check bool "lowercase is greater than uppercase" true
(memcmp_string buffer2 0 string1 0 (Bigstringaf.length buffer1) > 0));
()
;;
let memchr m () =
let module Memchr = (val m : S.Memchr) in
let open Memchr in
let string = "hello world foo bar baz" in
let buffer = Bigstringaf.of_string ~off:0 ~len:(String.length string) string in
let buffer_len = Bigstringaf.length buffer in
Alcotest.(check int) "memchr starting at offset 0" (String.index_from string 0 ' ')
(memchr buffer 0 ' ' buffer_len);
Alcotest.(check int) "memchr with an offset" (String.index_from string 7 ' ')
(memchr buffer 7 ' ' (buffer_len - 7));
Alcotest.(check int) "memchr char not found" (-1)
(memchr buffer 0 'Z' buffer_len)
let negative_bounds_check () =
let open Bigstringaf in
let buf = Bigstringaf.empty in
let exn_str fn =
Invalid_argument
(Printf.sprintf
"Bigstringaf.%s invalid range: { buffer_len: 0, off: 0, len: -8 }"
fn)
in
let exn_ba fn =
Invalid_argument
(Printf.sprintf
"Bigstringaf.%s invalid range: { src_len: 0, src_off: 0, dst_len: 0, dst_off: 4, len: -8 }"
fn)
in
let exn_cmp fn =
Invalid_argument
(Printf.sprintf
"Bigstringaf.%s invalid range: { buf1_len: 0, buf1_off: 0, buf2_len: 0, buf2_off: 0, len: -8 }"
fn)
in
Alcotest.check_raises "copy"
(exn_str "copy")
(fun () -> ignore (copy buf ~off:0 ~len:(-8)));
Alcotest.check_raises "substring"
(exn_str "substring")
(fun () -> ignore (substring buf ~off:0 ~len:(-8)));
Alcotest.check_raises "of_string"
(exn_str "of_string")
(fun () -> ignore (of_string "" ~off:0 ~len:(-8)));
Alcotest.check_raises "blit"
(exn_ba "blit")
(fun () -> ignore (blit buf ~src_off:0 buf ~dst_off:4 ~len:(-8)));
Alcotest.check_raises "blit_from_string"
(exn_ba "blit_from_string")
(fun () ->
ignore (blit_from_string "" ~src_off:0 buf ~dst_off:4 ~len:(-8)));
Alcotest.check_raises "blit_from_bytes"
(exn_ba "blit_from_bytes")
(fun () ->
ignore (blit_from_bytes (Bytes.of_string "") ~src_off:0 buf ~dst_off:4 ~len:(-8)));
Alcotest.check_raises "blit_to_bytes"
(exn_ba "blit_to_bytes")
(fun () ->
ignore (blit_to_bytes buf ~src_off:0 (Bytes.of_string "") ~dst_off:4 ~len:(-8)));
Alcotest.check_raises "memcmp"
(exn_cmp "memcmp")
(fun () ->
ignore (memcmp buf 0 buf 0 (-8)));
Alcotest.check_raises "memcmp_string"
(exn_cmp "memcmp_string")
(fun () ->
ignore (memcmp_string buf 0 "" 0 (-8)));
;;
let safe_operations =
let module Getters : S.Getters = Bigstringaf in
let module Setters : S.Setters = Bigstringaf in
let module Blit : S.Blit = Bigstringaf in
let module Memcmp : S.Memcmp = Bigstringaf in
let module Memchr : S.Memchr = Bigstringaf in
[ "index out of bounds", `Quick, index_out_of_bounds
; "getters" , `Quick, getters (module Getters)
; "setters" , `Quick, setters (module Setters)
; "blit" , `Quick, blit (module Blit)
; "blit_to_bytes" , `Quick, blit_to_bytes (module Blit)
; "blit_from_bytes" , `Quick, blit_from_bytes (module Blit)
; "memcmp" , `Quick, memcmp (module Memcmp)
; "memcmp_string" , `Quick, memcmp_string (module Memcmp)
; "negative length" , `Quick, negative_bounds_check
; "memchr" , `Quick, memchr (module Memchr)
]
let unsafe_operations =
let module Getters : S.Getters = struct
open Bigstringaf
let get = unsafe_get
let get_int16_le = unsafe_get_int16_le
let get_int16_sign_extended_le = unsafe_get_int16_sign_extended_le
let get_int32_le = unsafe_get_int32_le
let get_int64_le = unsafe_get_int64_le
let get_int16_be = unsafe_get_int16_be
let get_int16_sign_extended_be = unsafe_get_int16_sign_extended_be
let get_int32_be = unsafe_get_int32_be
let get_int64_be = unsafe_get_int64_be
end in
let module Setters : S.Setters = struct
open Bigstringaf
let set = unsafe_set
let set_int16_le = unsafe_set_int16_le
let set_int32_le = unsafe_set_int32_le
let set_int64_le = unsafe_set_int64_le
let set_int16_be = unsafe_set_int16_be
let set_int32_be = unsafe_set_int32_be
let set_int64_be = unsafe_set_int64_be
end in
let module Blit : S.Blit = struct
open Bigstringaf
let blit = unsafe_blit
let blit_from_string = unsafe_blit_from_string
let blit_from_bytes = unsafe_blit_from_bytes
let blit_to_bytes = unsafe_blit_to_bytes
end in
let module Memcmp : S.Memcmp = struct
open Bigstringaf
let memcmp = unsafe_memcmp
let memcmp_string = unsafe_memcmp_string
end in
let module Memchr : S.Memchr = struct
open Bigstringaf
let memchr = unsafe_memchr
end in
[ "getters" , `Quick, getters (module Getters)
; "setters" , `Quick, setters (module Setters)
; "blit" , `Quick, blit (module Blit)
; "blit_to_bytes" , `Quick, blit_to_bytes (module Blit)
; "blit_from_bytes", `Quick, blit_from_bytes (module Blit)
; "memcmp" , `Quick, memcmp (module Memcmp)
; "memcmp_string" , `Quick, memcmp_string (module Memcmp)
; "memchr" , `Quick, memchr (module Memchr)
]
let () =
Alcotest.run "test suite"
[ "constructors" , constructors
; "safe operations" , safe_operations
; "unsafe operations", unsafe_operations ]
| |
topoSort.mli | (** Time-stamp: <modified the 03/02/2016 (at 10:04) by Erwan Jahier> *)
module type PartialOrder =
sig
type elt
type store
val have_dep : store -> elt -> bool
val find_dep : store -> elt -> elt list
val remove_dep:store -> elt -> store
end
module type S =
sig
type elt
type store
exception DependencyCycle of elt * elt list
val check_there_is_no_cycle : store -> elt list -> unit
val f : store -> elt list -> elt list
end
module Make(PO: PartialOrder) : S
with type elt = PO.elt
with type store = PO.store
| (** Time-stamp: <modified the 03/02/2016 (at 10:04) by Erwan Jahier> *)
|
test.ml | let () =
Alcotest_lwt.run
"tezos-shell-context"
[("mem_context", Test_mem_context.tests)]
|> Lwt_main.run
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
glpapi06.c | /* glpapi06.c (simplex method routines) */
/***********************************************************************
* This code is part of GLPK (GNU Linear Programming Kit).
* Copyright (C) 2007-2018 Free Software Foundation, Inc.
* Written by Andrew Makhorin <mao@gnu.org>.
*
* GLPK is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GLPK is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
* License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GLPK. If not, see <http://www.gnu.org/licenses/>.
***********************************************************************/
#include "env.h"
#include "ios.h"
#include "npp.h"
#if 0 /* 07/XI-2015 */
#include "glpspx.h"
#else
#include "simplex.h"
#define spx_dual spy_dual
#endif
/***********************************************************************
* NAME
*
* glp_simplex - solve LP problem with the simplex method
*
* SYNOPSIS
*
* int glp_simplex(glp_prob *P, const glp_smcp *parm);
*
* DESCRIPTION
*
* The routine glp_simplex is a driver to the LP solver based on the
* simplex method. This routine retrieves problem data from the
* specified problem object, calls the solver to solve the problem
* instance, and stores results of computations back into the problem
* object.
*
* The simplex solver has a set of control parameters. Values of the
* control parameters can be passed in a structure glp_smcp, which the
* parameter parm points to.
*
* The parameter parm can be specified as NULL, in which case the LP
* solver uses default settings.
*
* RETURNS
*
* 0 The LP problem instance has been successfully solved. This code
* does not necessarily mean that the solver has found optimal
* solution. It only means that the solution process was successful.
*
* GLP_EBADB
* Unable to start the search, because the initial basis specified
* in the problem object is invalid--the number of basic (auxiliary
* and structural) variables is not the same as the number of rows in
* the problem object.
*
* GLP_ESING
* Unable to start the search, because the basis matrix correspodning
* to the initial basis is singular within the working precision.
*
* GLP_ECOND
* Unable to start the search, because the basis matrix correspodning
* to the initial basis is ill-conditioned, i.e. its condition number
* is too large.
*
* GLP_EBOUND
* Unable to start the search, because some double-bounded variables
* have incorrect bounds.
*
* GLP_EFAIL
* The search was prematurely terminated due to the solver failure.
*
* GLP_EOBJLL
* The search was prematurely terminated, because the objective
* function being maximized has reached its lower limit and continues
* decreasing (dual simplex only).
*
* GLP_EOBJUL
* The search was prematurely terminated, because the objective
* function being minimized has reached its upper limit and continues
* increasing (dual simplex only).
*
* GLP_EITLIM
* The search was prematurely terminated, because the simplex
* iteration limit has been exceeded.
*
* GLP_ETMLIM
* The search was prematurely terminated, because the time limit has
* been exceeded.
*
* GLP_ENOPFS
* The LP problem instance has no primal feasible solution (only if
* the LP presolver is used).
*
* GLP_ENODFS
* The LP problem instance has no dual feasible solution (only if the
* LP presolver is used). */
static void trivial_lp(glp_prob *P, const glp_smcp *parm)
{ /* solve trivial LP which has empty constraint matrix */
GLPROW *row;
GLPCOL *col;
int i, j;
double p_infeas, d_infeas, zeta;
P->valid = 0;
P->pbs_stat = P->dbs_stat = GLP_FEAS;
P->obj_val = P->c0;
P->some = 0;
p_infeas = d_infeas = 0.0;
/* make all auxiliary variables basic */
for (i = 1; i <= P->m; i++)
{ row = P->row[i];
row->stat = GLP_BS;
row->prim = row->dual = 0.0;
/* check primal feasibility */
if (row->type == GLP_LO || row->type == GLP_DB ||
row->type == GLP_FX)
{ /* row has lower bound */
if (row->lb > + parm->tol_bnd)
{ P->pbs_stat = GLP_NOFEAS;
if (P->some == 0 && parm->meth != GLP_PRIMAL)
P->some = i;
}
if (p_infeas < + row->lb)
p_infeas = + row->lb;
}
if (row->type == GLP_UP || row->type == GLP_DB ||
row->type == GLP_FX)
{ /* row has upper bound */
if (row->ub < - parm->tol_bnd)
{ P->pbs_stat = GLP_NOFEAS;
if (P->some == 0 && parm->meth != GLP_PRIMAL)
P->some = i;
}
if (p_infeas < - row->ub)
p_infeas = - row->ub;
}
}
/* determine scale factor for the objective row */
zeta = 1.0;
for (j = 1; j <= P->n; j++)
{ col = P->col[j];
if (zeta < fabs(col->coef)) zeta = fabs(col->coef);
}
zeta = (P->dir == GLP_MIN ? +1.0 : -1.0) / zeta;
/* make all structural variables non-basic */
for (j = 1; j <= P->n; j++)
{ col = P->col[j];
if (col->type == GLP_FR)
col->stat = GLP_NF, col->prim = 0.0;
else if (col->type == GLP_LO)
lo: col->stat = GLP_NL, col->prim = col->lb;
else if (col->type == GLP_UP)
up: col->stat = GLP_NU, col->prim = col->ub;
else if (col->type == GLP_DB)
{ if (zeta * col->coef > 0.0)
goto lo;
else if (zeta * col->coef < 0.0)
goto up;
else if (fabs(col->lb) <= fabs(col->ub))
goto lo;
else
goto up;
}
else if (col->type == GLP_FX)
col->stat = GLP_NS, col->prim = col->lb;
col->dual = col->coef;
P->obj_val += col->coef * col->prim;
/* check dual feasibility */
if (col->type == GLP_FR || col->type == GLP_LO)
{ /* column has no upper bound */
if (zeta * col->dual < - parm->tol_dj)
{ P->dbs_stat = GLP_NOFEAS;
if (P->some == 0 && parm->meth == GLP_PRIMAL)
P->some = P->m + j;
}
if (d_infeas < - zeta * col->dual)
d_infeas = - zeta * col->dual;
}
if (col->type == GLP_FR || col->type == GLP_UP)
{ /* column has no lower bound */
if (zeta * col->dual > + parm->tol_dj)
{ P->dbs_stat = GLP_NOFEAS;
if (P->some == 0 && parm->meth == GLP_PRIMAL)
P->some = P->m + j;
}
if (d_infeas < + zeta * col->dual)
d_infeas = + zeta * col->dual;
}
}
/* simulate the simplex solver output */
if (parm->msg_lev >= GLP_MSG_ON && parm->out_dly == 0)
{ xprintf("~%6d: obj = %17.9e infeas = %10.3e\n", P->it_cnt,
P->obj_val, parm->meth == GLP_PRIMAL ? p_infeas : d_infeas);
}
if (parm->msg_lev >= GLP_MSG_ALL && parm->out_dly == 0)
{ if (P->pbs_stat == GLP_FEAS && P->dbs_stat == GLP_FEAS)
xprintf("OPTIMAL SOLUTION FOUND\n");
else if (P->pbs_stat == GLP_NOFEAS)
xprintf("PROBLEM HAS NO FEASIBLE SOLUTION\n");
else if (parm->meth == GLP_PRIMAL)
xprintf("PROBLEM HAS UNBOUNDED SOLUTION\n");
else
xprintf("PROBLEM HAS NO DUAL FEASIBLE SOLUTION\n");
}
return;
}
static int solve_lp(glp_prob *P, const glp_smcp *parm)
{ /* solve LP directly without using the preprocessor */
int ret;
if (!glp_bf_exists(P))
{ ret = glp_factorize(P);
if (ret == 0)
;
else if (ret == GLP_EBADB)
{ if (parm->msg_lev >= GLP_MSG_ERR)
xprintf("glp_simplex: initial basis is invalid\n");
}
else if (ret == GLP_ESING)
{ if (parm->msg_lev >= GLP_MSG_ERR)
xprintf("glp_simplex: initial basis is singular\n");
}
else if (ret == GLP_ECOND)
{ if (parm->msg_lev >= GLP_MSG_ERR)
xprintf(
"glp_simplex: initial basis is ill-conditioned\n");
}
else
xassert(ret != ret);
if (ret != 0) goto done;
}
if (parm->meth == GLP_PRIMAL)
ret = spx_primal(P, parm);
else if (parm->meth == GLP_DUALP)
{ ret = spx_dual(P, parm);
if (ret == GLP_EFAIL && P->valid)
ret = spx_primal(P, parm);
}
else if (parm->meth == GLP_DUAL)
ret = spx_dual(P, parm);
else
xassert(parm != parm);
done: return ret;
}
static int preprocess_and_solve_lp(glp_prob *P, const glp_smcp *parm)
{ /* solve LP using the preprocessor */
NPP *npp;
glp_prob *lp = NULL;
glp_bfcp bfcp;
int ret;
if (parm->msg_lev >= GLP_MSG_ALL)
xprintf("Preprocessing...\n");
/* create preprocessor workspace */
npp = npp_create_wksp();
/* load original problem into the preprocessor workspace */
npp_load_prob(npp, P, GLP_OFF, GLP_SOL, GLP_OFF);
/* process LP prior to applying primal/dual simplex method */
ret = npp_simplex(npp, parm);
if (ret == 0)
;
else if (ret == GLP_ENOPFS)
{ if (parm->msg_lev >= GLP_MSG_ALL)
xprintf("PROBLEM HAS NO PRIMAL FEASIBLE SOLUTION\n");
}
else if (ret == GLP_ENODFS)
{ if (parm->msg_lev >= GLP_MSG_ALL)
xprintf("PROBLEM HAS NO DUAL FEASIBLE SOLUTION\n");
}
else
xassert(ret != ret);
if (ret != 0) goto done;
/* build transformed LP */
lp = glp_create_prob();
npp_build_prob(npp, lp);
/* if the transformed LP is empty, it has empty solution, which
is optimal */
if (lp->m == 0 && lp->n == 0)
{ lp->pbs_stat = lp->dbs_stat = GLP_FEAS;
lp->obj_val = lp->c0;
if (parm->msg_lev >= GLP_MSG_ON && parm->out_dly == 0)
{ xprintf("~%6d: obj = %17.9e infeas = %10.3e\n", P->it_cnt,
lp->obj_val, 0.0);
}
if (parm->msg_lev >= GLP_MSG_ALL)
xprintf("OPTIMAL SOLUTION FOUND BY LP PREPROCESSOR\n");
goto post;
}
if (parm->msg_lev >= GLP_MSG_ALL)
{ xprintf("%d row%s, %d column%s, %d non-zero%s\n",
lp->m, lp->m == 1 ? "" : "s", lp->n, lp->n == 1 ? "" : "s",
lp->nnz, lp->nnz == 1 ? "" : "s");
}
/* inherit basis factorization control parameters */
glp_get_bfcp(P, &bfcp);
glp_set_bfcp(lp, &bfcp);
/* scale the transformed problem */
{ ENV *env = get_env_ptr();
int term_out = env->term_out;
if (!term_out || parm->msg_lev < GLP_MSG_ALL)
env->term_out = GLP_OFF;
else
env->term_out = GLP_ON;
glp_scale_prob(lp, GLP_SF_AUTO);
env->term_out = term_out;
}
/* build advanced initial basis */
{ ENV *env = get_env_ptr();
int term_out = env->term_out;
if (!term_out || parm->msg_lev < GLP_MSG_ALL)
env->term_out = GLP_OFF;
else
env->term_out = GLP_ON;
glp_adv_basis(lp, 0);
env->term_out = term_out;
}
/* solve the transformed LP */
lp->it_cnt = P->it_cnt;
ret = solve_lp(lp, parm);
P->it_cnt = lp->it_cnt;
/* only optimal solution can be postprocessed */
if (!(ret == 0 && lp->pbs_stat == GLP_FEAS && lp->dbs_stat ==
GLP_FEAS))
{ if (parm->msg_lev >= GLP_MSG_ERR)
xprintf("glp_simplex: unable to recover undefined or non-op"
"timal solution\n");
if (ret == 0)
{ if (lp->pbs_stat == GLP_NOFEAS)
ret = GLP_ENOPFS;
else if (lp->dbs_stat == GLP_NOFEAS)
ret = GLP_ENODFS;
else
xassert(lp != lp);
}
goto done;
}
post: /* postprocess solution from the transformed LP */
npp_postprocess(npp, lp);
/* the transformed LP is no longer needed */
glp_delete_prob(lp), lp = NULL;
/* store solution to the original problem */
npp_unload_sol(npp, P);
/* the original LP has been successfully solved */
ret = 0;
done: /* delete the transformed LP, if it exists */
if (lp != NULL) glp_delete_prob(lp);
/* delete preprocessor workspace */
npp_delete_wksp(npp);
return ret;
}
int glp_simplex(glp_prob *P, const glp_smcp *parm)
{ /* solve LP problem with the simplex method */
glp_smcp _parm;
int i, j, ret;
/* check problem object */
#if 0 /* 04/IV-2016 */
if (P == NULL || P->magic != GLP_PROB_MAGIC)
xerror("glp_simplex: P = %p; invalid problem object\n", P);
#endif
if (P->tree != NULL && P->tree->reason != 0)
xerror("glp_simplex: operation not allowed\n");
/* check control parameters */
if (parm == NULL)
parm = &_parm, glp_init_smcp((glp_smcp *)parm);
if (!(parm->msg_lev == GLP_MSG_OFF ||
parm->msg_lev == GLP_MSG_ERR ||
parm->msg_lev == GLP_MSG_ON ||
parm->msg_lev == GLP_MSG_ALL ||
parm->msg_lev == GLP_MSG_DBG))
xerror("glp_simplex: msg_lev = %d; invalid parameter\n",
parm->msg_lev);
if (!(parm->meth == GLP_PRIMAL ||
parm->meth == GLP_DUALP ||
parm->meth == GLP_DUAL))
xerror("glp_simplex: meth = %d; invalid parameter\n",
parm->meth);
if (!(parm->pricing == GLP_PT_STD ||
parm->pricing == GLP_PT_PSE))
xerror("glp_simplex: pricing = %d; invalid parameter\n",
parm->pricing);
if (!(parm->r_test == GLP_RT_STD ||
#if 1 /* 16/III-2016 */
parm->r_test == GLP_RT_FLIP ||
#endif
parm->r_test == GLP_RT_HAR))
xerror("glp_simplex: r_test = %d; invalid parameter\n",
parm->r_test);
if (!(0.0 < parm->tol_bnd && parm->tol_bnd < 1.0))
xerror("glp_simplex: tol_bnd = %g; invalid parameter\n",
parm->tol_bnd);
if (!(0.0 < parm->tol_dj && parm->tol_dj < 1.0))
xerror("glp_simplex: tol_dj = %g; invalid parameter\n",
parm->tol_dj);
if (!(0.0 < parm->tol_piv && parm->tol_piv < 1.0))
xerror("glp_simplex: tol_piv = %g; invalid parameter\n",
parm->tol_piv);
if (parm->it_lim < 0)
xerror("glp_simplex: it_lim = %d; invalid parameter\n",
parm->it_lim);
if (parm->tm_lim < 0)
xerror("glp_simplex: tm_lim = %d; invalid parameter\n",
parm->tm_lim);
#if 0 /* 15/VII-2017 */
if (parm->out_frq < 1)
#else
if (parm->out_frq < 0)
#endif
xerror("glp_simplex: out_frq = %d; invalid parameter\n",
parm->out_frq);
if (parm->out_dly < 0)
xerror("glp_simplex: out_dly = %d; invalid parameter\n",
parm->out_dly);
if (!(parm->presolve == GLP_ON || parm->presolve == GLP_OFF))
xerror("glp_simplex: presolve = %d; invalid parameter\n",
parm->presolve);
#if 1 /* 11/VII-2017 */
if (!(parm->excl == GLP_ON || parm->excl == GLP_OFF))
xerror("glp_simplex: excl = %d; invalid parameter\n",
parm->excl);
if (!(parm->shift == GLP_ON || parm->shift == GLP_OFF))
xerror("glp_simplex: shift = %d; invalid parameter\n",
parm->shift);
if (!(parm->aorn == GLP_USE_AT || parm->aorn == GLP_USE_NT))
xerror("glp_simplex: aorn = %d; invalid parameter\n",
parm->aorn);
#endif
/* basic solution is currently undefined */
P->pbs_stat = P->dbs_stat = GLP_UNDEF;
P->obj_val = 0.0;
P->some = 0;
/* check bounds of double-bounded variables */
for (i = 1; i <= P->m; i++)
{ GLPROW *row = P->row[i];
if (row->type == GLP_DB && row->lb >= row->ub)
{ if (parm->msg_lev >= GLP_MSG_ERR)
xprintf("glp_simplex: row %d: lb = %g, ub = %g; incorrec"
"t bounds\n", i, row->lb, row->ub);
ret = GLP_EBOUND;
goto done;
}
}
for (j = 1; j <= P->n; j++)
{ GLPCOL *col = P->col[j];
if (col->type == GLP_DB && col->lb >= col->ub)
{ if (parm->msg_lev >= GLP_MSG_ERR)
xprintf("glp_simplex: column %d: lb = %g, ub = %g; incor"
"rect bounds\n", j, col->lb, col->ub);
ret = GLP_EBOUND;
goto done;
}
}
/* solve LP problem */
if (parm->msg_lev >= GLP_MSG_ALL)
{ xprintf("GLPK Simplex Optimizer %s\n", glp_version());
xprintf("%d row%s, %d column%s, %d non-zero%s\n",
P->m, P->m == 1 ? "" : "s", P->n, P->n == 1 ? "" : "s",
P->nnz, P->nnz == 1 ? "" : "s");
}
if (P->nnz == 0)
trivial_lp(P, parm), ret = 0;
else if (!parm->presolve)
ret = solve_lp(P, parm);
else
ret = preprocess_and_solve_lp(P, parm);
done: /* return to the application program */
return ret;
}
/***********************************************************************
* NAME
*
* glp_init_smcp - initialize simplex method control parameters
*
* SYNOPSIS
*
* void glp_init_smcp(glp_smcp *parm);
*
* DESCRIPTION
*
* The routine glp_init_smcp initializes control parameters, which are
* used by the simplex solver, with default values.
*
* Default values of the control parameters are stored in a glp_smcp
* structure, which the parameter parm points to. */
void glp_init_smcp(glp_smcp *parm)
{ parm->msg_lev = GLP_MSG_ALL;
parm->meth = GLP_PRIMAL;
parm->pricing = GLP_PT_PSE;
parm->r_test = GLP_RT_HAR;
parm->tol_bnd = 1e-7;
parm->tol_dj = 1e-7;
#if 0 /* 07/XI-2015 */
parm->tol_piv = 1e-10;
#else
parm->tol_piv = 1e-9;
#endif
parm->obj_ll = -DBL_MAX;
parm->obj_ul = +DBL_MAX;
parm->it_lim = INT_MAX;
parm->tm_lim = INT_MAX;
#if 0 /* 15/VII-2017 */
parm->out_frq = 500;
#else
parm->out_frq = 5000; /* 5 seconds */
#endif
parm->out_dly = 0;
parm->presolve = GLP_OFF;
#if 1 /* 11/VII-2017 */
parm->excl = GLP_ON;
parm->shift = GLP_ON;
parm->aorn = GLP_USE_NT;
#endif
return;
}
/***********************************************************************
* NAME
*
* glp_get_status - retrieve generic status of basic solution
*
* SYNOPSIS
*
* int glp_get_status(glp_prob *lp);
*
* RETURNS
*
* The routine glp_get_status reports the generic status of the basic
* solution for the specified problem object as follows:
*
* GLP_OPT - solution is optimal;
* GLP_FEAS - solution is feasible;
* GLP_INFEAS - solution is infeasible;
* GLP_NOFEAS - problem has no feasible solution;
* GLP_UNBND - problem has unbounded solution;
* GLP_UNDEF - solution is undefined. */
int glp_get_status(glp_prob *lp)
{ int status;
status = glp_get_prim_stat(lp);
switch (status)
{ case GLP_FEAS:
switch (glp_get_dual_stat(lp))
{ case GLP_FEAS:
status = GLP_OPT;
break;
case GLP_NOFEAS:
status = GLP_UNBND;
break;
case GLP_UNDEF:
case GLP_INFEAS:
status = status;
break;
default:
xassert(lp != lp);
}
break;
case GLP_UNDEF:
case GLP_INFEAS:
case GLP_NOFEAS:
status = status;
break;
default:
xassert(lp != lp);
}
return status;
}
/***********************************************************************
* NAME
*
* glp_get_prim_stat - retrieve status of primal basic solution
*
* SYNOPSIS
*
* int glp_get_prim_stat(glp_prob *lp);
*
* RETURNS
*
* The routine glp_get_prim_stat reports the status of the primal basic
* solution for the specified problem object as follows:
*
* GLP_UNDEF - primal solution is undefined;
* GLP_FEAS - primal solution is feasible;
* GLP_INFEAS - primal solution is infeasible;
* GLP_NOFEAS - no primal feasible solution exists. */
int glp_get_prim_stat(glp_prob *lp)
{ int pbs_stat = lp->pbs_stat;
return pbs_stat;
}
/***********************************************************************
* NAME
*
* glp_get_dual_stat - retrieve status of dual basic solution
*
* SYNOPSIS
*
* int glp_get_dual_stat(glp_prob *lp);
*
* RETURNS
*
* The routine glp_get_dual_stat reports the status of the dual basic
* solution for the specified problem object as follows:
*
* GLP_UNDEF - dual solution is undefined;
* GLP_FEAS - dual solution is feasible;
* GLP_INFEAS - dual solution is infeasible;
* GLP_NOFEAS - no dual feasible solution exists. */
int glp_get_dual_stat(glp_prob *lp)
{ int dbs_stat = lp->dbs_stat;
return dbs_stat;
}
/***********************************************************************
* NAME
*
* glp_get_obj_val - retrieve objective value (basic solution)
*
* SYNOPSIS
*
* double glp_get_obj_val(glp_prob *lp);
*
* RETURNS
*
* The routine glp_get_obj_val returns value of the objective function
* for basic solution. */
double glp_get_obj_val(glp_prob *lp)
{ /*struct LPXCPS *cps = lp->cps;*/
double z;
z = lp->obj_val;
/*if (cps->round && fabs(z) < 1e-9) z = 0.0;*/
return z;
}
/***********************************************************************
* NAME
*
* glp_get_row_stat - retrieve row status
*
* SYNOPSIS
*
* int glp_get_row_stat(glp_prob *lp, int i);
*
* RETURNS
*
* The routine glp_get_row_stat returns current status assigned to the
* auxiliary variable associated with i-th row as follows:
*
* GLP_BS - basic variable;
* GLP_NL - non-basic variable on its lower bound;
* GLP_NU - non-basic variable on its upper bound;
* GLP_NF - non-basic free (unbounded) variable;
* GLP_NS - non-basic fixed variable. */
int glp_get_row_stat(glp_prob *lp, int i)
{ if (!(1 <= i && i <= lp->m))
xerror("glp_get_row_stat: i = %d; row number out of range\n",
i);
return lp->row[i]->stat;
}
/***********************************************************************
* NAME
*
* glp_get_row_prim - retrieve row primal value (basic solution)
*
* SYNOPSIS
*
* double glp_get_row_prim(glp_prob *lp, int i);
*
* RETURNS
*
* The routine glp_get_row_prim returns primal value of the auxiliary
* variable associated with i-th row. */
double glp_get_row_prim(glp_prob *lp, int i)
{ /*struct LPXCPS *cps = lp->cps;*/
double prim;
if (!(1 <= i && i <= lp->m))
xerror("glp_get_row_prim: i = %d; row number out of range\n",
i);
prim = lp->row[i]->prim;
/*if (cps->round && fabs(prim) < 1e-9) prim = 0.0;*/
return prim;
}
/***********************************************************************
* NAME
*
* glp_get_row_dual - retrieve row dual value (basic solution)
*
* SYNOPSIS
*
* double glp_get_row_dual(glp_prob *lp, int i);
*
* RETURNS
*
* The routine glp_get_row_dual returns dual value (i.e. reduced cost)
* of the auxiliary variable associated with i-th row. */
double glp_get_row_dual(glp_prob *lp, int i)
{ /*struct LPXCPS *cps = lp->cps;*/
double dual;
if (!(1 <= i && i <= lp->m))
xerror("glp_get_row_dual: i = %d; row number out of range\n",
i);
dual = lp->row[i]->dual;
/*if (cps->round && fabs(dual) < 1e-9) dual = 0.0;*/
return dual;
}
/***********************************************************************
* NAME
*
* glp_get_col_stat - retrieve column status
*
* SYNOPSIS
*
* int glp_get_col_stat(glp_prob *lp, int j);
*
* RETURNS
*
* The routine glp_get_col_stat returns current status assigned to the
* structural variable associated with j-th column as follows:
*
* GLP_BS - basic variable;
* GLP_NL - non-basic variable on its lower bound;
* GLP_NU - non-basic variable on its upper bound;
* GLP_NF - non-basic free (unbounded) variable;
* GLP_NS - non-basic fixed variable. */
int glp_get_col_stat(glp_prob *lp, int j)
{ if (!(1 <= j && j <= lp->n))
xerror("glp_get_col_stat: j = %d; column number out of range\n"
, j);
return lp->col[j]->stat;
}
/***********************************************************************
* NAME
*
* glp_get_col_prim - retrieve column primal value (basic solution)
*
* SYNOPSIS
*
* double glp_get_col_prim(glp_prob *lp, int j);
*
* RETURNS
*
* The routine glp_get_col_prim returns primal value of the structural
* variable associated with j-th column. */
double glp_get_col_prim(glp_prob *lp, int j)
{ /*struct LPXCPS *cps = lp->cps;*/
double prim;
if (!(1 <= j && j <= lp->n))
xerror("glp_get_col_prim: j = %d; column number out of range\n"
, j);
prim = lp->col[j]->prim;
/*if (cps->round && fabs(prim) < 1e-9) prim = 0.0;*/
return prim;
}
/***********************************************************************
* NAME
*
* glp_get_col_dual - retrieve column dual value (basic solution)
*
* SYNOPSIS
*
* double glp_get_col_dual(glp_prob *lp, int j);
*
* RETURNS
*
* The routine glp_get_col_dual returns dual value (i.e. reduced cost)
* of the structural variable associated with j-th column. */
double glp_get_col_dual(glp_prob *lp, int j)
{ /*struct LPXCPS *cps = lp->cps;*/
double dual;
if (!(1 <= j && j <= lp->n))
xerror("glp_get_col_dual: j = %d; column number out of range\n"
, j);
dual = lp->col[j]->dual;
/*if (cps->round && fabs(dual) < 1e-9) dual = 0.0;*/
return dual;
}
/***********************************************************************
* NAME
*
* glp_get_unbnd_ray - determine variable causing unboundedness
*
* SYNOPSIS
*
* int glp_get_unbnd_ray(glp_prob *lp);
*
* RETURNS
*
* The routine glp_get_unbnd_ray returns the number k of a variable,
* which causes primal or dual unboundedness. If 1 <= k <= m, it is
* k-th auxiliary variable, and if m+1 <= k <= m+n, it is (k-m)-th
* structural variable, where m is the number of rows, n is the number
* of columns in the problem object. If such variable is not defined,
* the routine returns 0.
*
* COMMENTS
*
* If it is not exactly known which version of the simplex solver
* detected unboundedness, i.e. whether the unboundedness is primal or
* dual, it is sufficient to check the status of the variable reported
* with the routine glp_get_row_stat or glp_get_col_stat. If the
* variable is non-basic, the unboundedness is primal, otherwise, if
* the variable is basic, the unboundedness is dual (the latter case
* means that the problem has no primal feasible dolution). */
int glp_get_unbnd_ray(glp_prob *lp)
{ int k;
k = lp->some;
xassert(k >= 0);
if (k > lp->m + lp->n) k = 0;
return k;
}
#if 1 /* 08/VIII-2013 */
int glp_get_it_cnt(glp_prob *P)
{ /* get simplex solver iteration count */
return P->it_cnt;
}
#endif
#if 1 /* 08/VIII-2013 */
void glp_set_it_cnt(glp_prob *P, int it_cnt)
{ /* set simplex solver iteration count */
P->it_cnt = it_cnt;
return;
}
#endif
/* eof */
| /* glpapi06.c (simplex method routines) */
|
ocollection.mli | (*s: ocollection.mli *)
type ('a, 'b) view = Empty | Cons of 'a * 'b
class virtual ['a] ocollection :
object ('o)
inherit Objet.objet
method virtual empty : 'o
method virtual add : 'a -> 'o
method virtual iter : ('a -> unit) -> unit
method virtual view : ('a, 'o) view
(* no need virtual, but better to force redefine for efficiency *)
method virtual del : 'a -> 'o
method virtual mem : 'a -> bool
method virtual null : bool
(* effect version *)
method add2 : 'a -> unit
method del2 : 'a -> unit
method clear : unit
method fold : ('c -> 'a -> 'c) -> 'c -> 'c
method fromlist : 'a list -> 'o
method tolist : 'a list
method exists : ('a -> bool) -> bool
method filter : ('a -> bool) -> 'o
method length : int
method getone : 'a
method others : 'o
end
(*e: ocollection.mli *)
| (*s: ocollection.mli *)
type ('a, 'b) view = Empty | Cons of 'a * 'b |
nonce_hash.ml | (* 32 *)
let nonce_hash = "\069\220\169" (* nce(53) *)
module H =
Blake2B.Make
(Base58)
(struct
let name = "cycle_nonce"
let title = "A nonce hash"
let b58check_prefix = nonce_hash
let size = None
end)
include H
include Path_encoding.Make_hex (H)
let () = Base58.check_encoded_prefix b58check_encoding "nce" 53
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
owl_opencl_base.mli |
open Owl_opencl_generated
(** {5 Platform module} *)
module Platform : sig
type info =
{ profile : string
; version : string
; name : string
; vendor : string
; extensions : string
}
(** ``info`` type contains the basic information of the object. *)
val get_info : cl_platform_id -> info
(** Get the information of a given object. *)
val to_string : cl_platform_id -> string
(** Get the string representation of a given object, often contains the object's basic information. *)
val get_platforms : unit -> cl_platform_id array
(** Get an array of all the available platforms. *)
end
(** {5 Device module} *)
module Device : sig
type info =
{ name : string
; profile : string
; vendor : string
; version : string
; driver_version : string
; opencl_c_version : string
; build_in_kernels : string
; typ : int
; address_bits : int
; available : bool
; compiler_available : bool
; linker_available : bool
; global_mem_cache_size : int
; global_mem_size : int
; max_clock_frequency : int
; max_compute_units : int
; max_work_group_size : int
; max_parameter_size : int
; max_samplers : int
; reference_count : int
; double_fp_config : int
; extensions : string
; parent_device : cl_device_id
; platform : cl_platform_id
}
(** ``info`` type contains the basic information of the object. *)
val get_info : cl_device_id -> info
(** Get the information of a given object. *)
val to_string : cl_device_id -> string
(** Get the string representation of a given object, often contains the object's basic information. *)
val get_devices : cl_platform_id -> cl_device_id array
(** Get an array of all the available devices on a given platform. *)
end
(** {5 Context module} *)
module Context : sig
type info =
{ reference_count : int
; num_devices : int
; devices : cl_device_id array
}
(** ``info`` type contains the basic information of the object. *)
val get_info : cl_context -> info
(** Get the information of a given object. *)
val to_string : cl_context -> string
(** Get the string representation of a given object, often contains the object's basic information. *)
val create : ?properties:(int * int) list -> cl_device_id array -> cl_context
(** Create an object with the passed in parameters. *)
val create_from_type : ?properties:(int * int) list -> int -> cl_context
(** Create a context from a given type. *)
val retain : cl_context -> unit
(** Retain a resource by increasing its reference number by 1. *)
val release : cl_context -> unit
(** Release a resource by decreasing its reference number by 1. *)
end
(** {5 Program module} *)
module Program : sig
type info =
{ reference_count : int
; context : cl_context
; num_devices : int
; devices : cl_device_id array
; source : string
; binary_sizes : int array
; binaries : Cstubs_internals.voidp array
; num_kernels : int
; kernel_names : string array
}
(** ``info`` type contains the basic information of the object. *)
val get_info : cl_program -> info
(** Get the information of a given object. *)
val to_string : cl_program -> string
(** Get the string representation of a given object, often contains the object's basic information. *)
val create_with_source : cl_context -> string array -> cl_program
(** Create a program from its source string. *)
val build : ?options:string -> cl_program -> cl_device_id array -> unit
(** Build a program for the passed-in devices with the given parameters. *)
val retain : cl_program -> unit
(** Retain a resource by increasing its reference number by 1. *)
val release : cl_program -> unit
(** Release a resource by decreasing its reference number by 1. *)
end
(** {5 Kernel module} *)
module Kernel : sig
type info =
{ function_name : string
; num_args : int
; attributes : int
; reference_count : int
; context : cl_context
; program : cl_program
; work_group_size : (cl_device_id * int) array
}
(** ``info`` type contains the basic information of the object. *)
val get_info : cl_kernel -> info
(** Get the information of a given object. *)
val to_string : cl_kernel -> string
(** Get the string representation of a given object, often contains the object's basic information. *)
val create : cl_program -> string -> cl_kernel
(** Create an object with the passed in parameters. *)
val set_arg : cl_kernel -> int -> int -> 'a Ctypes.ptr -> unit
(** Set the arguments of a given kernel. *)
val enqueue_task : ?wait_for:cl_event list -> cl_command_queue -> cl_kernel -> cl_event
(** Enqueue a task into the associate command queue of a given kernel. *)
val enqueue_ndrange
: ?wait_for:cl_event list
-> ?global_work_ofs:int list
-> ?local_work_size:int list
-> cl_command_queue
-> cl_kernel
-> int
-> int list
-> cl_event
(** Enqueue a ndrange task into the associate command queue of a given kernel. *)
val retain : cl_kernel -> unit
(** Retain a resource by increasing its reference number by 1. *)
val release : cl_kernel -> unit
(** Release a resource by decreasing its reference number by 1. *)
end
(** {5 CommandQueue module} *)
module CommandQueue : sig
type info =
{ context : cl_context
; device : cl_device_id
; reference_count : int
; queue_properties : Unsigned.ULong.t
}
(** ``info`` type contains the basic information of the object. *)
val get_info : cl_command_queue -> info
(** Get the information of a given object. *)
val to_string : cl_command_queue -> string
(** Get the string representation of a given object, often contains the object's basic information. *)
val create : ?properties:int list -> cl_context -> cl_device_id -> cl_command_queue
(** Create an object with the passed in parameters. *)
val barrier : ?wait_for:cl_event list -> cl_command_queue -> cl_event
(** Barrier function of the given command queue. *)
val marker : ?wait_for:cl_event list -> cl_command_queue -> cl_event
(** Marker function of the given command queue. *)
val flush : cl_command_queue -> unit
(** Flush the given command queue. *)
val finish : cl_command_queue -> unit
(** Finish the given command queue. *)
val retain : cl_command_queue -> unit
(** Retain a resource by increasing its reference number by 1. *)
val release : cl_command_queue -> unit
(** Release a resource by decreasing its reference number by 1. *)
end
(** {5 Event module} *)
module Event : sig
type info =
{ command_type : int
; reference_count : int
; command_execution_status : int
; command_queue : cl_command_queue
; context : cl_context
}
(** ``info`` type contains the basic information of the object. *)
val get_info : cl_event -> info
(** Get the information of a given object. *)
val to_string : cl_event -> string
(** Get the string representation of a given object, often contains the object's basic information. *)
val create : cl_context -> cl_event
(** Create an object with the passed in parameters. *)
val set_status : cl_event -> int -> unit
(** Set the status of a given event. *)
val wait_for : cl_event list -> int32
(** Wait for a list of events to finish. *)
val retain : cl_event -> unit
(** Retain a resource by increasing its reference number by 1. *)
val release : cl_event -> unit
(** Release a resource by decreasing its reference number by 1. *)
end
(** {5 Buffer module} *)
module Buffer : sig
type info =
{ typ : int
; size : int
; reference_count : int
}
(** ``info`` type contains the basic information of the object. *)
val get_info : cl_mem -> info
(** Get the information of a given object. *)
val to_string : cl_mem -> string
(** Get the string representation of a given object, often contains the object's basic information. *)
val create : ?flags:int list -> cl_context -> int -> unit Ctypes.ptr -> cl_mem
(** Create an object with the passed in void pointer. *)
val create_bigarray
: ?flags:int list
-> cl_context
-> ('a, 'b) Owl_dense_ndarray_generic.t
-> cl_mem
(** Create an object with the passed in bigarray. Refer to ``create`` for a more general function. *)
val enqueue_read
: ?blocking:bool
-> ?wait_for:cl_event list
-> cl_command_queue
-> cl_mem
-> int
-> int
-> unit Ctypes.ptr
-> cl_event
(** Enqueue a read operation on the given memory object to a command queue. *)
val enqueue_write
: ?blocking:bool
-> ?wait_for:cl_event list
-> cl_command_queue
-> cl_mem
-> int
-> int
-> unit Ctypes.ptr
-> cl_event
(** Enqueue a write operation on the given memory object to a command queue. *)
val enqueue_map
: ?blocking:bool
-> ?wait_for:Owl_opencl_generated.cl_event list
-> ?flags:int list
-> cl_command_queue
-> cl_mem
-> int
-> int
-> cl_event * unit Ctypes.ptr
(** Enqueue a map operation on the given memory object to a command queue. *)
val enqueue_unmap
: ?wait_for:cl_event list
-> cl_command_queue
-> cl_mem
-> unit Ctypes.ptr
-> cl_event
(** Enqueue a unmap operation on the given memory object to a command queue. *)
val retain : cl_mem -> unit
(** Retain a resource by increasing its reference number by 1. *)
val release : cl_mem -> unit
(** Release a resource by decreasing its reference number by 1. *)
end
| (*
* OWL - OCaml Scientific and Engineering Computing
* Copyright (c) 2016-2020 Liang Wang <liang.wang@cl.cam.ac.uk>
*) |
test_int_conversions.ml |
open! Import
open! Int_conversions
let%test_module "pretty" =
(module struct
let check input output =
List.for_all [ ""; "+"; "-" ] ~f:(fun prefix ->
let input = prefix ^ input in
let output = prefix ^ output in
[%compare.equal: string] output (insert_underscores input))
;;
let%test _ = check "1" "1"
let%test _ = check "12" "12"
let%test _ = check "123" "123"
let%test _ = check "1234" "1_234"
let%test _ = check "12345" "12_345"
let%test _ = check "123456" "123_456"
let%test _ = check "1234567" "1_234_567"
let%test _ = check "12345678" "12_345_678"
let%test _ = check "123456789" "123_456_789"
let%test _ = check "1234567890" "1_234_567_890"
end)
;;
let%test_module "conversions" =
(module struct
module type S = sig
include Int.S
val module_name : string
end
let test_conversion (type a b) loc ma mb a_to_b_or_error a_to_b_trunc b_to_a_trunc =
let (module A : S with type t = a) = ma in
let (module B : S with type t = b) = mb in
let examples =
[ A.min_value
; A.minus_one
; A.zero
; A.one
; A.max_value
; B.min_value |> b_to_a_trunc
; B.max_value |> b_to_a_trunc
]
|> List.concat_map ~f:(fun a -> [ A.pred a; a; A.succ a ])
|> List.dedup_and_sort ~compare:A.compare
|> List.sort ~compare:A.compare
in
List.iter examples ~f:(fun a ->
let b' = a_to_b_trunc a in
let a' = b_to_a_trunc b' in
match a_to_b_or_error a with
| Ok b ->
require
loc
(B.equal b b')
~if_false_then_print_s:
(lazy
[%message
"conversion produced wrong value"
~from:(A.module_name : string)
~to_:(B.module_name : string)
~input:(a : A.t)
~output:(b : B.t)
~expected:(b' : B.t)]);
require
loc
(A.equal a a')
~if_false_then_print_s:
(lazy
[%message
"conversion does not round-trip"
~from:(A.module_name : string)
~to_:(B.module_name : string)
~input:(a : A.t)
~output:(b : B.t)
~round_trip:(a' : A.t)])
| Error error ->
require
loc
(not (A.equal a a'))
~if_false_then_print_s:
(lazy
[%message
"conversion failed"
~from:(A.module_name : string)
~to_:(B.module_name : string)
~input:(a : A.t)
~expected_output:(b' : B.t)
~error:(error : Error.t)]))
;;
let test loc ma mb (a_to_b_trunc, a_to_b_or_error) (b_to_a_trunc, b_to_a_or_error) =
test_conversion loc ma mb a_to_b_or_error a_to_b_trunc b_to_a_trunc;
test_conversion loc mb ma b_to_a_or_error b_to_a_trunc a_to_b_trunc
;;
module Int = struct
include Int
let module_name = "Int"
end
module Int32 = struct
include Int32
let module_name = "Int32"
end
module Int64 = struct
include Int64
let module_name = "Int64"
end
module Nativeint = struct
include Nativeint
let module_name = "Nativeint"
end
let with_exn f x = Or_error.try_with (fun () -> f x)
let optional f x = Or_error.try_with (fun () -> Option.value_exn (f x))
let alwaysok f x = Ok (f x)
let%expect_test "int <-> int32" =
test
[%here]
(module Int)
(module Int32)
(Caml.Int32.of_int, with_exn int_to_int32_exn)
(Caml.Int32.to_int, with_exn int32_to_int_exn);
[%expect {| |}];
test
[%here]
(module Int)
(module Int32)
(Caml.Int32.of_int, optional int_to_int32)
(Caml.Int32.to_int, optional int32_to_int);
[%expect {| |}]
;;
let%expect_test "int <-> int64" =
test
[%here]
(module Int)
(module Int64)
(Caml.Int64.of_int, alwaysok int_to_int64)
(Caml.Int64.to_int, with_exn int64_to_int_exn);
[%expect {| |}];
test
[%here]
(module Int)
(module Int64)
(Caml.Int64.of_int, alwaysok int_to_int64)
(Caml.Int64.to_int, optional int64_to_int);
[%expect {| |}]
;;
let%expect_test "int <-> nativeint" =
test
[%here]
(module Int)
(module Nativeint)
(Caml.Nativeint.of_int, alwaysok int_to_nativeint)
(Caml.Nativeint.to_int, with_exn nativeint_to_int_exn);
[%expect {| |}];
test
[%here]
(module Int)
(module Nativeint)
(Caml.Nativeint.of_int, alwaysok int_to_nativeint)
(Caml.Nativeint.to_int, optional nativeint_to_int);
[%expect {| |}]
;;
let%expect_test "int32 <-> int64" =
test
[%here]
(module Int32)
(module Int64)
(Caml.Int64.of_int32, alwaysok int32_to_int64)
(Caml.Int64.to_int32, with_exn int64_to_int32_exn);
[%expect {| |}];
test
[%here]
(module Int32)
(module Int64)
(Caml.Int64.of_int32, alwaysok int32_to_int64)
(Caml.Int64.to_int32, optional int64_to_int32);
[%expect {| |}]
;;
let%expect_test "int32 <-> nativeint" =
test
[%here]
(module Int32)
(module Nativeint)
(Caml.Nativeint.of_int32, alwaysok int32_to_nativeint)
(Caml.Nativeint.to_int32, with_exn nativeint_to_int32_exn);
[%expect {| |}];
test
[%here]
(module Int32)
(module Nativeint)
(Caml.Nativeint.of_int32, alwaysok int32_to_nativeint)
(Caml.Nativeint.to_int32, optional nativeint_to_int32);
[%expect {| |}]
;;
let%expect_test "int64 <-> nativeint" =
test
[%here]
(module Int64)
(module Nativeint)
(Caml.Int64.to_nativeint, with_exn int64_to_nativeint_exn)
(Caml.Int64.of_nativeint, alwaysok nativeint_to_int64);
[%expect {| |}];
test
[%here]
(module Int64)
(module Nativeint)
(Caml.Int64.to_nativeint, optional int64_to_nativeint)
(Caml.Int64.of_nativeint, alwaysok nativeint_to_int64);
[%expect {| |}]
;;
end)
;;
| |
dune_init.mli | (** Initialize dune components *)
open! Stdune
(** The context in which the initialization is executed *)
module Init_context : sig
type t =
{ dir : Path.t
; project : Dune_engine.Dune_project.t
}
val make : string option -> t Memo.t
end
(** A [Component.t] is a set of files that can be built or included as part of a
build. *)
module Component : sig
(** Options determining the details of a generated component *)
module Options : sig
(** The common options shared by all components *)
module Common : sig
type t =
{ name : Dune_lang.Atom.t
; libraries : Dune_lang.Atom.t list
; pps : Dune_lang.Atom.t list
}
end
type public_name =
| Use_name
| Public_name of Dune_lang.Atom.t
val public_name_to_string : public_name -> string
(** Options for executable components *)
module Executable : sig
type t = { public : public_name option }
end
(** Options for library components *)
module Library : sig
type t =
{ public : public_name option
; inline_tests : bool
}
end
(** Options for test components *)
module Test : sig
(** NOTE: no options supported yet *)
type t = unit
end
(** Options for project components (which consist of several sub-components) *)
module Project : sig
(** Determines whether this is a library project or an executable project *)
module Template : sig
type t =
| Exec
| Lib
val of_string : string -> t option
val commands : (string * t) list
end
(** The package manager used for a project *)
module Pkg : sig
type t =
| Opam
| Esy
val commands : (string * t) list
end
type t =
{ template : Template.t
; inline_tests : bool
; pkg : Pkg.t
}
end
type 'a t =
{ context : Init_context.t
; common : Common.t
; options : 'a
}
end
(** All the the supported types of components *)
type 'options t =
| Executable : Options.Executable.t Options.t -> Options.Executable.t t
| Library : Options.Library.t Options.t -> Options.Library.t t
| Project : Options.Project.t Options.t -> Options.Project.t t
| Test : Options.Test.t Options.t -> Options.Test.t t
(** Create or update the component specified by the ['options t], where
['options] is *)
val init : 'options t -> unit
end
| (** Initialize dune components *)
|
gc.mli |
type stat =
{
minor_words: float ;
promoted_words: float ;
major_words: float ;
minor_collections: int ;
major_collections: int ;
heap_words: int ;
heap_chunks: int ;
live_words: int ;
live_blocks: int ;
free_words: int ;
free_blocks: int ;
largest_free: int ;
fragments: int ;
compactions: int ;
top_heap_words: int ;
stack_size: int }
type control =
{
mutable minor_heap_size: int ;
mutable major_heap_increment: int ;
mutable space_overhead: int ;
mutable verbose: int ;
mutable max_overhead: int ;
mutable stack_limit: int ;
mutable allocation_policy: int ;
window_size: int }
external stat : unit -> stat = "caml_gc_stat"
external quick_stat : unit -> stat = "caml_gc_quick_stat"
external counters : unit -> (float * float * float) = "caml_gc_counters"
external minor_words :
unit -> ((float)[@unboxed ]) = "caml_gc_minor_words"
"caml_gc_minor_words_unboxed"[@@noalloc ]
external get : unit -> control = "caml_gc_get"
external set : control -> unit = "caml_gc_set"
external minor : unit -> unit = "caml_gc_minor"
external major_slice : int -> int = "caml_gc_major_slice"
external major : unit -> unit = "caml_gc_major"
external full_major : unit -> unit = "caml_gc_full_major"
external compact : unit -> unit = "caml_gc_compaction"
val print_stat : out_channel -> unit
val allocated_bytes : unit -> float
external get_minor_free : unit -> int = "caml_get_minor_free"[@@noalloc ]
external get_bucket : int -> int = "caml_get_major_bucket"[@@noalloc ]
external get_credit : unit -> int = "caml_get_major_credit"[@@noalloc ]
external huge_fallback_count : unit -> int = "caml_gc_huge_fallback_count"
val finalise : ('a -> unit) -> 'a -> unit
val finalise_last : (unit -> unit) -> 'a -> unit
val finalise_release : unit -> unit
type alarm
val create_alarm : (unit -> unit) -> alarm
val delete_alarm : alarm -> unit
| |
dune |
(executable (name step_by_step) (modules Step_by_step)
(libraries bundled)
)
(executable
(name run) (modules Run)
(libraries unix codept_lib bundled)
)
(executable
(name serialization) (modules Serialization)
(libraries unix codept_lib)
)
(executable
(name integrated) (modules Integrated)
(libraries unix codept_lib)
)
(test (name bundle_sync) (modules Bundle_sync) (libraries bundled bundle_refs codept_lib))
(rule
(alias runtest)
(deps run.exe)
(action (run %{exe:run.exe} ../../.. ))
)
(rule
(alias runtest)
(deps run.exe)
(action (run %{exe:serialization.exe}))
)
(rule
(alias runtest)
(deps ../full/codept.exe step_by_step.exe)
(action (run %{exe:integrated.exe}))
)
| |
owl_aeos_tuners.ml |
open Owl_aeos_tuner_map
open Owl_aeos_tuner_fold
type tuner =
| Reci of Reci.t
| Abs of Abs.t
| Abs2 of Abs2.t
| Signum of Signum.t
| Sqr of Sqr.t
| Sqrt of Sqrt.t
| Cbrt of Cbrt.t
| Exp of Exp.t
| Expm1 of Expm1.t
| Log of Log.t
| Log1p of Log1p.t
| Sin of Sin.t
| Cos of Cos.t
| Tan of Tan.t
| Asin of Asin.t
| Acos of Acos.t
| Atan of Atan.t
| Sinh of Sinh.t
| Cosh of Cosh.t
| Tanh of Tanh.t
| Asinh of Asinh.t
| Acosh of Acosh.t
| Atanh of Atanh.t
| Erf of Erf.t
| Erfc of Erfc.t
| Logistic of Logistic.t
| Relu of Relu.t
| Softplus of Softplus.t
| Softsign of Softsign.t
| Sigmoid of Sigmoid.t
| Elt_equal of Elt_equal.t
| Add of Add.t
| Mul of Mul.t
| Div of Div.t
| Pow of Pow.t
| Hypot of Hypot.t
| Atan2 of Atan2.t
| Max2 of Max2.t
| Fmod of Fmod.t
| Cumsum of Cumsum.t
| Cumprod of Cumprod.t
| Cummax of Cummax.t
| Diff of Diff.t
| Repeat of Repeat.t
let tuning = function
| Reci x -> Reci.tune x
| Abs x -> Abs.tune x
| Abs2 x -> Abs2.tune x
| Signum x -> Signum.tune x
| Sqr x -> Sqr.tune x
| Sqrt x -> Sqrt.tune x
| Cbrt x -> Cbrt.tune x
| Exp x -> Exp.tune x
| Expm1 x -> Expm1.tune x
| Log x -> Log.tune x
| Log1p x -> Log1p.tune x
| Sin x -> Sin.tune x
| Cos x -> Cos.tune x
| Tan x -> Tan.tune x
| Asin x -> Asin.tune x
| Acos x -> Acos.tune x
| Atan x -> Atan.tune x
| Sinh x -> Sinh.tune x
| Cosh x -> Cosh.tune x
| Tanh x -> Tanh.tune x
| Asinh x -> Asinh.tune x
| Acosh x -> Acosh.tune x
| Atanh x -> Atanh.tune x
| Erf x -> Erf.tune x
| Erfc x -> Erfc.tune x
| Logistic x -> Logistic.tune x
| Relu x -> Relu.tune x
| Softplus x -> Softplus.tune x
| Softsign x -> Softsign.tune x
| Sigmoid x -> Sigmoid.tune x
| Elt_equal x -> Elt_equal.tune x
| Add x -> Add.tune x
| Mul x -> Mul.tune x
| Div x -> Div.tune x
| Pow x -> Pow.tune x
| Hypot x -> Hypot.tune x
| Atan2 x -> Atan2.tune x
| Max2 x -> Max2.tune x
| Fmod x -> Fmod.tune x
| Cumsum x -> Cumsum.tune x
| Cumprod x -> Cumprod.tune x
| Cummax x -> Cummax.tune x
| Diff x -> Diff.tune x
| Repeat x -> Repeat.tune x
let to_string_array = function
| Reci x -> [| Reci.to_string x |]
| Abs x -> [| Abs.to_string x |]
| Abs2 x -> [| Abs2.to_string x |]
| Signum x -> [| Signum.to_string x |]
| Sqr x -> [| Sqr.to_string x |]
| Sqrt x -> [| Sqrt.to_string x |]
| Cbrt x -> [| Cbrt.to_string x |]
| Exp x -> [| Exp.to_string x |]
| Expm1 x -> [| Expm1.to_string x |]
| Log x -> [| Log.to_string x |]
| Log1p x -> [| Log1p.to_string x |]
| Sin x -> [| Sin.to_string x |]
| Cos x -> [| Cos.to_string x |]
| Tan x -> [| Tan.to_string x |]
| Asin x -> [| Asin.to_string x |]
| Acos x -> [| Acos.to_string x |]
| Atan x -> [| Atan.to_string x |]
| Sinh x -> [| Sinh.to_string x |]
| Cosh x -> [| Cosh.to_string x |]
| Tanh x -> [| Tanh.to_string x |]
| Asinh x -> [| Asinh.to_string x |]
| Acosh x -> [| Acosh.to_string x |]
| Atanh x -> [| Atanh.to_string x |]
| Erf x -> [| Erf.to_string x |]
| Erfc x -> [| Erfc.to_string x |]
| Logistic x -> [| Logistic.to_string x |]
| Relu x -> [| Relu.to_string x |]
| Softplus x -> [| Softplus.to_string x |]
| Softsign x -> [| Softsign.to_string x |]
| Sigmoid x -> [| Sigmoid.to_string x |]
| Elt_equal x -> [| Elt_equal.to_string x |]
| Add x -> [| Add.to_string x |]
| Mul x -> [| Mul.to_string x |]
| Div x -> [| Div.to_string x |]
| Pow x -> [| Pow.to_string x |]
| Hypot x -> [| Hypot.to_string x |]
| Atan2 x -> [| Atan2.to_string x |]
| Max2 x -> [| Max2.to_string x |]
| Fmod x -> [| Fmod.to_string x |]
| Cumsum x -> [| Cumsum.to_string x |]
| Cumprod x -> [| Cumprod.to_string x |]
| Cummax x -> [| Cummax.to_string x |]
| Diff x -> [| Diff.to_string x |]
| Repeat x -> [| Repeat.to_string x |]
let save_data = function
| Reci x -> Reci.save_data x
| Abs x -> Abs.save_data x
| Abs2 x -> Abs2.save_data x
| Signum x -> Signum.save_data x
| Sqr x -> Sqr.save_data x
| Sqrt x -> Sqrt.save_data x
| Cbrt x -> Cbrt.save_data x
| Exp x -> Exp.save_data x
| Expm1 x -> Expm1.save_data x
| Log x -> Log.save_data x
| Log1p x -> Log1p.save_data x
| Sin x -> Sin.save_data x
| Cos x -> Cos.save_data x
| Tan x -> Tan.save_data x
| Asin x -> Asin.save_data x
| Acos x -> Acos.save_data x
| Atan x -> Atan.save_data x
| Sinh x -> Sinh.save_data x
| Cosh x -> Cosh.save_data x
| Tanh x -> Tanh.save_data x
| Asinh x -> Asinh.save_data x
| Acosh x -> Acosh.save_data x
| Atanh x -> Atanh.save_data x
| Erf x -> Erf.save_data x
| Erfc x -> Erfc.save_data x
| Logistic x -> Logistic.save_data x
| Relu x -> Relu.save_data x
| Softplus x -> Softplus.save_data x
| Softsign x -> Softsign.save_data x
| Sigmoid x -> Sigmoid.save_data x
| Elt_equal x -> Elt_equal.save_data x
| Add x -> Add.save_data x
| Mul x -> Mul.save_data x
| Div x -> Div.save_data x
| Pow x -> Pow.save_data x
| Hypot x -> Hypot.save_data x
| Atan2 x -> Atan2.save_data x
| Max2 x -> Max2.save_data x
| Fmod x -> Fmod.save_data x
| Cumsum x -> Cumsum.save_data x
| Cumprod x -> Cumprod.save_data x
| Cummax x -> Cummax.save_data x
| Diff x -> Diff.save_data x
| Repeat x -> Repeat.save_data x
let get_params = function
| Reci x -> [| x.param |]
| Abs x -> [| x.param |]
| Abs2 x -> [| x.param |]
| Signum x -> [| x.param |]
| Sqr x -> [| x.param |]
| Sqrt x -> [| x.param |]
| Cbrt x -> [| x.param |]
| Exp x -> [| x.param |]
| Expm1 x -> [| x.param |]
| Log x -> [| x.param |]
| Log1p x -> [| x.param |]
| Sin x -> [| x.param |]
| Cos x -> [| x.param |]
| Tan x -> [| x.param |]
| Asin x -> [| x.param |]
| Acos x -> [| x.param |]
| Atan x -> [| x.param |]
| Sinh x -> [| x.param |]
| Cosh x -> [| x.param |]
| Tanh x -> [| x.param |]
| Asinh x -> [| x.param |]
| Acosh x -> [| x.param |]
| Atanh x -> [| x.param |]
| Erf x -> [| x.param |]
| Erfc x -> [| x.param |]
| Logistic x -> [| x.param |]
| Relu x -> [| x.param |]
| Softplus x -> [| x.param |]
| Softsign x -> [| x.param |]
| Sigmoid x -> [| x.param |]
| Elt_equal x -> [| x.param |]
| Add x -> [| x.param |]
| Mul x -> [| x.param |]
| Div x -> [| x.param |]
| Pow x -> [| x.param |]
| Hypot x -> [| x.param |]
| Atan2 x -> [| x.param |]
| Max2 x -> [| x.param |]
| Fmod x -> [| x.param |]
| Cumsum x -> [| x.param |]
| Cumprod x -> [| x.param |]
| Cummax x -> [| x.param |]
| Diff x -> [| x.param |]
| Repeat x -> [| x.param |]
let all =
[| Reci (Reci.make ())
; Abs (Abs.make ())
; Abs2 (Abs2.make ())
; Signum (Signum.make ())
; Sqr (Sqr.make ())
; Sqrt (Sqrt.make ())
; Cbrt (Cbrt.make ())
; Exp (Exp.make ())
; Expm1 (Expm1.make ())
; Log (Log.make ())
; Log1p (Log1p.make ())
; Sin (Sin.make ())
; Cos (Cos.make ())
; Tan (Tan.make ())
; Asin (Asin.make ())
; Acos (Acos.make ())
; Atan (Atan.make ())
; Sinh (Sinh.make ())
; Cosh (Cosh.make ())
; Tanh (Tanh.make ())
; Asinh (Asinh.make ())
; Acosh (Acosh.make ())
; Atanh (Atanh.make ())
; Erf (Erf.make ())
; Erfc (Erfc.make ())
; Logistic (Logistic.make ())
; Relu (Relu.make ())
; Softplus (Softplus.make ())
; Softsign (Softsign.make ())
; Sigmoid (Sigmoid.make ())
; Add (Add.make ())
; Div (Div.make ())
; Atan2 (Atan2.make ())
; Fmod (Fmod.make ())
|]
| (*
* OWL - OCaml Scientific and Engineering Computing
* Copyright (c) 2016-2020 Liang Wang <liang.wang@cl.cam.ac.uk>
*) |
arrow_apply.mli |
open Aliases
module type LAWS = sig
include Arrow.LAWS
val law8 : string * (unit -> ('a * 'b, 'a * 'b) t pair)
val law9 : string * (('a, 'b) t -> (('b, 'c) t * 'a, 'c) t pair)
val law10 : string * (('a, 'b) t -> (('c, 'a) t * 'c, 'b) t pair)
end
module Laws (A : Preface_specs.ARROW_APPLY) :
LAWS with type ('a, 'b) t := ('a, 'b) A.t
| |
lwt_process_stubs.c | /* This file is part of Lwt, released under the MIT license. See LICENSE.md for
details, or visit https://github.com/ocsigen/lwt/blob/master/LICENSE.md. */
#include "lwt_config.h"
#if defined(LWT_ON_WINDOWS)
#include <lwt_unix.h>
#if OCAML_VERSION < 41300
#define CAML_INTERNALS
#endif
#include <caml/alloc.h>
#include <caml/fail.h>
#include <caml/memory.h>
#include <caml/osdeps.h>
static HANDLE get_handle(value opt) {
value fd;
if (Is_some(opt)) {
fd = Some_val(opt);
if (Descr_kind_val(fd) == KIND_SOCKET) {
win32_maperr(ERROR_INVALID_HANDLE);
uerror("CreateProcess", Nothing);
return NULL;
} else
return Handle_val(fd);
} else
return INVALID_HANDLE_VALUE;
}
/* Ensures the handle [h] is inheritable. Returns the handle for the
child process in [hStd] and in [to_close] if it needs to be closed
after CreateProcess. */
static int ensure_inheritable(HANDLE h /* in */,
HANDLE * hStd /* out */,
HANDLE * to_close /* out */)
{
DWORD flags;
HANDLE hp;
if (h == INVALID_HANDLE_VALUE || h == NULL)
return 1;
if (! GetHandleInformation(h, &flags))
return 0;
hp = GetCurrentProcess();
if (! (flags & HANDLE_FLAG_INHERIT)) {
if (! DuplicateHandle(hp, h, hp, hStd, 0, TRUE, DUPLICATE_SAME_ACCESS))
return 0;
*to_close = *hStd;
} else {
*hStd = h;
}
return 1;
}
CAMLprim value lwt_process_create_process(value prog, value cmdline, value env,
value cwd, value fds) {
CAMLparam5(prog, cmdline, env, cwd, fds);
CAMLlocal1(result);
STARTUPINFO si;
PROCESS_INFORMATION pi;
DWORD flags = 0, err;
HANDLE hp, fd0, fd1, fd2;
HANDLE to_close0 = INVALID_HANDLE_VALUE, to_close1 = INVALID_HANDLE_VALUE,
to_close2 = INVALID_HANDLE_VALUE;
fd0 = get_handle(Field(fds, 0));
fd1 = get_handle(Field(fds, 1));
fd2 = get_handle(Field(fds, 2));
err = ERROR_SUCCESS;
ZeroMemory(&si, sizeof(si));
ZeroMemory(&pi, sizeof(pi));
si.cb = sizeof(si);
si.dwFlags = STARTF_USESTDHANDLES;
/* If needed, duplicate the handles fd1, fd2, fd3 to make sure they
are inheritable. */
if (! ensure_inheritable(fd0, &si.hStdInput, &to_close0) ||
! ensure_inheritable(fd1, &si.hStdOutput, &to_close1) ||
! ensure_inheritable(fd2, &si.hStdError, &to_close2)) {
err = GetLastError(); goto ret;
}
#define string_option(opt) \
(Is_block(opt) ? caml_stat_strdup_to_os(String_val(Field(opt, 0))) : NULL)
char_os
*progs = string_option(prog),
*cmdlines = caml_stat_strdup_to_os(String_val(cmdline)),
*envs = string_option(env),
*cwds = string_option(cwd);
#undef string_option
flags |= CREATE_UNICODE_ENVIRONMENT;
if (! CreateProcess(progs, cmdlines, NULL, NULL, TRUE, flags,
envs, cwds, &si, &pi)) {
err = GetLastError();
}
caml_stat_free(progs);
caml_stat_free(cmdlines);
caml_stat_free(envs);
caml_stat_free(cwds);
ret:
/* Close the handles if we duplicated them above. */
if (to_close0 != INVALID_HANDLE_VALUE) CloseHandle(to_close0);
if (to_close1 != INVALID_HANDLE_VALUE) CloseHandle(to_close1);
if (to_close2 != INVALID_HANDLE_VALUE) CloseHandle(to_close2);
if (err != ERROR_SUCCESS) {
win32_maperr(err);
uerror("CreateProcess", Nothing);
}
CloseHandle(pi.hThread);
result = caml_alloc_tuple(2);
Store_field(result, 0, Val_int(pi.dwProcessId));
Store_field(result, 1, win_alloc_handle(pi.hProcess));
CAMLreturn(result);
}
struct job_wait {
struct lwt_unix_job job;
HANDLE handle;
};
static void worker_wait(struct job_wait *job) {
WaitForSingleObject(job->handle, INFINITE);
}
static value result_wait(struct job_wait *job) {
DWORD code, error;
if (!GetExitCodeProcess(job->handle, &code)) {
error = GetLastError();
CloseHandle(job->handle);
lwt_unix_free_job(&job->job);
win32_maperr(error);
uerror("GetExitCodeProcess", Nothing);
}
CloseHandle(job->handle);
lwt_unix_free_job(&job->job);
return Val_int(code);
}
CAMLprim value lwt_process_wait_job(value handle) {
LWT_UNIX_INIT_JOB(job, wait, 0);
job->handle = Handle_val(handle);
return lwt_unix_alloc_job(&(job->job));
}
CAMLprim value lwt_process_terminate_process(value handle, value code) {
if (!TerminateProcess(Handle_val(handle), Int_val(code))) {
win32_maperr(GetLastError());
uerror("TerminateProcess", Nothing);
}
return Val_unit;
}
#else /* defined(LWT_ON_WINDOWS) */
/* This is used to suppress a warning from ranlib about the object file having
no symbols. */
void lwt_process_dummy_symbol() {}
#endif /* defined(LWT_ON_WINDOWS) */
| /* This file is part of Lwt, released under the MIT license. See LICENSE.md for
details, or visit https://github.com/ocsigen/lwt/blob/master/LICENSE.md. */ |
script_list.ml | open Script_typed_ir
let empty : 'a boxed_list = {elements = []; length = 0}
let cons : 'a -> 'a boxed_list -> 'a boxed_list =
fun elt l -> {length = 1 + l.length; elements = elt :: l.elements}
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* Copyright (c) 2020 Metastate AG <hello@metastate.dev> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
dump_core_on_job_delay_stubs.c |
#define _GNU_SOURCE
#include <assert.h>
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdbool.h>
#include "ocaml_utils.h"
/* this type must be kept strictly in sync with the OCaml type */
typedef enum {
CALL_ABORT = 0,
CALL_GCORE = 1,
DUMP_TYPE_LIMIT = 2 /* used to catch mismatch between this type and the OCaml type */
} core_dump_type;
static int num_ticks = 0; /* updated by regular Async job */
static int core_dump_count = 0;
#define CORE_FILENAME_MAX_LEN (4 + 1 + 10 + 1)
/* max pid is 2^22 on 64 bit systems, which is 7 digits + 1 for terminating NULL. */
#define PID_STR_MAX_LEN 10
static void dump_core (core_dump_type dump_type)
{
pid_t main_pid = getpid ();
pid_t fork_pid;
int status;
char gcore_path[] = "/usr/bin/gcore";
char pid_str[PID_STR_MAX_LEN];
char core_filename[CORE_FILENAME_MAX_LEN]; /* core.<count>. */
char *args[] = { NULL, NULL, NULL, NULL, NULL };
char *env[] = { NULL };
core_dump_count = core_dump_count + 1;
switch (dump_type) {
case CALL_ABORT:
abort ();
break;
case CALL_GCORE:
fork_pid = fork ();
if (fork_pid) {
waitpid (fork_pid, &status, 0);
} else {
assert (snprintf (core_filename, CORE_FILENAME_MAX_LEN, "core.%i",
core_dump_count)
< CORE_FILENAME_MAX_LEN);
assert (snprintf (pid_str, PID_STR_MAX_LEN, "%d", main_pid) < PID_STR_MAX_LEN);
args[0] = gcore_path;
args[1] = "-o";
args[2] = core_filename;
args[3] = pid_str;
execve(gcore_path, args, env);
};
break;
case DUMP_TYPE_LIMIT:
caml_leave_blocking_section();
caml_failwith ("bug in dump_core_on_job_delay_dump_core");
};
}
CAMLprim value dump_core_on_job_delay_dump_core (value v_dump_type)
{
CAMLparam1 (v_dump_type);
core_dump_type dump_type = Int_val (v_dump_type);
if ( dump_type >= DUMP_TYPE_LIMIT )
caml_failwith ("bug in dump_core_on_job_delay_dump_core");
dump_core (dump_type);
CAMLreturn (Val_unit);
}
CAMLprim value dump_core_on_job_delay_watch (value v_dump_if_delayed_by,
value v_dump_type)
{
CAMLparam2 (v_dump_if_delayed_by, v_dump_type);
useconds_t dump_if_delayed_by = Double_val (v_dump_if_delayed_by) * 1000 * 1000;
core_dump_type dump_type = CALL_ABORT;
int last_num_ticks_seen = num_ticks;
bool already_dumped_this_cycle = false;
dump_type = Int_val (v_dump_type);
if ( dump_type >= DUMP_TYPE_LIMIT )
caml_failwith ("bug in dump_core_on_job_delay_watch");
/* We give up the CAML lock because we intend to run the following
loop for the life of the program. */
caml_enter_blocking_section();
for (;;) {
usleep (dump_if_delayed_by);
/* If [last_num_ticks_seen] is the same as the last time we woke
up, then the Async tick job has been delayed. */
if (last_num_ticks_seen == num_ticks) {
if (!already_dumped_this_cycle) {
already_dumped_this_cycle = true;
dump_core (dump_type);
}
} else {
/* Otherwise, if the count has changed, and we reset everything. */
already_dumped_this_cycle = false;
last_num_ticks_seen = num_ticks;
};
};
caml_leave_blocking_section();
CAMLreturn (Val_unit);
}
CAMLprim value dump_core_on_job_delay_tick (value v_unit)
{
/* Not strictly needed, but it keeps the compiler from complaining
about an unused [v_unit] arg, and there really isn't a need to make
this as fast as possible. */
CAMLparam1 (v_unit);
num_ticks = num_ticks + 1;
CAMLreturn (Val_unit);
}
| |
polylog_tail.c |
#include "mag.h"
void
mag_polylog_tail(mag_t u, const mag_t z, slong sigma, ulong d, ulong N)
{
mag_t TN, UN, t;
if (N < 2)
{
mag_inf(u);
return;
}
mag_init(TN);
mag_init(UN);
mag_init(t);
if (mag_cmp_2exp_si(z, 0) >= 0)
{
mag_inf(u);
}
else
{
/* Bound T(N) */
mag_pow_ui(TN, z, N);
/* multiply by log(N)^d */
if (d > 0)
{
mag_log_ui(t, N);
mag_pow_ui(t, t, d);
mag_mul(TN, TN, t);
}
/* multiply by 1/k^s */
if (sigma > 0)
{
mag_set_ui_lower(t, N);
mag_pow_ui_lower(t, t, sigma);
mag_div(TN, TN, t);
}
else if (sigma < 0)
{
mag_set_ui(t, N);
mag_pow_ui(t, t, -sigma);
mag_mul(TN, TN, t);
}
/* Bound U(N) */
mag_set(UN, z);
/* multiply by (1 + 1/N)**S */
if (sigma < 0)
{
mag_binpow_uiui(t, N, -sigma);
mag_mul(UN, UN, t);
}
/* multiply by (1 + 1/(N log(N)))^d */
if (d > 0)
{
ulong nl;
/* rounds down */
nl = mag_d_log_lower_bound(N) * N * (1 - 1e-13);
mag_binpow_uiui(t, nl, d);
mag_mul(UN, UN, t);
}
/* T(N) / (1 - U(N)) */
if (mag_cmp_2exp_si(UN, 0) >= 0)
{
mag_inf(u);
}
else
{
mag_one(t);
mag_sub_lower(t, t, UN);
mag_div(u, TN, t);
}
}
mag_clear(TN);
mag_clear(UN);
mag_clear(t);
}
| /*
Copyright (C) 2014 Fredrik Johansson
This file is part of Arb.
Arb is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License (LGPL) as published
by the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version. See <http://www.gnu.org/licenses/>.
*/ |
routed.ml |
open! Core
type 'a t =
{ envelope : 'a
; next_hop_choices : Host_and_port.t list
; retry_intervals : Retry_interval.t list
}
[@@deriving sexp_of, fields, compare, hash]
type 'a create =
envelope:'a
-> next_hop_choices:Host_and_port.t list
-> retry_intervals:Retry_interval.t list
-> 'a t
type 'a set =
?sender:Sender.t
-> ?sender_args:Sender_argument.t list
-> ?recipients:Email_address.t list
-> ?rejected_recipients:Email_address.t list
-> ?route:string option
-> ?next_hop_choices:Host_and_port.t list
-> ?retry_intervals:Retry_interval.t list
-> 'a
| |
server.mli |
module Schema = Graphql_lwt.Schema
(** GraphQL server *)
module type S = sig
module IO : Cohttp_lwt.S.IO
type repo
type server
type response_action =
[ `Expert of Cohttp.Response.t * (IO.ic -> IO.oc -> unit Lwt.t)
| `Response of Cohttp.Response.t * Cohttp_lwt.Body.t ]
val schema : repo -> unit Schema.schema
val execute_request :
unit Schema.schema ->
Cohttp_lwt.Request.t ->
Cohttp_lwt.Body.t ->
response_action Lwt.t
val v : repo -> server
end
(** GraphQL server config *)
module type CONFIG = sig
val remote : (?headers:Cohttp.Header.t -> string -> Irmin.remote) option
val info :
?author:string -> ('a, Format.formatter, unit, Irmin.Info.f) format4 -> 'a
end
(** Custom GraphQL schema type and argument type for [type t]. *)
module type CUSTOM_TYPE = sig
type t
val schema_typ : (unit, t option) Schema.typ
val arg_typ : t option Schema.Arg.arg_typ
end
(** GraphQL types for Irmin concepts (key, metadata, contents, hash and branch). *)
module type CUSTOM_TYPES = sig
type key
type metadata
type contents
type hash
type branch
module Key : CUSTOM_TYPE with type t := key
module Metadata : CUSTOM_TYPE with type t := metadata
module Contents : CUSTOM_TYPE with type t := contents
module Hash : CUSTOM_TYPE with type t := hash
module Branch : CUSTOM_TYPE with type t := branch
end
(** Default GraphQL types for the Irmin store [S]. *)
module Default_types (S : Irmin.S) :
CUSTOM_TYPES
with type key := S.key
and type metadata := S.metadata
and type contents := S.contents
and type hash := S.hash
and type branch := S.branch
(** Create a GraphQL server with default GraphQL types for [S]. *)
module Make (Server : Cohttp_lwt.S.Server) (Config : CONFIG) (Store : Irmin.S) :
S with type repo = Store.repo and type server = Server.t
(** Create a GraphQL server with custom GraphQL types. *)
module Make_ext
(Server : Cohttp_lwt.S.Server)
(Config : CONFIG)
(Store : Irmin.S)
(Types : CUSTOM_TYPES
with type key := Store.key
and type metadata := Store.metadata
and type contents := Store.contents
and type hash := Store.hash
and type branch := Store.branch) :
S with type repo = Store.repo and type server = Server.t
| |
Util.mli | module Import: sig
type fontforge
type psMat
type extFontForge
type pyobject
type _ obj =
Fontforge: fontforge obj
| PsMat: psMat obj
(* | ExtFontForge: extFontForge obj
(* if some code has to be written in python *)
*)
type 'a t = 'a obj * pyobject
type 'a lazy_object = unit -> 'a t
val fontforge: fontforge lazy_object
val psMat: psMat lazy_object
(* val extFontForge: extFontForge lazy_object
(* if some code has to be written in python *)
*)
val python_of: 'a lazy_object -> pyobject
val pp_type: Format.formatter -> 'a obj -> unit
val pretty_type: Format.formatter -> 'a t -> unit
val init: unit -> unit
end
(***********************************************************)
module Object:sig
type contour
type font
type glyph
type glyphPen
type layer
type matrix
type point
type selection
type _ obj =
| Contour: contour obj
| Font: font obj
| Glyph: glyph obj
| GlyphPen: glyphPen obj
| Layer: layer obj
| Matrix: matrix obj
| Point: point obj
| Selection: selection obj
type pyobject
type 'a t = 'a obj * pyobject
val pretty_type: Format.formatter -> 'a t -> unit
val pretty: Format.formatter -> 'a t -> unit
val python_of: 'a t -> Pytypes.pyobject
val of_python: typ:'a obj -> Pytypes.pyobject -> 'a t
val pp_type: Format.formatter -> 'a obj -> unit
end
(***********************************************************)
module Value: sig
type _ obj =
| Object: 'a Object.obj -> 'a Object.t obj
| Unit: unit obj
| Bool: bool obj
| Float: float obj
| Int: int obj
| String: string obj
| Comb: 'a obj -> 'a list obj
| List: 'a obj -> 'a list obj
| Array: 'a obj -> 'a list obj
| Nullable: 'a obj -> 'a option obj
| Option: 'a obj -> 'a option obj
| Pair: 'a obj * 'b obj -> ('a * 'b) obj
| Coord: (float*float) obj
type t
val pp_type: Format.formatter -> 'a obj -> unit
val pretty_type: Format.formatter -> t -> unit
val pretty: Format.formatter -> t -> unit
val value: typ:'a obj -> 'a -> t
val python_of: t -> Pytypes.pyobject
val of_python: typ:'a obj -> Pytypes.pyobject -> 'a
end
(***********************************************************)
module API: sig
val size: 'a Object.t -> int
val get: typ:'b Value.obj -> m:string -> 'a Object.t -> 'b
(** get an attribute *)
val set: typ:'b Value.obj -> m:string -> 'a Object.t -> 'b -> unit
(** set an attribute *)
val call_method:
typ:'a Value.obj -> m:string -> Value.t list -> 'b Object.t -> 'a
(** method call of an object *)
val call_function:
'b Import.lazy_object -> typ:'a Value.obj -> m:string -> Value.t list -> 'a
(** function call of an imported module *)
end
(***********************************************************)
| (******************************************************************************)
(* *)
(* This file is part of fontforge-of-ocaml library *)
(* *)
(* Copyright (C) 2017-2022, Patrick BAUDIN *)
(* (https://github.com/pbaudin/fontforge-of-ocaml) *)
(* *)
(* you can redistribute it and/or modify it under the terms of the GNU *)
(* Lesser General Public License as published by the Free Software *)
(* Foundation, version 2.1. *)
(* *)
(* It is distributed in the hope that it will be useful, but WITHOUT ANY *)
(* WARRANTY; without even the implied warranty of MERCHANTABILITY or *)
(* FITNESS FOR A PARTICULAR PURPOSE. *)
(* *)
(* See the GNU Lesser General Public License version 2.1 *)
(* for more details (enclosed in the file licenses/LGPLv2.1) *)
(* *)
(******************************************************************************)
|
pvm.ml | open Protocol
open Alpha_context
(** Desired module type of a PVM from the L2 node's perspective *)
module type S = sig
include
Sc_rollup.PVM.S
with type context = Context.rw_index
and type hash = Sc_rollup.State_hash.t
(** Kind of the PVM (same as {!name}). *)
val kind : Sc_rollup.Kind.t
(** [get_tick state] gets the total tick counter for the given PVM state. *)
val get_tick : state -> Sc_rollup.Tick.t Lwt.t
(** PVM status *)
type status
(** [get_status state] gives you the current execution status for the PVM. *)
val get_status : state -> status Lwt.t
(** [string_of_status status] returns a string representation of [status]. *)
val string_of_status : status -> string
(** [get_outbox outbox_level state] returns a list of outputs
available in the outbox of [state] at a given [outbox_level]. *)
val get_outbox : Raw_level.t -> state -> Sc_rollup.output list Lwt.t
(** [eval_many ~max_steps s0] returns a state [s1] resulting from the
execution of up to [~max_steps] steps of the rollup at state [s0]. *)
val eval_many :
reveal_builtins:Tezos_scoru_wasm.Builtins.reveals ->
write_debug:Tezos_scoru_wasm.Builtins.write_debug ->
?stop_at_snapshot:bool ->
max_steps:int64 ->
state ->
(state * int64) Lwt.t
val new_dissection :
default_number_of_sections:int ->
start_chunk:Sc_rollup.Dissection_chunk.t ->
our_stop_chunk:Sc_rollup.Dissection_chunk.t ->
Sc_rollup.Tick.t list
module RPC : sig
(** Build RPC directory of the PVM *)
val build_directory : Node_context.rw -> unit Environment.RPC_directory.t
end
(** State storage for this PVM. *)
module State : sig
(** [empty ()] is the empty state. *)
val empty : unit -> state
(** [find context] returns the PVM state stored in the [context], if any. *)
val find : _ Context.t -> state option Lwt.t
(** [lookup state path] returns the data stored for the path [path] in the
PVM state [state]. *)
val lookup : state -> string list -> bytes option Lwt.t
(** [set context state] saves the PVM state [state] in the context and
returns the updated context. Note: [set] does not perform any write on
disk, this information must be committed using {!Context.commit}. *)
val set : 'a Context.t -> state -> 'a Context.t Lwt.t
end
end
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2022-2023 TriliTech <contact@trili.tech> *)
(* Copyright (c) 2022 Nomadic Labs, <contact@nomadic-labs.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
tast_iterator.mli | (**
Allows the implementation of typed tree inspection using open recursion
*)
open Asttypes
open Typedtree
type iterator =
{
binding_op: iterator -> binding_op -> unit;
case: 'k . iterator -> 'k case -> unit;
class_declaration: iterator -> class_declaration -> unit;
class_description: iterator -> class_description -> unit;
class_expr: iterator -> class_expr -> unit;
class_field: iterator -> class_field -> unit;
class_signature: iterator -> class_signature -> unit;
class_structure: iterator -> class_structure -> unit;
class_type: iterator -> class_type -> unit;
class_type_declaration: iterator -> class_type_declaration -> unit;
class_type_field: iterator -> class_type_field -> unit;
env: iterator -> Env.t -> unit;
expr: iterator -> expression -> unit;
extension_constructor: iterator -> extension_constructor -> unit;
module_binding: iterator -> module_binding -> unit;
module_coercion: iterator -> module_coercion -> unit;
module_declaration: iterator -> module_declaration -> unit;
module_substitution: iterator -> module_substitution -> unit;
module_expr: iterator -> module_expr -> unit;
module_type: iterator -> module_type -> unit;
module_type_declaration: iterator -> module_type_declaration -> unit;
package_type: iterator -> package_type -> unit;
pat: 'k . iterator -> 'k general_pattern -> unit;
row_field: iterator -> row_field -> unit;
object_field: iterator -> object_field -> unit;
open_declaration: iterator -> open_declaration -> unit;
open_description: iterator -> open_description -> unit;
signature: iterator -> signature -> unit;
signature_item: iterator -> signature_item -> unit;
structure: iterator -> structure -> unit;
structure_item: iterator -> structure_item -> unit;
typ: iterator -> core_type -> unit;
type_declaration: iterator -> type_declaration -> unit;
type_declarations: iterator -> (rec_flag * type_declaration list) -> unit;
type_extension: iterator -> type_extension -> unit;
type_exception: iterator -> type_exception -> unit;
type_kind: iterator -> type_kind -> unit;
value_binding: iterator -> value_binding -> unit;
value_bindings: iterator -> (rec_flag * value_binding list) -> unit;
value_description: iterator -> value_description -> unit;
with_constraint: iterator -> with_constraint -> unit;
}
val default_iterator: iterator
| (**************************************************************************)
(* *)
(* OCaml *)
(* *)
(* Isaac "Izzy" Avram *)
(* *)
(* Copyright 2019 Institut National de Recherche en Informatique et *)
(* en Automatique. *)
(* *)
(* All rights reserved. This file is distributed under the terms of *)
(* the GNU Lesser General Public License version 2.1, with the *)
(* special exception on linking described in the file LICENSE. *)
(* *)
(**************************************************************************)
|
p-factor_kaltofen_shoup_vs_fq_poly.c |
#include <stdio.h>
#include <stdlib.h>
#include <gmp.h>
#include <float.h>
#include "flint.h"
#include "fmpz.h"
#include "ulong_extras.h"
#include "profiler.h"
#include "fq_poly.h"
#include "fq_nmod_poly.h"
#define nalgs 2
#define ncases 1
#define cpumin 2
int
main(int argc, char** argv)
{
slong s[nalgs];
int c, n, len, ext, reps = 0;
slong j;
fmpz_t p, temp;
fq_poly_t f, g;
fq_nmod_poly_t fn;
fq_ctx_t ctx;
fq_nmod_ctx_t ctxn;
fmpz_poly_t fpoly;
nmod_poly_t nmod;
FLINT_TEST_INIT(state);
fmpz_init(p);
fmpz_set_str(p, argv[1], 10);
fmpz_init(temp);
fmpz_set_str(temp, argv[2], 10);
ext = fmpz_get_si(temp);
fmpz_set_str(temp, argv[3], 10);
len = fmpz_get_si(temp);
fq_ctx_init(ctx, p, ext, "a");
fmpz_poly_init(fpoly);
nmod_poly_init(nmod, fmpz_get_ui(p));
fmpz_poly_get_nmod_poly(nmod, fpoly);
fq_nmod_ctx_init_modulus(ctxn, nmod, "a");
fq_poly_init(f, ctx);
fq_poly_init(g, ctx);
fq_nmod_poly_init(fn, ctxn);
for (c = 0; c < nalgs; c++)
{
s[c] = WORD(0);
}
for (n = 0; n < ncases; n++)
{
timeit_t t[nalgs];
int l, loops = 1;
fq_poly_factor_t res;
fq_nmod_poly_factor_t resn;
/*
Construct random elements of fq
*/
{
fq_poly_randtest_irreducible(f, state, len + 1, ctx);
fq_poly_randtest_irreducible(g, state, len + 2, ctx);
fq_poly_mul(f, f, g, ctx);
fq_poly_make_monic(f, f, ctx);
fq_nmod_poly_fit_length(fn, f->length, ctxn);
for (j = 0; j < f->length; j++)
{
fmpz_poly_get_nmod_poly(fn->coeffs + j, f->coeffs + j);
}
_fq_nmod_poly_set_length(fn, f->length, ctxn);
}
loop:
fflush(stdout);
timeit_start(t[0]);
for (l = 0; l < loops; l++)
{
fq_poly_factor_init(res, ctx);
fq_poly_factor_kaltofen_shoup(res, f, ctx);
fq_poly_factor_clear(res, ctx);
}
timeit_stop(t[0]);
timeit_start(t[1]);
for (l = 0; l < loops; l++)
{
fq_nmod_poly_factor_init(resn, ctxn);
fq_nmod_poly_factor_kaltofen_shoup(resn, fn, ctxn);
fq_nmod_poly_factor_clear(resn, ctxn);
}
timeit_stop(t[1]);
for (c = 0; c < nalgs; c++)
if (t[c]->cpu <= cpumin)
{
loops += 2;
goto loop;
}
for (c = 0; c < nalgs; c++)
s[c] += t[c]->cpu;
reps += loops;
}
for (c = 0; c < nalgs; c++)
{
flint_printf("%20f ", s[c] / (double) reps);
fflush(stdout);
}
printf("\n");
fq_poly_clear(f, ctx);
fq_poly_clear(g, ctx);
fq_nmod_poly_clear(fn, ctxn);
nmod_poly_clear(nmod);
fq_ctx_clear(ctx);
fq_nmod_ctx_clear(ctxn);
fmpz_clear(p);
fmpz_clear(temp);
FLINT_TEST_CLEANUP(state);
return 0;
}
| /*
Copyright (C) 2013 Mike Hansen
This file is part of FLINT.
FLINT is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License (LGPL) as published
by the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version. See <https://www.gnu.org/licenses/>.
*/ |
contract_hash.mli | (** A specialized Blake2B implementation for hashing contract identifiers. *)
include S.HASH
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* Copyright (c) 2020-2021 Nomadic Labs <contact@nomadic-labs.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
lseek.c | #include <caml/mlvalues.h>
#include <caml/alloc.h>
#include "unixsupport.h"
#ifdef HAS_UNISTD
#include <unistd.h>
#else
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2
#endif
static DWORD seek_command_table[] = {
FILE_BEGIN, FILE_CURRENT, FILE_END
};
#ifndef INVALID_SET_FILE_POINTER
#define INVALID_SET_FILE_POINTER (-1)
#endif
static __int64 caml_set_file_pointer(HANDLE h, __int64 dist, DWORD mode)
{
LARGE_INTEGER i;
DWORD err;
i.QuadPart = dist;
i.LowPart = SetFilePointer(h, i.LowPart, &i.HighPart, mode);
if (i.LowPart == INVALID_SET_FILE_POINTER) {
err = GetLastError();
if (err != NO_ERROR) { win32_maperr(err); uerror("lseek", Nothing); }
}
return i.QuadPart;
}
CAMLprim value unix_lseek(value fd, value ofs, value cmd)
{
__int64 ret;
ret = caml_set_file_pointer(Handle_val(fd), Long_val(ofs),
seek_command_table[Int_val(cmd)]);
if (ret > Max_long) {
win32_maperr(ERROR_ARITHMETIC_OVERFLOW);
uerror("lseek", Nothing);
}
return Val_long(ret);
}
CAMLprim value unix_lseek_64(value fd, value ofs, value cmd)
{
__int64 ret;
ret = caml_set_file_pointer(Handle_val(fd), Int64_val(ofs),
seek_command_table[Int_val(cmd)]);
return caml_copy_int64(ret);
}
| /**************************************************************************/
/* */
/* OCaml */
/* */
/* Xavier Leroy, projet Cristal, INRIA Rocquencourt */
/* */
/* Copyright 1996 Institut National de Recherche en Informatique et */
/* en Automatique. */
/* */
/* All rights reserved. This file is distributed under the terms of */
/* the GNU Lesser General Public License version 2.1, with the */
/* special exception on linking described in the file LICENSE. */
/* */
/**************************************************************************/
|
query.ml |
open Printf
open ExtLib
open Common
type var_list = [ `List of Tjson.var list | `Var of Tjson.var ]
let var_list_of_json ~desc = function
| `List l -> `List (List.filter_map (function `Var v -> Some v | _ -> None) l)
| `Var _ as x -> x
| _ -> fail "bad %s : expecting list or variable" desc
type query_t =
| Bool of (string * query list) list
| Field of { field : string; multi : multi; values : Tjson.t list }
| Var of Tjson.var
| Strings of var_list
| Nothing
and query = { json : Tjson.t; query : query_t }
type t =
| Search of { q : query; extra : constraint_t list; source : source_filter option; highlight : string list option; }
| Mget of { ids: var_list; json: Tjson.t; conf: Tjson.t }
| Get of (Tjson.var * source_filter option)
module Variable = struct
type t = Property of multi * ES_name.t * simple_type | Any | Type of simple_type | List of simple_type
let show = function
| Any -> "any"
| Type typ -> show_simple_type typ
| List typ -> sprintf "[%s]" (show_simple_type typ)
| Property (multi,name,typ) ->
let s = sprintf "%s:%s" (ES_name.show name) (show_simple_type typ) in
match multi with
| One -> s
| Many -> sprintf "[%s]" s
let equal a b =
match a,b with
| Any, Any -> true
| Type a, Type b -> a = b
| Property (m1,n1,t1), Property (m2,n2,t2) -> ES_name.equal n1 n2 && t1 = t2 && m1 = m2
| _ -> false
end
let lookup json x = try Some (U.assoc x json) with _ -> None
let multi_of_qt = function "terms" -> Many | _ -> One
let rec extract_clause (clause,json) =
try match clause with
| "must" | "must_not" | "should" | "filter" ->
begin match json with
| `Var v -> (json, (clause, [ {json; query=Var v} ]))
| `Assoc _ as x -> let q = extract_query x in (q.json, (clause, [q]))
| `List l ->
let l = List.map extract_query l in
let json = `List (List.map (fun q -> q.json) l) in
(json, (clause, l))
| _ -> fail "bad %S clause : expected list or dict" clause
end
| "minimum_should_match" ->
begin match json with
| `Int _ | `String _ -> json, (clause, [])
| _ -> fail "bad %S clause : expected int or string" clause
end
| _ -> fail "unsupported clause"
with
exn -> fail ~exn "clause %S" clause
and extract_query json =
let (qt,qv) = match json with `Assoc [q] -> q | _ -> fail "bad query" in
let (json,query) = match qt, qv with
| ("function_score"|"nested"), `Assoc l ->
begin match List.assoc "query" l with
| exception _ when qt = "nested" -> fail "nested query requires query, duh"
| exception _ when qt = "function_score" -> json, Nothing
| q ->
let { json; query } = extract_query q in
`Assoc [qt, Tjson.replace qv "query" json], query
end
| "bool", `Assoc l ->
let bool = List.map extract_clause l in
let json = `Assoc ["bool", `Assoc (List.map (fun (json,(clause,_)) -> clause, json) bool)] in
json, Bool (List.map snd bool)
| "ids", x -> json, Strings (var_list_of_json ~desc:"ids values" (U.assoc "values" x))
| "query_string", x -> json, (match U.assoc "query" x with `Var x -> Strings (`List [x]) | _ -> Nothing)
| ("match_all"|"match_none"), _ -> json, Nothing
| _qt, `Var x -> json, Var x
| "range", `Assoc [_f, `Var x] -> json, Var x
| _ ->
let field, values =
(* For simple single-field queries, store relation of one field to one or more values (with or without variables) *)
try
match qt with
| "term"
| "prefix"
| "wildcard"
| "regexp"
| "fuzzy"
| "type"
| "match_phrase" ->
begin match qv with
| `Assoc [f, (`Assoc _ as x)] -> f, [U.assoc "value" x]
| `Assoc [f, x] -> f, [x]
| _ -> fail "expected dictionary with single key (field name)"
end
| _ ->
match qt, qv with
| "exists", `Assoc ["field", `String f] -> f, []
| "terms", `Assoc [f, x] -> f, [x] (* TODO distinguish terms lookup *)
| "range", `Assoc [f, (`Assoc _ as x)] -> f, List.filter_map (lookup x) ["gte";"gt";"lte";"lt"]
| "match", `Assoc [f, (`Assoc _ as x)] -> f, [U.assoc "query" x]
| "match", `Assoc [f, x] -> f, [x]
| _ -> fail "unrecognized"
with exn ->
fail ~exn "dsl query %S" qt
in
json, Field { field; multi = multi_of_qt qt; values }
in
let json =
match List.filter_map (fun {Tjson.optional;list=_;name} -> if optional then Some name else None) @@ Tjson.get_vars ~optional:false json with
| [] -> json
| vars ->
if Tjson.debug_dump then printfn "introducing optional scope for : %s" (String.concat " " vars);
let label =
match vars with
| [var] -> var (* single variable group should be named same as variable *)
| _ ->
match query with
| Field { field; _ } -> field
| _ -> String.concat "_" vars
in
let label = to_valid_ident ~prefix:"f_" label in (* XXX *)
`Optional ({ label; vars }, json)
in
{ query; json }
let record vars var ti =
match Hashtbl.find vars var with
| exception _ -> Hashtbl.add vars var ti
| x when Variable.equal x ti -> ()
| x -> fail "type mismatch for variable %S : %s <> %s" var (Variable.show ti) (Variable.show x)
let infer' c0 query =
let constraints = ref c0 in
let rec iter { query; json=_ } =
match query with
| Bool l -> List.iter (fun (_typ,l) -> List.iter iter l) l
| Field { field; multi; values } ->
List.iter (function `Var var -> tuck constraints (On_var (var, Eq_field (multi,field))) | _ -> ()) values
| Var var -> tuck constraints (On_var (var, Eq_any))
| Strings (`Var var) -> tuck constraints (On_var (var, Eq_list `String))
| Strings (`List l) -> l |> List.iter (function var -> tuck constraints (On_var (var, Eq_type `String)))
| Nothing -> ()
in
iter query;
!constraints
let infer = infer' []
let record_single_var typ (v:Tjson.var) =
let vars = Hashtbl.create 3 in
record vars v.name typ;
vars
let resolve_mget_types ids =
match ids with
| `Var (v:Tjson.var) -> record_single_var (List `String) v
| _ -> fail "mget: only variable ids supported"
let resolve_get_types = record_single_var (Type `String)
let get_var json name =
match U.member name json with
| `Var v -> assert (v.Tjson.optional = false); Some v
| _ -> None
let extract_conf json =
match U.member "_esgg" json with
| `Null -> `Assoc []
| j -> j
let extract_source json =
let source = U.member "_source" json in
match U.member "size" json = `Int 0 || source = `Bool false with
| true -> None
| false ->
let (excludes,includes) =
match source with
| `List l -> None, Some (List.map U.to_string l)
| `String s -> None, Some [s]
| _ -> source_fields "excludes" json, source_fields "includes" json
in
Some { excludes; includes; }
let extract_highlight json =
match U.opt "highlight" id json with
| None -> None
| Some json -> Some (U.get "fields" U.to_assoc json |> List.map fst)
(** Filter out the [_esgg] field from the json if it exist. *)
let filter_out_conf json =
match json with
| `Assoc l -> `Assoc (List.filter (fun (k, _v) -> k <> "_esgg") l)
| j -> j
let extract json =
match U.assoc "query" json with
| q ->
let extra = List.map (fun v -> On_var (v, Eq_type `Int)) @@ List.filter_map (get_var json) ["size";"from"] in
Search { q = extract_query q; extra; source = extract_source json; highlight = extract_highlight json; }
| exception _ ->
match U.assoc "id" json with
| `Var v -> Get (v, extract_source json)
| _ -> fail "only variable id supported for get request"
| exception _ ->
let conf = extract_conf json in
let json = filter_out_conf json in
let ids =
match U.assoc "docs" json with
| `List l -> var_list_of_json ~desc:"mget docs" (`List (List.map U.(assoc "_id") l))
| _ -> fail "unexpected docs"
| exception _ ->
match U.(assoc "ids" json) with
| ids -> var_list_of_json ~desc:"mget ids" ids
| exception _ -> fail "unrecognized ES toplevel query type, expected one of : id, ids, docs, query"
in
Mget { ids; json; conf }
let resolve_constraints mapping l =
let typeof field =
let name = ES_name.make mapping field in
let typ = typeof mapping name in
name, typ
in
let vars = Hashtbl.create 3 in
l |> List.iter begin function
| On_var (var,t) ->
let t = match t with
| Eq_type typ -> Variable.Type typ
| Eq_list typ -> List typ
| Eq_object -> Any (* TODO object of json *)
| Eq_any -> Any
| Eq_field (multi,field) ->
let (name,typ) = typeof field in
Property (multi,name,typ)
in
record vars var.name t
| Field_num (Field f) ->
begin match snd @@ typeof f with
| `Int | `Int64 | `Double -> ()
| `String | `Bool | `Json as t -> eprintfn "W: field %S expected to be numeric, but has type %s" f (show_simple_type t)
end
| Field_num (Script _) -> ()
| Field_date _ -> ()
end;
vars
| |
dependent_bool.ml | type no = private DNo
type yes = private DYes
type _ dbool = No : no dbool | Yes : yes dbool
type ('a, 'b, 'r) dand =
| NoNo : (no, no, no) dand
| NoYes : (no, yes, no) dand
| YesNo : (yes, no, no) dand
| YesYes : (yes, yes, yes) dand
type ('a, 'b) ex_dand = Ex_dand : ('a, 'b, _) dand -> ('a, 'b) ex_dand
[@@unboxed]
let dand : type a b. a dbool -> b dbool -> (a, b) ex_dand =
fun a b ->
match (a, b) with
| (No, No) -> Ex_dand NoNo
| (No, Yes) -> Ex_dand NoYes
| (Yes, No) -> Ex_dand YesNo
| (Yes, Yes) -> Ex_dand YesYes
let dbool_of_dand : type a b r. (a, b, r) dand -> r dbool = function
| NoNo -> No
| NoYes -> No
| YesNo -> No
| YesYes -> Yes
type (_, _) eq = Eq : ('a, 'a) eq
let merge_dand :
type a b c1 c2. (a, b, c1) dand -> (a, b, c2) dand -> (c1, c2) eq =
fun w1 w2 ->
match (w1, w2) with
| (NoNo, NoNo) -> Eq
| (NoYes, NoYes) -> Eq
| (YesNo, YesNo) -> Eq
| (YesYes, YesYes) -> Eq
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2022 Nomadic Labs <contact@nomadic-labs.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
extism.mli | (** Extism bindings for OCaml *)
val extism_version : unit -> string
(** Returns the libextism version, not the version of the OCaml library *)
module Manifest = Extism_manifest
module Error : sig
type t = [ `Msg of string ]
exception Error of t
val unwrap : ('a, t) result -> 'a
val throw : t -> 'a
end
(** [Val_type] enumerates every possible argument/result type *)
module Val_type : sig
type t =
| I32
| I64
| F32
| F64
| V128
| FuncRef
| ExternRef (** Value type *)
val of_int : int -> t
val to_int : t -> int
end
(** [Val] represents low-level WebAssembly values *)
module Val : sig
type t
(** Val *)
val ty : t -> Val_type.t
(** [ty v] returns the [Val_type.t] for the value [v] *)
val of_i32 : int32 -> t
(** Create an i32 [Val] *)
val of_i64 : int64 -> t
(** Create an i64 [Val] *)
val of_f32 : float -> t
(** Create an f32 [Val] *)
val of_f64 : float -> t
(** Create an f64 [Val] *)
val to_i32 : t -> int32 option
(** Get an int32 from [Val] if the type matches *)
val to_i64 : t -> int64 option
(** Get an int64 from [Val] if the type matches *)
val to_f32 : t -> float option
(** Get a f32 from [Val] if the type matches *)
val to_f64 : t -> float option
(** Get an f64 from [Val] if the type matches *)
val to_i32_exn : t -> int32
(** Same as [to_i32] but raises an exception if the types don't match*)
val to_i64_exn : t -> int64
(** Same as [to_i64] but raises an exception if the types don't match*)
val to_f32_exn : t -> float
(** Same as [to_f32] but raises an exception if the types don't match*)
val to_f64_exn : t -> float
(** Same as [to_f64] but raises an exception if the types don't match*)
end
(** [Val_array] is used for input/output parameters for host functions *)
module Val_array : sig
type t = Val.t Ctypes.CArray.t
(** [Val_array] type *)
val get : t -> int -> Val.t
(** Get an index *)
val set : t -> int -> Val.t -> unit
(** Set an index *)
val length : t -> int
(** Get the number of items in a [Val_array]*)
val ( .$[] ) : t -> int -> Val.t
(** Syntax for [get] *)
val ( .$[]<- ) : t -> int -> Val.t -> unit
(** Syntax for [set] *)
end
(** [Current_plugin] represents the plugin that is currently running, it should
it should only be used from a host function *)
module Current_plugin : sig
type t
(** Opaque type, wraps [ExtismCurrentPlugin] *)
type memory_block = { offs : Unsigned.UInt64.t; len : Unsigned.UInt64.t }
(** Represents a block of guest memory *)
val memory : ?offs:Unsigned.UInt64.t -> t -> Unsigned.uint8 Ctypes.ptr
(** Get pointer to entire plugin memory *)
val find : t -> Unsigned.UInt64.t -> memory_block option
(** Find memory block *)
val alloc : t -> int -> memory_block
(** Allocate a new block of memory *)
val free : t -> memory_block -> unit
(** Free an allocated block of memory *)
val return_string : t -> Val_array.t -> int -> string -> unit
val return_bigstring : t -> Val_array.t -> int -> Bigstringaf.t -> unit
val input_string : t -> Val_array.t -> int -> string
val input_bigstring : t -> Val_array.t -> int -> Bigstringaf.t
(** Some helpter functions for reading/writing memory *)
module Memory_block : sig
val to_val : memory_block -> Val.t
(** Convert memory block to [Val] *)
val of_val : t -> Val.t -> memory_block option
(** Convert [Val] to memory block *)
val of_val_exn : t -> Val.t -> memory_block
(** Convert [Val] to memory block, raises [Invalid_argument] if the value is not a pointer
to a valid memory block *)
val get_string : t -> memory_block -> string
(** Get a string from memory stored at the provided offset *)
val get_bigstring : t -> memory_block -> Bigstringaf.t
(** Get a bigstring from memory stored at the provided offset *)
val set_string : t -> memory_block -> string -> unit
(** Store a string into memory at the provided offset *)
val set_bigstring : t -> memory_block -> Bigstringaf.t -> unit
(** Store a bigstring into memory at the provided offset *)
end
end
(** [Function] is used to create new a new function, which can be called
from a WebAssembly plugin *)
module Function : sig
type t
(** Function type *)
val create :
string ->
?namespace:string ->
params:Val_type.t list ->
results:Val_type.t list ->
user_data:'a ->
(Current_plugin.t -> Val_array.t -> Val_array.t -> 'a -> unit) ->
t
(** Create a new function, [Function.v name ~params ~results ~user_data f] creates
a new [Function] with the given [name], [params] specifies the argument types,
[results] specifies the return types, [user_data] is used to pass arbitrary
OCaml values into the function and [f] is the OCaml function that will be
called.
*)
val with_namespace : t -> string -> t
(** Update a function's namespace *)
val free : t -> unit
(** Free a function *)
val free_all : t list -> unit
(** Free a list of functions *)
end
(** [Context] is used to group plugins *)
module Context : sig
type t
(** Context type *)
val create : unit -> t
(** Create a new context *)
val free : t -> unit
(** Free a context. All plugins will be removed and the value should not be
accessed after this call *)
val reset : t -> unit
(** Reset a context. All plugins will be removed *)
end
val with_context : (Context.t -> 'a) -> 'a
(** Execute a function with a fresh context and free it after *)
val set_log_file :
?level:[ `Error | `Warn | `Info | `Debug | `Trace ] -> string -> bool
(** [Plugins] contain functions that can be called *)
module Plugin : sig
type t
val create :
?config:Manifest.config ->
?wasi:bool ->
?functions:Function.t list ->
Context.t ->
string ->
(t, Error.t) result
(** Make a new plugin from raw WebAssembly or JSON encoded manifest *)
val of_manifest :
?wasi:bool ->
?functions:Function.t list ->
Context.t ->
Manifest.t ->
(t, Error.t) result
(** Make a new plugin from a [Manifest] *)
val update :
t ->
?config:(string * string option) list ->
?wasi:bool ->
?functions:Function.t list ->
string ->
(unit, [ `Msg of string ]) result
(** Update a plugin from raw WebAssembly or JSON encoded manifest *)
val update_manifest : t -> ?wasi:bool -> Manifest.t -> (unit, Error.t) result
(** Update a plugin from a [Manifest] *)
val call_bigstring :
t -> name:string -> Bigstringaf.t -> (Bigstringaf.t, Error.t) result
(** Call a function, uses [Bigstringaf.t] for input/output *)
val call : t -> name:string -> string -> (string, Error.t) result
(** Call a function, uses [string] for input/output *)
val free : t -> unit
(** Drop a plugin *)
val function_exists : t -> string -> bool
(** Check if a function is exported by a plugin *)
module Cancel_handle: sig
type t
val cancel: t -> bool
end
val cancel_handle: t -> Cancel_handle.t
end
| (** Extism bindings for OCaml *)
|
roll_repr.mli | type t = private int32
type roll = t
val encoding : roll Data_encoding.t
val rpc_arg : roll RPC_arg.t
val random : Seed_repr.sequence -> bound:roll -> roll * Seed_repr.sequence
val first : roll
val succ : roll -> roll
val to_int32 : roll -> Int32.t
val ( = ) : roll -> roll -> bool
module Index : Storage_description.INDEX with type t = roll
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
nra_tactic.h | #pragma once
tactic * mk_nra_tactic(ast_manager & m, params_ref const & p = params_ref());
/*
ADD_TACTIC("nra", "builtin strategy for solving NRA problems.", "mk_nra_tactic(m, p)")
*/
| /*++
Copyright (c) 2012 Microsoft Corporation
Module Name:
nra_tactic.h
Abstract:
Tactic for NRA
Author:
Leonardo (leonardo) 2012-03-13
Notes:
--*/ |
mikhailsky.mli | open Protocol
(** Mikhailsky: Michelson in Micheline form, with typed holes and annotations.
Mikhailsky terms are hash-consed. *)
(**
Michelson code is a hard to type-check and generate incrementally due to
the presence of ambiguous constructs, such as literals
like [{ 1 ; 2 ; 3 }]. Is it a list of ints? of nats? of tez? Or a set?
Thus, we will work with Mikhailsky, a better behaved version of Michelson
allowing local reconstruction of types.
Differences wrt Michelson:
1. non string/byte literals are explicitly annotated with their head type constructor.
Here is an int i: Prim (_, D_int, [Int i], _)
Here is an nat n: Prim (_, D_nat, [Int i], _)
Here is an list of something: Prim (_, D_list, michelson_list, _)
Here is a set: Prim (_, D_set, michelson_set, _)
Here is a map: Prim (_, D_map, michelson_map, _)
etc.
Projecting back from this language to Michelson is trivial.
2. Instructions `LEFT/RIGHT` do not need to carry the type of the other
component of the disjunction. These has to be filled in back when
generating Michelson from Mikhailsky.
4. The same holds for the input/output type of a lambda as specified in the
`LAMBDA` instruction.
3. Some instructions are annotated with the type on which they operate.
Eg if Prim (_, I_ADD, [], []) is the (ad-hoc polymorphic) addition in Michelson,
we will have the following variants in Mikhailsky:
- Prim (_, I_ADD, [ Prim (_, T_mutez, [], []),
Prim (_, T_mutez, [], []) ], []) for mutez addition
- Prim (_, I_ADD, [ Prim (_, T_int, [], []),
Prim (_, T_nat, [], []) ], []) for int+nat addition
etc.
*)
(** The signature of Mikhailsky terms. *)
module Mikhailsky_signature : Signature.S with type t = Mikhailsky_prim.prim
(** Elements of type [Path.t] allow to index subterms of Mikhailsky terms. *)
module Path : Path.S
(** The following types correspond to those provided when instantiating the
functor [Micheline_with_hash_consing.Make] on [Mikhailsky_signature]. *)
type label = Micheline_with_hash_consing.hcons_info
type head = Mikhailsky_signature.t
type node = (label, head) Micheline.node
exception Term_contains_holes
exception Ill_formed_mikhailsky
(** [parse_ty] returns a type from a Mikhailsky term. *)
val parse_ty :
allow_big_map:bool ->
allow_operation:bool ->
allow_contract:bool ->
node ->
Type.Base.t
(** [map_var f x] maps the function f on all variables contained
in the type [x]. *)
val map_var : (int -> node) -> Type.Base.t -> node
(** [unparse_ty] returns a Mikhailsky term representing a type. *)
val unparse_ty_exn : Type.Base.t -> node
val unparse_ty : Type.Base.t -> node option
(** Extracts a Michelson term from a Mikhailsky one. Raises
[Term_contains_holes] if it cannot be done. *)
val to_michelson : node -> Script_repr.expr
(** Pretty printer. *)
val pp : Format.formatter -> node -> unit
val to_string : node -> string
(** Returns the number of nodes of a Mikhailsky term. *)
val size : node -> int
(** Micheline generic constructors *)
val prim : Mikhailsky_prim.prim -> node list -> string list -> node
val seq : node list -> node
val string : string -> node
val bytes : Bytes.t -> node
(** Mikhailsky smart constructors*)
(** Holes *)
val instr_hole : node
val data_hole : node
(** Types *)
val unit_ty : node
val int_ty : node
val nat_ty : node
val bool_ty : node
val string_ty : node
val bytes_ty : node
val key_hash_ty : node
val option_ty : node -> node
val list_ty : node -> node
(** Project unique tag out of Mikhailsky node *)
val tag : node -> int
(** Project hash out of Mikhailsky node *)
val hash : node -> int
(** Instructions *)
module Instructions : sig
(** Arithmetic. Binary operations take the input types as extra arguments. *)
val add : node -> node -> node
val sub : node -> node -> node
val mul : node -> node -> node
val ediv : node -> node -> node
val abs : node
val gt : node
(** Stack *)
val push : node -> node -> node
val dip : node -> node
val dup : node
val drop : node
val dropn : int -> node
val swap : node
(** Crypto *)
val blake2b : node
val sha256 : node
val sha512 : node
val hash_key : node
(** Control *)
val if_ : node -> node -> node
val if_left : node -> node -> node
val if_none : node -> node -> node
val loop : node -> node
val loop_left : node -> node
(** Pairs *)
val car : node
val cdr : node
val pair : node
(** Unions *)
val left : node
val right : node
(** Booleans *)
val and_ : node
(** Compare *)
val compare : node
(** Set/Map *)
val empty_set : node
val update_set : node
val size_set : node
val iter_set : node list -> node
val mem_set : node
val empty_map : node
val update_map : node
val size_map : node
val iter_map : node list -> node
val map_map : node list -> node
val get_map : node
val mem_map : node
(** Lists *)
val nil : node
val cons : node
val size_list : node
val iter_list : node list -> node
val map_list : node list -> node
(** Strings/bytes *)
val concat : node
val size_string : node
val size_bytes : node
(** Lambdas *)
val lambda : node list -> node
val exec : node
val apply : node
(** pack/unpack *)
val pack : node
val unpack : node
(** Hole *)
val hole : node
end
(** data *)
module Data : sig
val unit : node
val false_ : node
val true_ : node
val none : node
val some : node -> node
val pair : node -> node -> node
val left : node -> node
val right : node -> node
val list : node list -> node
val set : node list -> node
val map_elt : node -> node -> node
val map : node list -> node
val timestamp : Alpha_context.Script_timestamp.t -> node
val mutez : Alpha_context.Tez.t -> node
val key_hash : Tezos_crypto.Signature.Public_key_hash.t -> node
val key : Tezos_crypto.Signature.Public_key.t -> node
val integer : int -> node
val natural : int -> node
val big_integer : Z.t -> node
val big_natural : Z.t -> node
val string : string -> node
val bytes : Bytes.t -> node
val lambda : node list -> node
val hole : node
end
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2021 Nomadic Labs, <contact@nomadic-labs.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
spec.ml |
open Core;;
open Json_schema;;
type contact_object = {
name : string option [@yojson.option];
url : string option [@yojson.option];
email : string option [@yojson.option];
} [@@deriving make,show,yojson];;
type license_object = {
name : string;
url : string option [@yojson.option];
} [@@deriving make,show,yojson];;
type server_variable_object = {
enum : string list option [@yojson.option];
default : string;
description : string option [@yojson.option];
} [@@deriving make,show,yojson];;
type external_documentation_object = {
description : string option [@yojson.option];
url : string;
} [@@deriving make,show,yojson];;
type server_object = {
url : string;
description : string option [@yojson.option];
variables : server_variable_object map option
[@yojson.option]
} [@@deriving make,show,yojson];;
type link_object = {
operation_ref : string option [@key "operationRef"]
[@yojson.option];
operation_id : string option [@key "operationId"]
[@yojson.option];
parameters : any map option [@yojson.option];
request_body : any option [@key "requestBody"]
[@yojson.option];
description : string option [@yojson.option];
server : server_object option [@yojson.option];
} [@@deriving make,show,yojson];;
type header_object = {
description : string option
[@yojson.option];
required : bool option
[@yojson.option];
deprecated : bool option
[@yojson.option];
allow_empty_value : bool option [@key "allowEmptyValue"]
[@yojson.option];
} [@@deriving make,show,yojson];;
type example_object = {
summary : string option
[@yojson.option];
description : string option
[@yojson.option];
value : any option
[@yojson.option];
externalValue : string option
[@yojson.option];
} [@@deriving make, show, yojson];;
type media_type_object = {
schema : schema or_ref option [@yojson.option];
example : any option [@yojson.option];
examples : example_object or_ref map option [@yojson.option];
encoding : any map option [@yojson.option] (* fixme: should be an encoding_object map *)
} [@@deriving make, show, yojson];;
type response_object = {
description : string;
headers : header_object or_ref map option
[@yojson.option];
content : media_type_object map option
[@yojson.option];
links : link_object or_ref map option
[@yojson.option];
} [@@deriving make,show,yojson];;
type responses_object = response_object or_ref map [@@deriving show, yojson];;
type parameter_location = Query | Header | Path | Cookie [@@deriving show,yojson];;
let parameter_location_of_yojson = function
| `String "query" -> Query
| `String "header" -> Header
| `String "path" -> Path
| `String "cookie" -> Cookie
| x -> let open Ppx_yojson_conv_lib.Yojson_conv in
raise (Of_yojson_error
(Failure (sprintf "%s: unexpected value must be \"query\", \"header\", \"path\", or \"cookie\"" __LOC__), x));;
let yojson_of_parameter_location = function
| Query -> `String "query"
| Header -> `String "header"
| Path -> `String "path"
| Cookie -> `String "cookie"
type parameter_style = Simple | Form [@@deriving show];;
let parameter_style_of_yojson = function
| `String "simple" -> Simple
| `String "form" -> Form
| x -> let open Ppx_yojson_conv_lib.Yojson_conv in
raise (Of_yojson_error (Failure (sprintf "%s: unexpected value must be \"simple\" or \"form\"" __LOC__), x));;
;;
let yojson_of_parameter_style = function
| Simple -> `String "simple"
| Form -> `String "form"
type parameter_object = {
name : string;
in_ : parameter_location [@key "in"];
description : string option
[@yojson.option];
required : bool option
[@yojson.option];
deprecated : bool option
[@yojson.option];
allow_empty_value : bool option [@key "allowEmptyValue"]
[@yojson.option];
style : parameter_style option [@yojson.option];
schema : schema or_ref option [@yojson.option];
example : any option [@yojson.option]
} [@@deriving make,show,yojson];;
type request_body_object = {
description : string option [@yojson.option];
content : media_type_object map;
required : bool option [@yojson.option]
} [@@deriving make,show,yojson];;
type security_scheme_object = {
(* Note: these aren't actually all optional, which one is required
depends on the type field. Should probably use a union type
with custom json converters *)
type_ : string [@key "type"];
description : string option
[@yojson.option];
name : string option
[@yojson.option];
in_ : string option
[@key"in"] [@yojson.option];
scheme : string option
[@yojson.option];
bearer_format : string option
[@key "bearerFormat"] [@yojson.option];
(* FIXME: actually define Oauth Flows Object Type *)
flows : any option
[@yojson.option];
openid_connect_url : string option
[@key "openIdConnectUrl"] [@yojson.option]
} [@@deriving make,show,yojson];;
(* FIXME: define an actual type for this *)
type callback_object = any [@@deriving show,yojson];;
type components_object = {
schemas : schema or_ref map option
[@yojson.option];
responses : response_object or_ref map option
[@yojson.option];
parameters : parameter_object or_ref map option
[@yojson.option];
examples : example_object or_ref map option
[@yojson.option];
request_bodies : request_body_object or_ref map option
[@key "requestBodies"] [@yojson.option];
headers : header_object or_ref map option
[@yojson.option];
security_schemes : security_scheme_object or_ref map option
[@key "securitySchemes"] [@yojson.option];
links : link_object or_ref map option
[@yojson.option];
callbacks : callback_object or_ref map option
[@yojson.option];
} [@@deriving make,show,yojson];;
type info_object = {
title : string;
description : string option [@yojson.option];
terms_of_service : string option [@key "termsOfService"] [@yojson.option];
contact : contact_object option [@yojson.option];
license : license_object option [@yojson.option];
version : string;
} [@@deriving make,show,yojson];;
type operation_object = {
tags : string list option
[@yojson.option];
summary : string option
[@yojson.option];
description : string option
[@yojson.option];
external_docs : external_documentation_object option
[@key "externalDocs"] [@yojson.option];
operation_id : string option
[@key "operationId"] [@yojson.option];
parameters : parameter_object or_ref list option
[@yojson.option];
request_body : request_body_object or_ref option
[@key "requestBody"] [@yojson.option];
responses : responses_object;
callbacks : callback_object or_ref map option
[@yojson.option];
deprecated : bool option
[@yojson.option];
(* FIXME: add a type for security_requirement *)
security : any option
[@yojson.option];
servers : server_object list option
[@yojson.option];
} [@@deriving make,show,yojson];;
type path_object = {
summary : string option [@yojson.option];
description : string option [@yojson.option];
get : operation_object option [@yojson.option];
put : operation_object option [@yojson.option];
post : operation_object option [@yojson.option];
delete : operation_object option [@yojson.option];
options : operation_object option [@yojson.option];
head : operation_object option [@yojson.option];
patch : operation_object option [@yojson.option];
trace : operation_object option [@yojson.option];
servers : server_object list option [@yojson.option];
parameters : parameter_object or_ref list option [@yojson.option]
} [@@deriving make,show,yojson];;
type paths_object = path_object map [@@deriving yojson,show];;
type tag_object = {
name : string;
description : string option [@yojson.option];
external_docs : external_documentation_object option [@key "externalDocs"] [@yojson.option];
} [@@deriving make,show,yojson];;
type t = {
openapi : string;
info : info_object;
servers : server_object list option [@yojson.option];
paths : paths_object;
components : components_object option [@yojson.option];
security : any option [@yojson.option]; (* FIXME: define an actual type
for security_requirements_object *)
tags : tag_object list option [@yojson.option];
external_docs : external_documentation_object option [@key "externalDocs"] [@yojson.option]
} [@@deriving make,show,yojson];;
| (*
Copyright 2021/2022 Johns Hopkins University Applied Physics Laboratory
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*) |
prove_client.ml | let socket : Unix.file_descr option ref = ref None
exception NotConnected
exception AlreadyConnected
exception InvalidAnswer of string
exception ConnectionError of string
let is_connected () = !socket <> None
let client_connect ~fail socket_name =
if !socket <> None then raise AlreadyConnected;
try
let sock =
if Sys.os_type = "Win32" then
let name = "\\\\.\\pipe\\" ^ Filename.basename socket_name in
Unix.openfile name [Unix.O_RDWR] 0
else begin
let curdir = Sys.getcwd () in
let dir = Filename.dirname socket_name in
let fn = Filename.basename socket_name in
let sock = Unix.socket Unix.PF_UNIX Unix.SOCK_STREAM 0 in
try
Sys.chdir dir;
Unix.connect sock (Unix.ADDR_UNIX fn);
Sys.chdir curdir;
sock
with e ->
(* Make sure curdir is restored *)
let bt = Printexc.get_raw_backtrace () in
Sys.chdir curdir;
Printexc.raise_with_backtrace e bt
end
in
socket := Some sock
with
| Unix.Unix_error(err, func, arg) when fail ->
let s = Format.sprintf "client_connect: connection failed: %s (%s,%s) (socket_name=%s)@."
(Unix.error_message err) func arg socket_name in
raise (ConnectionError s)
| e when fail ->
let s = Format.sprintf "client_connect failed for some unexpected reason: %s@\nAborting.@."
(Printexc.to_string e) in
raise (ConnectionError s)
let client_disconnect () =
match !socket with
| None -> raise NotConnected
| Some sock ->
socket := None;
if Sys.os_type <> "Win32" then
Unix.shutdown sock Unix.SHUTDOWN_ALL;
Unix.close sock
let send_request_string msg =
match !socket with
| None -> raise NotConnected
| Some sock ->
let to_write = String.length msg in
let rec write pointer =
if pointer < to_write then
let written = Unix.write_substring sock msg pointer (to_write - pointer) in
write (pointer + written)
in write 0
let read_from_client =
let buf = Bytes.make 1024 ' ' in
fun blocking ->
match !socket with
| None -> raise NotConnected
| Some sock ->
(* we only call read() if we are allowed to block
or if the socket is ready *)
let do_read =
blocking ||
(let l,_,_ = Unix.select [sock] [] [] 0.0 in l <> [])
in
if do_read then
let read = Unix.read sock buf 0 1024 in
Bytes.sub_string buf 0 read
else ""
(* TODO/FIXME: should we be able to change this setting when
using an external server? *)
(* TODO/FIXME: this number should be stored server-side and
consulted via a protocol request, if ever needed. The only
reason for this reference to be here is to store the config
setting before the first connection request is issued. *)
let max_running_provers : int ref = ref 1
let set_max_running_provers x =
if x <= 0 then invalid_arg "Prove_client.set_max_running_provers";
max_running_provers := x;
if is_connected () then
send_request_string ("parallel;" ^ string_of_int x ^ "\n")
let send_buf : Buffer.t = Buffer.create 512
let recv_buf : Buffer.t = Buffer.create 1024
(* FIXME? should we send !max_running_provers once connected? *)
let connect_external socket_name =
if is_connected () then raise AlreadyConnected;
Buffer.clear recv_buf;
client_connect ~fail:true socket_name
let connect_internal libdir =
if is_connected () then raise AlreadyConnected;
Buffer.clear recv_buf;
let cwd = Unix.getcwd () in
Unix.chdir (Filename.get_temp_dir_name ());
let socket_name = (* Filename.concat (Unix.getcwd ())
("why3server." ^ string_of_int (Unix.getpid ()) ^ ".sock") *)
Filename.temp_file "why3server" "sock"
in
let exec = Filename.concat libdir "why3server" in
let pid =
(* use this version for debugging the C code
Unix.create_process "valgrind"
[|"/usr/bin/valgrind";exec; "--socket"; socket_name;
"--single-client";
"-j"; string_of_int !max_running_provers|]
Unix.stdin Unix.stdout Unix.stderr
*)
Unix.create_process exec
[|exec; "--socket"; socket_name;
"--single-client";
"-j"; string_of_int !max_running_provers|]
Unix.stdin Unix.stdout Unix.stderr
in
Unix.chdir cwd;
(* sleep before connecting, or the server will not be ready yet *)
let rec try_connect n d =
if n <= 0 then client_connect ~fail:true socket_name else
try client_connect ~fail:false socket_name with _ ->
ignore (Unix.select [] [] [] d);
try_connect (pred n) (d *. 4.0) in
try_connect 5 0.1; (* 0.1, 0.4, 1.6, 6.4, 25.6 *)
at_exit (fun () -> (* only if succesfully connected *)
(try client_disconnect () with NotConnected -> ());
ignore (Unix.waitpid [] pid))
(* TODO/FIXME: how should we handle disconnect if there are still
tasks in queue? What are the use cases for disconnect? *)
let disconnect = client_disconnect
(* TODO/FIXME: is this the right place to connect-on-demand? *)
let send_request ~libdir ~id ~timelimit ~memlimit ~use_stdin ~cmd =
if not (is_connected ()) then connect_internal libdir;
Buffer.clear send_buf;
let servercommand =
if use_stdin <> None then "runstdin;" else "run;" in
Buffer.add_string send_buf servercommand;
Buffer.add_string send_buf (string_of_int id);
Buffer.add_char send_buf ';';
Buffer.add_string send_buf (string_of_float timelimit);
Buffer.add_char send_buf ';';
Buffer.add_string send_buf (string_of_int memlimit);
List.iter (fun x ->
Buffer.add_char send_buf ';';
Buffer.add_string send_buf x)
cmd;
begin match use_stdin with
| None -> ()
| Some s ->
Buffer.add_char send_buf ';';
Buffer.add_string send_buf s
end;
Buffer.add_char send_buf '\n';
let s = Buffer.contents send_buf in
send_request_string s
let send_interrupt ~libdir ~id =
if not (is_connected ()) then connect_internal libdir;
Buffer.clear send_buf;
Buffer.add_string send_buf "interrupt;";
Buffer.add_string send_buf (string_of_int id);
Buffer.add_char send_buf '\n';
let s = Buffer.contents send_buf in
send_request_string s
let rec read_lines blocking =
let s = read_from_client blocking in
(* TODO: should we detect and handle EOF here? *)
if s = "" then [] else
if String.contains s '\n' then begin
let s = Buffer.contents recv_buf ^ s in
Buffer.clear recv_buf;
let l = Strings.rev_split '\n' s in
match l with
| [] -> assert false
| [x] -> [x]
| (x::xs) as l ->
if x = "" then List.rev xs else
if x.[String.length x - 1] = '\n' then List.rev l
else begin
Buffer.add_string recv_buf x;
List.rev xs
end
end else begin
Buffer.add_string recv_buf s;
read_lines blocking
end
type final_answer = {
id : int;
time : float;
timeout : bool;
out_file : string;
exit_code : int64;
}
type answer =
| Started of int
| Finished of final_answer
let read_answer s =
try
match Strings.split ';' s with
| "F":: id :: exit_s :: time_s :: timeout_s :: ( (_ :: _) as rest) ->
(* same trick we use in other parsing code. The file name may contain
';'. Luckily, the file name comes last, so we still split on ';',
and put the pieces back together afterwards *)
Finished { id = int_of_string id;
out_file = Strings.join ";" rest;
time = float_of_string time_s;
exit_code = Int64.of_string exit_s;
timeout = (timeout_s = "1"); }
| "S" :: [id] ->
Started (int_of_string id)
| _ ->
raise (InvalidAnswer s)
with Failure "int_of_string" ->
raise (InvalidAnswer s)
let read_answers ~blocking =
List.map read_answer (List.filter (fun x -> x <> "") (read_lines blocking))
let () = Exn_printer.register (fun fmt exn -> match exn with
| NotConnected ->
Format.pp_print_string fmt "Not connected to the proof server"
| AlreadyConnected ->
Format.pp_print_string fmt "Already connected to the proof server"
| InvalidAnswer s ->
Format.fprintf fmt "Invalid server answer: %s" s
| ConnectionError s ->
Format.fprintf fmt "Connection error: %s" s
| _ -> raise exn)
| (********************************************************************)
(* *)
(* The Why3 Verification Platform / The Why3 Development Team *)
(* Copyright 2010-2023 -- Inria - CNRS - Paris-Saclay University *)
(* *)
(* This software is distributed under the terms of the GNU Lesser *)
(* General Public License version 2.1, with the special exception *)
(* on linking described in file LICENSE. *)
(* *)
(********************************************************************)
|
dune |
(env
(dev
(flags (:standard -warn-error -A)))) | |
collated_intf.ml |
open Core
module Which_range = Collate.Which_range
module type Parametrized = sig
(** The result of collation - a filtered, sorted and restricted-to-a-range list of keys
and values. The underlying data structure is a bit more sophisticated than a list,
to provide better diffing.
To get an implementation of [Diffable] interface, you'll need to instantiate
[Make_concrete].
*)
type ('k, 'v) t [@@deriving sexp, bin_io, compare, equal]
val empty : _ t
val fold : ('k, 'v) t -> init:'accum -> f:('accum -> 'k * 'v -> 'accum) -> 'accum
val iter : ('k, 'v) t -> f:('k * 'v -> unit) -> unit
val to_alist : ('k, 'v) t -> ('k * 'v) list
val to_map_list : ('k, 'v) t -> ('k * 'v) Map_list.t
val first : ('k, 'v) t -> ('k * 'v) option
val last : ('k, 'v) t -> ('k * 'v) option
val mapi : ('k, 'v1) t -> f:('k -> 'v1 -> 'v2) -> ('k, 'v2) t
val length : _ t -> int
(** Total number of rows before filtering *)
val num_unfiltered_rows : _ t -> int
(** Total number of rows after filtering, but before limiting to range. *)
val num_filtered_rows : _ t -> int
(** Total number of rows that preceed the rank-range and key-range ranges. *)
val num_before_range : _ t -> int
(** Total number of rows that follow the rank-range and key-range ranges. *)
val num_after_range : _ t -> int
(** The key range this result was computed for *)
val key_range : ('k, _) t -> 'k Which_range.t
(** The rank range this result was computed for *)
val rank_range : _ t -> int Which_range.t
module Private : sig
val create
: data:('k * 'v) Int63.Map.t
-> num_filtered_rows:int
-> key_range:'k Which_range.t
-> rank_range:int Which_range.t
-> num_before_range:int
-> num_unfiltered_rows:int
-> ('k, 'v) t
end
module For_testing : sig
(** Create Collated.t of a list of data. Note: no collation or checks are performed,
it will contain exactly the data you provided *)
val of_list
: num_filtered_rows:int
-> key_range:'k Which_range.t
-> rank_range:int Which_range.t
-> num_before_range:int
-> num_unfiltered_rows:int
-> ('k * 'v) list
-> ('k, 'v) t
end
end
module type Bin_comp_sexp = sig
type t [@@deriving bin_io, sexp, compare, equal]
end
module type Concrete = sig
module Key : Bin_comp_sexp
module Value : Bin_comp_sexp
type ('k, 'v) parametrized
type t = (Key.t, Value.t) parametrized [@@deriving sexp, bin_io, compare, equal]
val empty : t
val fold : t -> init:'accum -> f:('accum -> Key.t * Value.t -> 'accum) -> 'accum
val iter : t -> f:(Key.t * Value.t -> unit) -> unit
val to_alist : t -> (Key.t * Value.t) list
val to_map_list : t -> (Key.t * Value.t) Map_list.t
val first : t -> (Key.t * Value.t) option
val last : t -> (Key.t * Value.t) option
val length : t -> int
val num_filtered_rows : t -> int
val num_unfiltered_rows : t -> int
val key_range : t -> Key.t Which_range.t
val rank_range : t -> int Which_range.t
include Diffable.S with type t := t
include Streamable.S with type t := t
val find_by_key : t -> Key.t -> Value.t option
val prev : t -> Key.t -> (Key.t * Value.t) option
val next : t -> Key.t -> (Key.t * Value.t) option
end
module type Collated = sig
include Parametrized
module type Concrete = Concrete with type ('k, 'v) parametrized = ('k, 'v) t
module Make_concrete (Key : Bin_comp_sexp) (Value : Bin_comp_sexp) :
Concrete with type Key.t = Key.t and type Value.t = Value.t
end
| |
Output_from_core_j.ml | (* TODO: when ATD will gets its module system we will not need this anymore *)
include Semgrep_output_v1_j
| (* TODO: when ATD will gets its module system we will not need this anymore *)
include Semgrep_output_v1_j |
snapshots.mli | (** Snapshots for the store
Snapshots are canonical representations of the store and its
associated context. Its main purposes it to save and load a
current state with the minimal necessary amount of
information. This snapshot may also be shared by third parties to
facilitate the bootstrap process.
A snapshot of a block [B] is composed of :
- The snapshot format version (see [version]), as a file;
- The metadata of the snapshot (see [metadata]), as a file;
- Some data to ensure snapshot consistency at import (see
[block_data]), as a file;
- A single context containing every key that the block [B-1] needs
(see below), as a file;
- The set of (cemented and floating) blocks and their operations
from the genesis block up to [B] -- it might contain less blocks
if the snapshot is created from a store using a [Rolling]
history mode of if it is created as a [Rolling]
snapshot. Block's metadata are not exported. The cemented blocks
are exported as a directory containing cycles as files, as well
as some indexing data. The floating blocks are stored as a
single file ;
- The set of necessary Tezos protocols, as a directory containing
the protocols as single files.
There are two kinds of snapshot formats that can be exported:
- [Raw] is a directory containing the aforementioned data as
independent files;
- [Tar] is a tar archive containing all the data as a single
archive file. To achieve better performances while loading the
snapshot's information (version and metadata), we store first the
version and then the metadata, to avoid seeking through the whole
file.
Importing a snapshot will initialize a fresh store with the data
contained in the snapshot. As snapshots may be shared between
users, checks are made to ensure that no malicious data is
loaded. For instance, we export the context of block [B-1] to make
sure that the application of the block [B], given its
predecessor's context, is valid.
Depending on the history mode, a snapshot might contain less
blocks. In full, all blocks are present and importing such a
snapshot will populate the {!Cemented_store} with every cycle up
to the snapshot's target block. Meanwhile, in [Rolling], only a
few previous blocks will be exported ([max_op_ttl] from the target
block), only populating a {!Floating_block_store}. Thus, the
snapshot size greatly differs depending on the history mode used.
Snapshots may be created concurrently with a running node. It
might impact the node for a few seconds to retrieve the necessary
consistent information to produce the snapshot.
*)
open Store_types
type error +=
| Incompatible_history_mode of {
requested : History_mode.t;
stored : History_mode.t;
}
| Invalid_export_block of {
block : Block_hash.t option;
reason :
[ `Pruned
| `Pruned_pred
| `Unknown
| `Unknown_ancestor
| `Caboose
| `Genesis
| `Not_enough_pred ];
}
| Invalid_export_path of string
| Snapshot_file_not_found of string
| Inconsistent_protocol_hash of {
expected : Protocol_hash.t;
got : Protocol_hash.t;
}
| Inconsistent_context_hash of {
expected : Context_hash.t;
got : Context_hash.t;
}
| Inconsistent_context of Context_hash.t
| Cannot_decode_protocol of Protocol_hash.t
| Cannot_write_metadata of string
| Cannot_read of {
kind :
[ `Version
| `Metadata
| `Block_data
| `Context
| `Protocol_table
| `Protocol
| `Cemented_cycle ];
path : string;
}
| Inconsistent_floating_store of block_descriptor * block_descriptor
| Missing_target_block of block_descriptor
| Cannot_read_floating_store of string
| Cannot_retrieve_block_interval
| Invalid_cemented_file of string
| Missing_cemented_file of string
| Corrupted_floating_store
| Invalid_protocol_file of string
| Target_block_validation_failed of Block_hash.t * string
| Directory_already_exists of string
| Empty_floating_store
| Cannot_remove_tmp_export_directory of string
| Inconsistent_chain_import of {
expected : Distributed_db_version.Name.t;
got : Distributed_db_version.Name.t;
}
| Inconsistent_imported_block of Block_hash.t * Block_hash.t
| Wrong_snapshot_file of {filename : string}
type snapshot_format = Tar | Raw
val pp_snapshot_format : Format.formatter -> snapshot_format -> unit
val snapshot_format_encoding : snapshot_format Data_encoding.t
module Snapshot_header : sig
type t
(** Pretty-printer of a snapshot's {!header} *)
val pp : Format.formatter -> t -> unit
val to_json : t -> Data_encoding.json
(** [version snapshot_header] returns the version of a given
[snapshot_header] as an integer value. *)
val get_version : t -> int
end
(** [read_snapshot_header ~snapshot_path] reads [snapshot_file]'s
header. *)
val read_snapshot_header :
snapshot_path:string -> Snapshot_header.t tzresult Lwt.t
(** [export ?snapshot_path snapshot_format ?rolling ~block ~store_dir
~context_dir ~chain_name genesis ~progress_display_mode] reads
from the [store_dir] and [context_dir] the current state of the
node and produces a snapshot, of the given [snapshot_format], in
[snapshot_file] if it is provided. Otherwise, a snapshot file name
is automatically generated using the target block as hint. If
[rolling] is set, only the necessary blocks will be exported. *)
val export :
?snapshot_path:string ->
snapshot_format ->
?rolling:bool ->
block:Block_services.block ->
store_dir:string ->
context_dir:string ->
chain_name:Distributed_db_version.Name.t ->
progress_display_mode:Animation.progress_display_mode ->
Genesis.t ->
unit tzresult Lwt.t
(** [import ~snapshot_path ?patch_context ?block ?check_consistency
~dst_store_dir ~dst_context_dir chain_name
~user_activated_upgrades ~user_activated_protocol_overrides
~ops_metadata_size_limit genesis] populates [dst_store_dir] and
[dst_context_dir] with the data contained in the
[snapshot_file]. If [check_consistency] is unset, less security
checks will be made and the import process will be more
efficient. If [block] is set, the import process will make sure
that the block is the correct one we load. [patch_context],
[user_activated_upgrades] and [user_activated_protocol_overrides]
are passed to the validator in order to validate the target
block. [ops_metadata_size_limit] determines the maximal size of
the metadata to store while importing a snapshot. *)
val import :
snapshot_path:string ->
?patch_context:
(Tezos_protocol_environment.Context.t ->
Tezos_protocol_environment.Context.t tzresult Lwt.t) ->
?block:Block_hash.t ->
?check_consistency:bool ->
dst_store_dir:string ->
dst_context_dir:string ->
chain_name:Distributed_db_version.Name.t ->
configured_history_mode:History_mode.t option ->
user_activated_upgrades:User_activated.upgrades ->
user_activated_protocol_overrides:User_activated.protocol_overrides ->
operation_metadata_size_limit:Shell_limits.operation_metadata_size_limit ->
progress_display_mode:Animation.progress_display_mode ->
Genesis.t ->
unit tzresult Lwt.t
(** [snapshot_file_kind ~snapshot_file] reads the [snapshot_file] and
returns its kind. Returns [Invalid] if it is a wrong snapshot
file. *)
val snapshot_file_kind : snapshot_path:string -> snapshot_format tzresult Lwt.t
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2020-2021 Nomadic Labs, <contact@nomadic-labs.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
main_tx_rollup_node_015_PtLimaPt.ml | let force_switch =
Tezos_clic.switch
~long:"force"
~doc:"Overwrites the configuration file when it exists."
()
let data_dir_doc =
Format.sprintf "The directory path to the transaction rollup node data."
let rpc_addr_doc =
Format.asprintf
"The address and port where the node listens to RPCs. The default is %s"
let reconnection_delay_doc =
Format.asprintf
"The reconnection delay when the connection is lost. The default delay is \
%f"
let data_dir_arg =
let doc = data_dir_doc in
Tezos_clic.arg
~long:"data-dir"
~placeholder:"data_dir"
~doc
Client_proto_args.string_parameter
let operator_arg =
Client_keys_v0.Public_key_hash.source_arg
~long:"operator"
~placeholder:"operator"
~doc:"The operator of the rollup"
()
let batch_signer_arg =
Client_keys_v0.Public_key_hash.source_arg
~long:"batch-signer"
~placeholder:"batch-signer"
~doc:"The signer for submission of batches"
()
let finalize_commitment_signer_arg =
Client_keys_v0.Public_key_hash.source_arg
~long:"finalize-commitment-signer"
~placeholder:"finalize-commitment-signer"
~doc:"The signer for finalization of commitments"
()
let remove_commitment_signer_arg =
Client_keys_v0.Public_key_hash.source_arg
~long:"remove-commitment-signer"
~placeholder:"remove-commitment-signer"
~doc:"The signer for removals of commitments"
()
let rejection_signer_arg =
Client_keys_v0.Public_key_hash.source_arg
~long:"rejection-signer"
~placeholder:"rejection-signer"
~doc:"The signer for rejections"
()
let dispatch_withdrawals_signer_arg =
Client_keys_v0.Public_key_hash.source_arg
~long:"dispatch-withdrawals-signer"
~placeholder:"dispatch-withdrawals-signer"
~doc:"The signer for dispatch withdrawals"
()
let rollup_id_param =
let open Client_proto_rollups in
Tezos_clic.parameter ~autocomplete:TxRollupAlias.autocomplete (fun cctxt s ->
let from_alias s = TxRollupAlias.find cctxt s in
let from_key s = TxRollupAlias.of_source s in
Client_aliases.parse_alternatives
[("alias", from_alias); ("key", from_key)]
s)
let origination_level_arg =
Tezos_clic.arg
~long:"origination-level"
~placeholder:"origination_level"
~doc:"The level of the block where the rollup was originated"
(Tezos_clic.parameter (fun _ str ->
match Int32.of_string_opt str with
| None -> failwith "Invalid origination level"
| Some l -> return l))
let rpc_addr_arg =
let default = P2p_point.Id.to_string Node_config.default_rpc_addr in
let doc = rpc_addr_doc default in
Tezos_clic.arg
~long:"rpc-addr"
~placeholder:"address:port"
~doc
(Tezos_clic.parameter (fun _ s ->
P2p_point.Id.of_string s
|> Result.map_error (fun e -> [Exn (Failure e)])
|> Lwt.return))
let rpc_addr_opt_arg =
let default = P2p_point.Id.to_string Node_config.default_rpc_addr in
let doc = rpc_addr_doc default in
Tezos_clic.arg
~long:"rpc-addr"
~placeholder:"address:port"
~doc
(Tezos_clic.parameter (fun _ s ->
P2p_point.Id.of_string s
|> Result.map_error (fun e -> [Exn (Failure e)])
|> Lwt.return))
let cors_origins_arg =
Tezos_clic.arg
~doc:
"CORS origins allowed by the RPC server via Access-Control-Allow-Origin"
~placeholder:"c1, c2, ..."
~long:"cors-origins"
@@ Tezos_clic.parameter (fun _ctxt s ->
String.split_no_empty ',' s |> List.map String.trim |> return)
let cors_headers_arg =
Tezos_clic.arg
~doc:
"Header reported by Access-Control-Allow-Headers reported during CORS \
preflighting"
~placeholder:"h1, h2, ..."
~long:"cors-headers"
@@ Tezos_clic.parameter (fun _ctxt s ->
String.split_no_empty ',' s |> List.map String.trim |> return)
let reconnection_delay_arg =
let default = Node_config.default_reconnection_delay in
let doc = reconnection_delay_doc default in
Tezos_clic.arg
~long:"reconnection-delay"
~placeholder:"delay"
~doc
(Tezos_clic.parameter (fun _ p ->
try return (float_of_string p) with _ -> failwith "Cannot read float"))
let possible_modes = List.map Node_config.string_of_mode Node_config.modes
let mode_parameter =
Tezos_clic.parameter
~autocomplete:(fun _ -> return possible_modes)
(fun _ m -> Lwt.return (Node_config.mode_of_string m))
let mode_param =
Tezos_clic.param
~name:"mode"
~desc:
(Printf.sprintf
"The mode for the rollup node (%s)"
(String.concat ", " possible_modes))
mode_parameter
let allow_deposit_arg =
Tezos_clic.switch
~doc:"Allow the operator to make a first deposit for commitments"
~long:"allow-deposit"
()
let group =
Tezos_clic.
{
name = "tx_rollup.node";
title = "Commands related to the transaction rollup node";
}
let config_from_args data_dir (rollup_id : Client_proto_rollups.TxRollupAlias.t)
mode operator batch_signer finalize_commitment_signer
remove_commitment_signer rejection_signer dispatch_withdrawals_signer
origination_level rpc_addr cors_origins cors_headers allow_deposit
reconnection_delay =
let open Lwt_syntax in
let origination_level =
Option.either rollup_id.origination_level origination_level
in
let rollup_id = rollup_id.rollup in
let+ data_dir =
match data_dir with
| Some d -> return d
| None -> Node_config.default_data_dir rollup_id
in
let rpc_addr = Option.value rpc_addr ~default:Node_config.default_rpc_addr in
let reconnection_delay =
Option.value
reconnection_delay
~default:Node_config.default_reconnection_delay
in
Node_config.
{
data_dir;
mode;
signers =
{
operator;
submit_batch = batch_signer;
finalize_commitment = finalize_commitment_signer;
remove_commitment = remove_commitment_signer;
rejection = rejection_signer;
dispatch_withdrawals = dispatch_withdrawals_signer;
};
rollup_id;
origination_level;
rpc_addr;
cors_origins = Option.value cors_origins ~default:[];
cors_headers = Option.value cors_headers ~default:[];
reconnection_delay;
allow_deposit;
l2_blocks_cache_size = default_l2_blocks_cache_size;
caps = default_caps;
batch_burn_limit = None;
}
let patch_config_from_args config
(rollup_id : Client_proto_rollups.TxRollupAlias.t) mode operator
batch_signer finalize_commitment_signer remove_commitment_signer
rejection_signer dispatch_withdrawals_signer origination_level rpc_addr
cors_origins cors_headers allow_deposit reconnection_delay =
let origination_level =
Option.either rollup_id.origination_level origination_level
in
let rollup_id = rollup_id.rollup in
if
Protocol.Alpha_context.Tx_rollup.(rollup_id <> config.Node_config.rollup_id)
then
error_with
"Rollup node is configured for rollup %a but asked to run for rollup %a"
Protocol.Alpha_context.Tx_rollup.pp
config.Node_config.rollup_id
Protocol.Alpha_context.Tx_rollup.pp
rollup_id
else
let operator = Option.either operator config.signers.operator in
let submit_batch = Option.either batch_signer config.signers.submit_batch in
let finalize_commitment =
Option.either
finalize_commitment_signer
config.signers.finalize_commitment
in
let remove_commitment =
Option.either remove_commitment_signer config.signers.remove_commitment
in
let dispatch_withdrawals =
Option.either
dispatch_withdrawals_signer
config.signers.dispatch_withdrawals
in
let rejection = Option.either rejection_signer config.signers.rejection in
let signers =
{
Node_config.operator;
submit_batch;
finalize_commitment;
remove_commitment;
dispatch_withdrawals;
rejection;
}
in
let origination_level =
Option.either origination_level config.origination_level
in
let rpc_addr = Option.value rpc_addr ~default:config.rpc_addr in
let cors_origins = Option.value cors_origins ~default:config.cors_origins in
let cors_headers = Option.value cors_headers ~default:config.cors_headers in
let reconnection_delay =
Option.value reconnection_delay ~default:config.reconnection_delay
in
let allow_deposit = allow_deposit || config.allow_deposit in
let config =
{
config with
mode;
signers;
origination_level;
rpc_addr;
cors_origins;
cors_headers;
reconnection_delay;
allow_deposit;
}
in
ok config
let configuration_init_command =
let open Tezos_clic in
command
~group
~desc:"Configure the transaction rollup daemon."
(args14
force_switch
data_dir_arg
operator_arg
batch_signer_arg
finalize_commitment_signer_arg
remove_commitment_signer_arg
rejection_signer_arg
dispatch_withdrawals_signer_arg
origination_level_arg
rpc_addr_arg
cors_origins_arg
cors_headers_arg
allow_deposit_arg
reconnection_delay_arg)
(prefix "init" @@ mode_param
@@ prefixes ["config"; "for"]
@@ Tezos_clic.param
~name:"rollup-id"
~desc:"address of the rollup"
rollup_id_param
@@ stop)
(fun ( force,
data_dir,
operator,
batch_signer,
finalize_commitment_signer,
remove_commitment_signer,
rejection_signer,
dispatch_withdrawals_signer,
origination_level,
rpc_addr,
cors_origins,
cors_headers,
allow_deposit,
reconnection_delay )
mode
rollup_id
cctxt ->
let open Lwt_result_syntax in
let*! () = Event.(emit preamble_warning) () in
let*! config =
config_from_args
data_dir
rollup_id
mode
operator
batch_signer
finalize_commitment_signer
remove_commitment_signer
rejection_signer
dispatch_withdrawals_signer
origination_level
rpc_addr
cors_origins
cors_headers
allow_deposit
reconnection_delay
in
let*? config = Node_config.check_mode config in
let* file = Node_config.save ~force config in
(* This is necessary because the node has not yet been launched, so event
listening can't be used. *)
let*! () = cctxt#message "Configuration written in %s" file in
let*! () = Event.(emit configuration_was_written) file in
return_unit)
let run_command =
let open Lwt_result_syntax in
let open Tezos_clic in
command
~group
~desc:"Run the transaction rollup daemon."
(args13
data_dir_arg
operator_arg
batch_signer_arg
finalize_commitment_signer_arg
remove_commitment_signer_arg
rejection_signer_arg
dispatch_withdrawals_signer_arg
origination_level_arg
rpc_addr_opt_arg
cors_origins_arg
cors_headers_arg
allow_deposit_arg
reconnection_delay_arg)
(prefix "run" @@ mode_param @@ prefix "for"
@@ Tezos_clic.param
~name:"rollup-id"
~desc:"address of the rollup"
rollup_id_param
@@ stop)
(fun ( data_dir,
operator,
batch_signer,
finalize_commitment_signer,
remove_commitment_signer,
rejection_signer,
dispatch_withdrawals_signer,
origination_level,
rpc_addr,
cors_origins,
cors_headers,
allow_deposit,
reconnection_delay )
mode
rollup_id
cctxt ->
let*! () = Event.(emit preamble_warning) () in
let*! config_from_args =
config_from_args
data_dir
rollup_id
mode
operator
batch_signer
finalize_commitment_signer
remove_commitment_signer
rejection_signer
dispatch_withdrawals_signer
origination_level
rpc_addr
cors_origins
cors_headers
allow_deposit
reconnection_delay
in
let* config =
match data_dir with
| None -> return config_from_args
| Some data_dir -> (
let*! disk_config = Node_config.load ~data_dir in
match disk_config with
| Error (Error.Tx_rollup_configuration_file_does_not_exists _ :: _)
->
return config_from_args
| Error _ as err -> Lwt.return err
| Ok config ->
let*? config =
patch_config_from_args
config
rollup_id
mode
operator
batch_signer
finalize_commitment_signer
remove_commitment_signer
rejection_signer
dispatch_withdrawals_signer
origination_level
rpc_addr
cors_origins
cors_headers
allow_deposit
reconnection_delay
in
return config)
in
let*? config = Node_config.check_mode config in
Daemon.run config cctxt)
let tx_rollup_commands () =
List.map
(Tezos_clic.map_command (new Protocol_client_context.wrap_full))
[configuration_init_command; run_command]
let select_commands _ _ = return (tx_rollup_commands ())
let () = Client_main_run.run (module Daemon_config) ~select_commands
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2022 Nomadic Labs, <contact@nomadic-labs.com> *)
(* Copyright (c) 2022 Marigold, <contact@marigold.dev> *)
(* Copyright (c) 2022 Oxhead Alpha <info@oxhead-alpha.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
uniondecl.ml | (* $Id: uniondecl.ml,v 1.16 2002-01-16 09:42:04 xleroy Exp $ *)
(* Handling of union declarations *)
open Printf
open Utils
open Variables
open Idltypes
open Cvttyp
open Cvtval
open Union
(* Convert an IDL union declaration to an ML datatype declaration *)
let ml_declaration oc ud =
if ud.ud_name = ""
then fprintf oc "union_%d =\n" ud.ud_stamp
else fprintf oc "%s =\n" (String.uncapitalize_ascii ud.ud_name);
let out_constr oc c =
if c = "default" then
if ud.ud_name <> ""
then fprintf oc "Default_%s" ud.ud_name
else fprintf oc "Default_%d" ud.ud_stamp
else
output_string oc (String.capitalize_ascii c) in
let emit_case = function
{case_labels = []; case_field = None} -> (* default case, no arg *)
fprintf oc " | %a of int\n" out_constr "default"
| {case_labels = []; case_field = Some f} -> (* default case, one arg *)
fprintf oc " | %a of int * %a\n"
out_constr "default" out_ml_type f.field_typ
| {case_labels = lbls; case_field = None} -> (* named cases, no args *)
List.iter
(fun lbl -> fprintf oc " | %a\n" out_constr lbl)
lbls
| {case_labels = lbls; case_field = Some f} -> (* named cases, one arg *)
List.iter
(fun lbl ->
fprintf oc " | %a of %a\n" out_constr lbl out_ml_type f.field_typ)
lbls in
List.iter emit_case ud.ud_cases
(* Convert an IDL union declaration to a C union declaration *)
let c_declaration oc ud =
if ud.ud_cases = []
then fprintf oc "union %s;\n" ud.ud_name
else begin out_union oc ud; fprintf oc ";\n\n" end
(* External (forward) declaration of the translation functions *)
let declare_transl oc ud =
fprintf oc "extern int camlidl_ml2c_%s_union_%s(value, union %s *, camlidl_ctx _ctx);\n"
ud.ud_mod ud.ud_name ud.ud_name;
fprintf oc "extern value camlidl_c2ml_%s_union_%s(int, union %s *, camlidl_ctx _ctx);\n\n"
ud.ud_mod ud.ud_name ud.ud_name
(* Translation function from an ML datatype to a C union *)
let transl_ml_to_c oc ud =
current_function := sprintf "union %s" ud.ud_name;
let v = new_var "_v" in
let c = new_var "_c" in
fprintf oc "int camlidl_ml2c_%s_union_%s(value %s, union %s * %s, camlidl_ctx _ctx)\n"
ud.ud_mod ud.ud_name v ud.ud_name c;
fprintf oc "{\n";
let pc = divert_output() in
increase_indent();
let discr = new_c_variable (Type_int(Int, Iunboxed)) in
iprintf pc "%s = -1;\n" discr; (* keeps gcc happy *)
union_ml_to_c ml_to_c pc false Prefix.empty ud v (sprintf "(*%s)" c) discr;
iprintf pc "return %s;\n" discr;
output_variable_declarations oc;
end_diversion oc;
decrease_indent();
fprintf oc "}\n\n";
current_function := ""
(* Translation function from a C union to an ML datatype *)
let transl_c_to_ml oc ud =
current_function := sprintf "union %s" ud.ud_name;
let discr = new_var "_discr" in
let c = new_var "_c" in
fprintf oc "value camlidl_c2ml_%s_union_%s(int %s, union %s * %s, camlidl_ctx _ctx)\n"
ud.ud_mod ud.ud_name discr ud.ud_name c;
fprintf oc "{\n";
let pc = divert_output() in
increase_indent();
let v = new_ml_variable() in
union_c_to_ml c_to_ml pc Prefix.empty ud (sprintf "(*%s)" c) v discr;
iprintf pc "return %s;\n" v;
output_variable_declarations oc;
end_diversion oc;
decrease_indent();
fprintf oc "}\n\n";
current_function := ""
(* Emit the translation functions *)
let emit_transl oc ud =
transl_ml_to_c oc ud;
transl_c_to_ml oc ud
| (***********************************************************************)
(* *)
(* CamlIDL *)
(* *)
(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)
(* *)
(* Copyright 1999 Institut National de Recherche en Informatique et *)
(* en Automatique. All rights reserved. This file is distributed *)
(* under the terms of the GNU Lesser General Public License LGPL v2.1 *)
(* *)
(***********************************************************************)
|
bloomer.ml | type 'a t = {
hash : 'a -> bytes;
(** Cryptographically secure hash function. We must have
[Bytes.length (hash x) >= index_bits * hashes]. *)
hashes : int;
(** The value returned by [hash] is split and converted in
[hashes] indices, each [index_bits] wide. *)
index_bits : int;
(** [index_bits] is the width in bits of the indices into
the [filter]. *)
countdown_bits : int;
(** [countdown_bits] is the width in bits of the counter cells
stored in the [filter]. *)
filter : bytes;
(** [filter] stores [2^index_bits] counter cells,
each [countdown_bits] wide. *)
count : int array;
(** [count] stores approximate statistics on the number of counter cells
with a given value. [count.(i)] is the approximate number of cells
equal to [2^countdown_bits - 1 - i].
Note that this field is not required for Bloom filter operation. *)
}
let sf = Printf.sprintf
let check_peek_poke_args fname bytes ofs bits =
if bits <= 0 then invalid_arg (sf "Bloomer.%s: non positive bits value" fname) ;
if ofs < 0 then invalid_arg (sf "Bloomer.%s: negative offset" fname) ;
if bits > Sys.int_size - 7 then
invalid_arg (sf "Bloomer.%s: indexes out of bounds" fname) ;
if bits + ofs > Bytes.length bytes * 8 then
invalid_arg (sf "Bloomer.%s: indexes out of bounds" fname)
(* Read [bits] bits of [bytes] at offset [ofs] as an OCaml int in big endian order.
The function proceeds by iteratively blitting the bytes overlapping the sought
bit interval into [v]. The superfluous bits at the beginning and at the end
are then removed from [v], yielding the returned value.
*)
let peek_unsafe bytes ofs bits =
let first = ofs / 8 in
let last = first + (((ofs mod 8) + bits + 7) / 8) in
let v = ref 0 in
for i = last - 1 downto first do
v := (!v lsl 8) lor Char.code (Bytes.get bytes i)
done ;
v := !v lsr (ofs mod 8) ;
v := !v land ((1 lsl bits) - 1) ;
!v
let peek bytes ofs bits =
check_peek_poke_args "peek" bytes ofs bits ;
peek_unsafe bytes ofs bits
(* blits [bits] bits of [bytes] at offset [ofs] from an OCaml int in big endian order *)
let poke_unsafe bytes ofs bits v =
let first = ofs / 8 in
let last = first + (((ofs mod 8) + bits + 7) / 8) in
let cur = ref 0 in
for i = last - 1 downto first do
cur := (!cur lsl 8) lor Char.code (Bytes.get bytes i)
done ;
let mask = lnot (((1 lsl bits) - 1) lsl (ofs mod 8)) in
let v = !cur land mask lor (v lsl (ofs mod 8)) in
for i = first to last - 1 do
Bytes.set bytes i (Char.chr ((v lsr ((i - first) * 8)) land 0xFF))
done
let poke bytes ofs bits v =
if v lsr bits <> 0 then invalid_arg "Bloomer.poke: value too large" ;
check_peek_poke_args "poke" bytes ofs bits ;
poke_unsafe bytes ofs bits v
let%test_unit "random_read_writes" =
let bytes_length = 45 in
let bit_length = bytes_length * 8 in
(* max_data_bit_width = 29 to to stay within Random.int bounds.
int_size - 7 to stay within [check_peek_poke_args] domain. *)
let max_data_bit_width = min 29 (Sys.int_size - 7) in
let bytes = Bytes.make 45 '\000' in
let poke_et_peek ofs len v =
poke bytes ofs len v ;
assert (peek bytes ofs len = v)
in
for _ = 0 to 100_000 do
let ofs = Random.int (bit_length - max_data_bit_width) in
let len = Random.int max_data_bit_width + 1 in
let v = Random.int (1 lsl len) in
poke_et_peek ofs len v
done ;
poke_et_peek 350 10 0x3FF ;
poke_et_peek 355 5 0x1F ;
poke_et_peek 350 10 0 ;
poke_et_peek 355 5 0 ;
try
poke_et_peek 355 6 0 ;
assert false
with _ -> ()
let%test_unit "peek and poke work with bits = [1 .. Sys.int_size - 7]" =
let fail_or_success f =
try
f () ;
true
with _ -> false
in
let bytes = Bytes.make 45 '\000' in
(* we ignore len = 0, the implementation would accepts it but check_peek_poke_args is more strict. *)
for len = 1 to Sys.int_size do
let ints =
List.init 400 (fun _ ->
Int64.(to_int (Random.int64 (sub (shift_left one len) one))))
in
let unsafe_result =
fail_or_success (fun () ->
(* we want to test the property regardless of the offset, we test all possible offset (mod 8) *)
for ofs = 8 to 16 do
List.iter
(fun v ->
poke_unsafe bytes ofs len v ;
assert (peek_unsafe bytes ofs len = v))
ints
done)
in
let check_result =
fail_or_success (fun () ->
(* we want to test the property regardless of the offset, we test all possible offset (mod 8) *)
for ofs = 8 to 16 do
List.iter
(fun v ->
if v lsr len <> 0 then
invalid_arg "Bloomer.poke: value too large" ;
check_peek_poke_args "unti-test" bytes ofs len)
ints
done)
in
assert (unsafe_result = check_result)
done
let%test_unit "sequential_read_writes" =
let bytes = Bytes.make 45 '\000' in
let bits = Bytes.length bytes * 8 in
(* max_data_bit_width = 29 to stay within Random.int bounds.
int_size - 7 to stay within [check_peek_poke_args] domain. *)
let max_data_bit_width = min 29 (Sys.int_size - 7) in
for _ = 0 to 10_000 do
let rec init ofs acc =
if ofs >= bits then List.rev acc
else
let len = min (Random.int max_data_bit_width + 1) (bits - ofs) in
let v = Random.int (1 lsl len) in
poke bytes ofs len v ;
assert (peek bytes ofs len = v) ;
init (ofs + len) ((ofs, len, v) :: acc)
in
List.iter (fun (ofs, len, v) -> assert (peek bytes ofs len = v)) (init 0 [])
done
let%test_unit "read_over_write" =
(* Check that non-overlapping writes really do not overlap. *)
let bytes = Bytes.make 45 '\000' in
let bits = Bytes.length bytes * 8 in
let random_disjoint_writes () =
let width = 1 lsl Random.int 3 in
let indices = bits / width in
let i1 = Random.int indices in
let i2 = (i1 + 1 + Random.int (indices - 1)) mod indices in
let i1 = i1 * width in
let i2 = i2 * width in
assert (i1 <> i2) ;
let v1 = Random.int (1 lsl width) in
let v2 = Random.int (1 lsl width) in
poke bytes i1 width v1 ;
poke bytes i2 width v2 ;
assert (peek bytes i1 width = v1)
in
for _ = 0 to 10_000 do
random_disjoint_writes ()
done
let create ~hash ~hashes ~index_bits ~countdown_bits =
(* We constrain [index_bits] and [countdown_bits] to a maximum of 24. This is
because [peek] and [poke] operate on ints with size [1 .. int_size - 7]
and we want to stay compatible with 32bit arch (e.g. JavaScript).
31 (int_size on 32bit) - 7 = 24
*)
if index_bits <= 0 || index_bits > 24 then
invalid_arg "Bloomer.create: invalid value for index_bits" ;
if countdown_bits <= 0 || countdown_bits > 24 then
invalid_arg "Bloomer.create: invalid value for countdown_bits" ;
let filter =
Bytes.make ((((1 lsl index_bits) * countdown_bits) + 7) / 8) '\000'
in
let count = Array.make ((1 lsl countdown_bits) - 1) 0 in
{hash; hashes; index_bits; countdown_bits; filter; count}
let mem {hash; hashes; index_bits; countdown_bits; filter; _} x =
let h = hash x in
try
for i = 0 to hashes - 1 do
let j = peek h (index_bits * i) index_bits in
if peek filter (j * countdown_bits) countdown_bits = 0 then raise Exit
done ;
true
with Exit -> false
let add {hash; hashes; index_bits; countdown_bits; filter; count} x =
count.(0) <- count.(0) + 1 ;
let h = hash x in
for i = 0 to hashes - 1 do
let j = peek h (index_bits * i) index_bits in
poke filter (j * countdown_bits) countdown_bits ((1 lsl countdown_bits) - 1)
done
let rem {hash; hashes; index_bits; countdown_bits; filter; _} x =
let h = hash x in
for i = 0 to hashes - 1 do
let j = peek h (index_bits * i) index_bits in
poke filter (j * countdown_bits) countdown_bits 0
done
let countdown {hash = _; hashes = _; index_bits; countdown_bits; filter; count}
=
for i = Array.length count - 1 downto 1 do
count.(i) <- count.(i - 1)
done ;
count.(0) <- 0 ;
for j = 0 to (1 lsl index_bits) - 1 do
let cur = peek filter (j * countdown_bits) countdown_bits in
if cur > 0 then poke filter (j * countdown_bits) countdown_bits (cur - 1)
done
let clear
{hash = _; hashes = _; index_bits = _; countdown_bits = _; filter; count} =
Array.fill count 0 (Array.length count) 0 ;
Bytes.fill filter 0 (Bytes.length filter) '\000'
let fill_percentage
{hash = _; hashes = _; index_bits; countdown_bits; filter; _} =
let total = float (1 lsl index_bits) in
let nonzero = ref 0 in
for j = 0 to (1 lsl index_bits) - 1 do
let cur = peek filter (j * countdown_bits) countdown_bits in
if cur > 0 then incr nonzero
done ;
float !nonzero /. total
let life_expectancy_histogram
{hash = _; hashes = _; index_bits; countdown_bits; filter; _} =
let hist_table = Array.make (1 lsl countdown_bits) 0 in
for j = 0 to (1 lsl index_bits) - 1 do
let cur = peek filter (j * countdown_bits) countdown_bits in
hist_table.(cur) <- hist_table.(cur) + 1
done ;
hist_table
let approx_count {count; _} = Array.fold_left ( + ) 0 count
let%test_unit "consistent_add_mem_countdown" =
for _ = 0 to 100 do
let index_bits = Random.int 16 + 1 in
let hashes = Random.int 7 + 1 in
let countdown_bits = Random.int 5 + 1 in
let hash v =
Bytes.init
(((hashes * index_bits) + 7) / 8)
(fun i -> Char.chr (Hashtbl.hash (v, i) mod 256))
in
let bloomer = create ~hash ~index_bits ~hashes ~countdown_bits in
let rec init n acc =
if n = 0 then acc
else
let x = Random.int (1 lsl 29) in
add bloomer x ;
assert (mem bloomer x) ;
init (n - 1) (x :: acc)
in
let all = init 1000 [] in
for _ = 0 to (1 lsl countdown_bits) - 2 do
List.iter (fun x -> assert (mem bloomer x)) all ;
countdown bloomer
done ;
List.iter (fun x -> assert (not (mem bloomer x))) all
done
let%test_unit "consistent_add_countdown_count" =
let module Set = Hashtbl.Make (struct
include Int
let hash = Hashtbl.hash
end) in
for _ = 0 to 100 do
let index_bits = 16 in
let hashes = Random.int 7 + 1 in
let countdown_bits = Random.int 5 + 1 in
let set = Set.create 100 in
let hash v =
Bytes.init
(((hashes * index_bits) + 7) / 8)
(fun i -> Char.chr (Hashtbl.hash (v, i) mod 256))
in
let bloomer = create ~hash ~index_bits ~hashes ~countdown_bits in
let next_ref = ref 0 in
let next () =
incr next_ref ;
!next_ref
in
let actual_set () =
List.filter (mem bloomer) (List.of_seq @@ Set.to_seq_keys set)
in
let rec init_step n acc =
if n = 0 then acc
else
let x = next () in
add bloomer x ;
assert (mem bloomer x) ;
Set.add set x () ;
init_step (n - 1) (1 + acc)
in
let rec init n stop counts =
if n = stop then counts
else
let approx_counted = approx_count bloomer in
let accurate_count = List.length @@ actual_set () in
let count = Random.int 10 in
let added = init_step count 0 in
assert (added = count) ;
countdown bloomer ;
init (n + 1) stop ((approx_counted, accurate_count) :: counts)
in
let all = init 0 ((1 lsl countdown_bits) + 30) [] in
List.iter (fun (approx, accurate) -> assert (approx = accurate)) all ;
clear bloomer ;
assert (approx_count bloomer = 0)
done
let%test_unit "false_positive_rate" =
(* We acknowledge the results published in "On the false-positive
rate of Bloom filters" (Information Processing Letters, volume
108, issue 4, 2008, pages 210-213) stating that the model formula
below is wrong.
However, we still use the original approximation made by Bloom to
check the behaviour of this implementation, as it is close enough
for security yet much simpler to compute. *)
let runs =
[|
(18, 4);
(18, 6);
(18, 8);
(18, 10);
(20, 2);
(20, 4);
(20, 6);
(20, 8);
(20, 9);
(20, 10);
(20, 11);
(20, 12);
(20, 13);
(20, 14);
(21, 2);
(21, 3);
(21, 4);
(21, 5);
(22, 2);
(22, 3);
(22, 4);
(22, 5);
(22, 6);
(22, 8);
|]
in
let steps = 995 in
let init_samples = 5_000 in
let samples_per_step = 1_000 in
let data =
Array.map
(fun (index_bits, hashes) ->
let countdown_bits = 1 in
let hash v =
Bytes.init
(((hashes * index_bits) + 7) / 8)
(fun i -> Char.chr (Hashtbl.hash (v, i) mod 256))
in
let bloomer = create ~hash ~index_bits ~hashes ~countdown_bits in
let (add, cur) =
let cur = ref 0 in
( (fun n ->
for _ = 1 to n do
add bloomer !cur ;
incr cur
done),
fun () -> !cur )
in
add init_samples ;
( float (Bytes.length bloomer.filter) /. 1024.,
index_bits,
hashes,
Array.init steps @@ fun i ->
add samples_per_step ;
let n = init_samples + ((i + 1) * samples_per_step) in
let expected_fp_proba =
let e = 2.718281828459045 in
(1.
-. (e ** (-.float hashes *. float n /. float (1 lsl index_bits))))
** float hashes
in
let actual_proba =
let falses = ref 0 in
for j = 1 to 500 do
if mem bloomer (cur () + j) then incr falses
done ;
float !falses /. 500.
in
(if abs_float (expected_fp_proba -. actual_proba) >= 0.1 then
let message =
Format.asprintf
"wrong false positive rate for n=%d, m=%d,k=%d, expected %g, \
got %g"
n
(1 lsl index_bits)
hashes
expected_fp_proba
actual_proba
in
failwith message) ;
(expected_fp_proba, actual_proba) ))
runs
in
match Sys.getenv_opt "BLOOMER_TEST_GNUPLOT_PATH" with
| Some path ->
for run = 0 to Array.length runs - 1 do
let (kb, index_bits, hashes, values) = data.(run) in
(let fp = open_out (Format.asprintf "%s/run_%02d.plot" path run) in
Printf.fprintf
fp
"set title 'false positive rate (bits=%d (%g KiB), hashes=%d)'\n%!"
(1 lsl index_bits)
kb
hashes ;
Printf.fprintf fp "set xlabel 'insertions'\n" ;
Printf.fprintf fp "set ylabel 'rate'\n" ;
Printf.fprintf fp "set yrange [0:1]\n" ;
Printf.fprintf fp "set terminal 'png' size 800,600\n" ;
Printf.fprintf fp "set output 'run_%02d.png'\n" run ;
Printf.fprintf
fp
"plot 'run_%02d.dat' using 1:2 title 'expected', 'run_%02d.dat' \
using 1:3 title 'obtained'\n\
%!"
run
run ;
close_out fp) ;
let fp = open_out (Format.asprintf "%s/run_%02d.dat" path run) in
for step = 0 to steps - 1 do
Printf.fprintf
fp
"%d %f %f\n"
(init_samples + (step * samples_per_step))
(fst values.(step))
(snd values.(step))
done ;
flush fp ;
close_out fp
done
| None ->
Format.eprintf
"Set the BLOOMER_TEST_GNUPLOT_PATH to a directory to get some human \
readable test results."
| (*****************************************************************************)
(* Open Source License *)
(* Copyright (c) 2020-2021 Nomadic Labs, <contact@nomadic-labs.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
mixMerge.ml | module Make(O:MixOption.S)(A:Arch_tools.S) : sig
val merge : Name.t -> A.test -> Name.t -> A.test -> A.test
val append : Name.t -> A.test -> Name.t -> A.test -> A.test
val cat : Name.t -> A.test -> Name.t -> A.test -> A.test
end =
struct
open MiscParser
module Alpha = Alpha.Make(O)(A)
module MixPerm = MixPerm.Make(O)(A)
(* Merge of conditions *)
open ConstrGen
let or_cond c1 c2 = match c1,c2 with
| ExistsState e1,ExistsState e2 -> ExistsState (Or [e1;e2])
| ForallStates e1,ForallStates e2 -> ForallStates (Or [e1;e2])
| NotExistsState e1,NotExistsState e2 -> NotExistsState (And [e1;e2])
| _,_ ->
let p1 = prop_of c1
and p2 = prop_of c2 in
ExistsState (Or [p1;p2])
let and_cond c1 c2 = match c1,c2 with
| ExistsState e1,ExistsState e2 -> ExistsState (And [e1;e2])
| ForallStates e1,ForallStates e2 -> ForallStates (And [e1;e2])
| NotExistsState e1,NotExistsState e2 -> NotExistsState (Or [e1;e2])
| _,_ ->
let p1 = prop_of c1
and p2 = prop_of c2 in
ExistsState (And [p1;p2])
let choose_cond =
let open MixOption in
match O.cond with
| Cond.Or -> fun _ -> or_cond
| Cond.And -> fun _ -> and_cond
| Cond.Auto -> fun c -> c
| Cond.No -> fun _ _ _ -> ForallStates (And [])
(* merge of locations *)
(*******)
(* Mix *)
(*******)
let rec mix_list xs sx ys sy = match xs, ys with
| [],[] -> []
| x::rx, [] -> x::mix_list rx (sx-1) ys sy
| [],y::ry -> y::mix_list xs sx ry (sy-1)
| x::rx, y::ry ->
if Random.int(sx+sy) < sx then
x::mix_list rx (sx-1) ys sy
else
y::mix_list xs sx ry (sy-1)
let clean_code =
List.filter
(fun i -> match i with
| A.Nop -> false
| A.Label _
| A.Instruction _
| A.Symbolic _
| A.Macro _ -> true)
let mix_code c1 c2 =
let c1 = clean_code c1
and c2 = clean_code c2 in
mix_list c1 (List.length c1) c2 (List.length c2)
let rec mix_prog p1 p2 = match p1,p2 with
| ([],p)|(p,[]) -> p
| (p,c1)::p1,(_,c2)::p2 -> (p,mix_code c1 c2)::mix_prog p1 p2
let mix_cond = choose_cond or_cond
let merge _doc1 t1 doc2 t2 =
let t2 = MixPerm.perm doc2 t2 in
let t2 = Alpha.alpha doc2 t1 t2 in
{ t1 with
init = t1.init @ t2.init ;
prog = mix_prog t1.prog t2.prog ;
locations = t1.locations @ t2.locations ;
condition = mix_cond t1.condition t2.condition ; }
(**********)
(* Append *)
(**********)
let append_cond = choose_cond and_cond
let append_code c1 c2 = c1@c2
let rec append_prog p1 p2 = match p1,p2 with
| ([],p)|(p,[]) -> p
| (p,c1)::p1,(_,c2)::p2 -> (p,append_code c1 c2)::append_prog p1 p2
let rec replicate x n = if n <= 0 then [] else x::replicate x (n-1)
let rec add_end len = function
| [] -> replicate A.Nop len
| x::xs -> x::add_end (len-1) xs
let same_length prg =
let len =
List.fold_left (fun m (_,c) -> max m (List.length c)) 0 prg in
let prg =
List.map
(fun (p,c) -> p,add_end (len+1) c)
prg in
prg
let append _doc1 t1 doc2 t2 =
let t2 = MixPerm.perm doc2 t2 in
let t2 = Alpha.alpha doc2 t1 t2 in
{ t1 with
init = t1.init @ t2.init ;
prog = append_prog (same_length t1.prog) t2.prog ;
locations = t1.locations @ t2.locations ;
condition = append_cond t1.condition t2.condition ; }
(********************************************)
(* Just concatenate in horizontal direction *)
(********************************************)
let nprocs t = List.length t.prog
let shift_location k loc = match loc with
| A.Location_reg (i,r) -> A.Location_reg (i+k,r)
| A.Location_global _ -> loc
let shift_rloc k = ConstrGen.map_rloc (shift_location k)
let shift_state_atom k (loc,v) = shift_location k loc,v
let shift_state k = List.map (shift_state_atom k)
let shift_locations k =
let open LocationsItem in
List.map
(function
| Loc (l,v) -> Loc (shift_rloc k l,v)
| Fault ((i,lbls),x,ft) -> Fault ((i+k,lbls),x,ft))
let shift_atom k a = match a with
| LV (l,v) -> LV (shift_rloc k l,v)
| LL (a,b) -> LL (shift_location k a,shift_location k b)
| FF ((i,lbls),x,ft) -> FF ((i+k,lbls),x,ft)
let shift_constr k = ConstrGen.map_constr (shift_atom k)
let shift_prog k prog = List.map (fun ((i,ao,func),code) -> (i+k,ao,func),code) prog
let shift k t =
{ t with
init = shift_state k t.init;
locations = shift_locations k t.locations;
condition = shift_constr k t.condition;
prog = shift_prog k t.prog;
}
let cat _doc1 t1 doc2 t2 =
let t2 = Alpha.global doc2 t1 t2 in
let n1 = nprocs t1 in
let t2 = shift n1 t2 in
{ t1 with
init = t1.init @ t2.init ;
prog = t1.prog @ t2.prog ;
locations = t1.locations @ t2.locations ;
condition = append_cond t1.condition t2.condition ; }
end
| (****************************************************************************)
(* the diy toolsuite *)
(* *)
(* Jade Alglave, University College London, UK. *)
(* Luc Maranget, INRIA Paris-Rocquencourt, France. *)
(* *)
(* Copyright 2010-present Institut National de Recherche en Informatique et *)
(* en Automatique and the authors. All rights reserved. *)
(* *)
(* This software is governed by the CeCILL-B license under French law and *)
(* abiding by the rules of distribution of free software. You can use, *)
(* modify and/ or redistribute the software under the terms of the CeCILL-B *)
(* license as circulated by CEA, CNRS and INRIA at the following URL *)
(* "http://www.cecill.info". We also give a copy in LICENSE.txt. *)
(****************************************************************************)
|
densld.ml |
open Cmdliner
open De_landmarks
let inflate file d =
let file = open_in file in
let len = in_channel_length file in
let src = Bigstringaf.of_string (really_input_string file len) ~off:0 ~len in
if d then
let dst = Bigstringaf.create (len * 10) in
ignore @@ Inf.Ns.inflate src dst
else
let dst = Bigstringaf.create (Def.Ns.compress_bound len) in
ignore @@ Def.Ns.deflate src dst
let file =
let doc = "input file" in
Arg.(value & pos 0 string "file" & info [] ~doc)
let d =
let doc = "decompress the input" in
Arg.(value & flag & info ["d"] ~doc)
let cmd =
( Term.(const inflate $ file $ d)
, Term.info "bench" ~doc:"Run benchmarks for ns implementation" )
let () = Term.(exit @@ eval cmd)
| |
dune |
(library
(public_name lacaml)
(modules
Lacaml
Common Io
S D C Z
Utils Version
Float32 Float64
Complex32 Complex64
Real_io Complex_io
Impl4_S Impl4_D Impl4_C Impl4_Z
Impl2_S Impl2_D Impl2_C Impl2_Z
Vec4_S Vec4_D Vec4_C Vec4_Z
Vec2_S Vec2_D Vec2_C Vec2_Z
Mat4_S Mat4_D Mat4_C Mat4_Z
Mat2_S Mat2_D Mat2_C Mat2_Z
)
(c_names
impl_c utils_c
vec2_S_c vec2_D_c vec2_C_c vec2_Z_c
vec4_S_c vec4_D_c vec4_C_c vec4_Z_c
mat2_S_c mat2_D_c mat2_C_c mat2_Z_c
mat4_S_c mat4_D_c mat4_C_c mat4_Z_c
impl2_S_c impl2_D_c impl2_C_c impl2_Z_c
impl4_S_c impl4_D_c impl4_C_c impl4_Z_c
)
(c_flags
(:standard)
(:include config/c_flags.sexp)
(:include config/blas_kind_flags.sexp)
; -ffast-math can break IEEE754 floating point semantics, but it is likely
; safe with the current Lacaml code base
-O3 -march=native -ffast-math
-fPIC -DPIC
)
(c_library_flags (:include config/c_library_flags.sexp) -lm)
(libraries bigarray)
)
(rule
(targets
lacaml.mli
;
S.mli S.ml
D.mli D.ml
C.mli C.ml
Z.mli Z.ml
;
impl4_S.mli impl4_S.ml
impl4_D.mli impl4_D.ml
impl4_C.mli impl4_C.ml
impl4_Z.mli impl4_Z.ml
impl2_S.mli impl2_S.ml
impl2_D.mli impl2_D.ml
impl2_C.mli impl2_C.ml
impl2_Z.mli impl2_Z.ml
;
mat4_S.mli mat4_S.ml
mat4_D.mli mat4_D.ml
mat4_C.mli mat4_C.ml
mat4_Z.mli mat4_Z.ml
mat2_S.mli mat2_S.ml
mat2_D.mli mat2_D.ml
mat2_C.mli mat2_C.ml
mat2_Z.mli mat2_Z.ml
;
vec4_S.mli vec4_S.ml
vec4_D.mli vec4_D.ml
vec4_C.mli vec4_C.ml
vec4_Z.mli vec4_Z.ml
vec2_S.mli vec2_S.ml
vec2_D.mli vec2_D.ml
vec2_C.mli vec2_C.ml
vec2_Z.mli vec2_Z.ml
)
(deps
config/make_prec_dep.exe
lacaml.pre.mli
SD.mli SD.ml CZ.mli CZ.ml
impl_SDCZ.mli impl_SDCZ.ml impl_SD.mli impl_SD.ml impl_CZ.mli impl_CZ.ml
mat_SDCZ.mli mat_SDCZ.ml mat_SD.mli mat_SD.ml mat_CZ.mli mat_CZ.ml
vec_SDCZ.mli vec_SDCZ.ml vec_SD.mli vec_SD.ml vec_CZ.mli vec_CZ.ml
real_io.mli complex_io.mli
)
(action (run config/make_prec_dep.exe))
)
| |
middleware_logger.ml |
open Import
let log_src = Logs.Src.create "opium.server"
module Log = (val Logs.src_log log_src : Logs.LOG)
let body_to_string ?(content_type = "text/plain") ?(max_len = 1000) body =
let open Lwt.Syntax in
let lhs, rhs =
match String.split_on_char ~sep:'/' content_type with
| [ lhs; rhs ] -> lhs, rhs
| _ -> "application", "octet-stream"
in
match lhs, rhs with
| "text", _ | "application", "json" | "application", "x-www-form-urlencoded" ->
let+ s = Body.copy body |> Body.to_string in
if String.length s > max_len
then
String.sub s ~pos:0 ~len:(min (String.length s) max_len)
^ Format.asprintf " [truncated %d characters]" (String.length s - max_len)
else s
| _ -> Lwt.return ("<" ^ content_type ^ ">")
;;
let request_to_string (request : Request.t) =
let open Lwt.Syntax in
let content_type = Request.content_type request in
let+ body_string = body_to_string ?content_type request.body in
Format.asprintf
"%s %s %s\n%s\n\n%s\n%!"
(Method.to_string request.meth)
request.target
(Version.to_string request.version)
(Headers.to_string request.headers)
body_string
;;
let response_to_string (response : Response.t) =
let open Lwt.Syntax in
let content_type = Response.content_type response in
let+ body_string = body_to_string ?content_type response.body in
Format.asprintf
"%a %a %s\n%a\n%s\n%!"
Version.pp_hum
response.version
Status.pp_hum
response.status
(Option.value ~default:"" response.reason)
Headers.pp_hum
response.headers
body_string
;;
let respond handler req =
let time_f f =
let t1 = Mtime_clock.now () in
let x = f () in
let t2 = Mtime_clock.now () in
let span = Mtime.span t1 t2 in
span, x
in
let open Lwt.Syntax in
let f () = handler req in
let span, response_lwt = time_f f in
let* response = response_lwt in
let code = response.Response.status |> Status.to_string in
Log.info (fun m -> m "Responded with HTTP code %s in %a" code Mtime.Span.pp span);
let+ response_string = response_to_string response in
Log.debug (fun m -> m "%s" response_string);
response
;;
let m =
let open Lwt.Syntax in
let filter handler req =
let meth = Method.to_string req.Request.meth in
let uri = req.Request.target |> Uri.of_string |> Uri.path_and_query in
Logs.info ~src:log_src (fun m -> m "Received %s %S" meth uri);
let* request_string = request_to_string req in
Logs.debug ~src:log_src (fun m -> m "%s" request_string);
Lwt.catch
(fun () -> respond handler req)
(fun exn ->
Logs.err ~src:log_src (fun f -> f "%s" (Nifty.Exn.to_string exn));
Lwt.fail exn)
in
Rock.Middleware.create ~name:"Logger" ~filter
;;
| |
bytea.h | #ifndef BYTEA_H
#define BYTEA_H
typedef enum
{
BYTEA_OUTPUT_ESCAPE,
BYTEA_OUTPUT_HEX
} ByteaOutputType;
extern int bytea_output; /* ByteaOutputType, but int for GUC enum */
#endif /* BYTEA_H */
| /*-------------------------------------------------------------------------
*
* bytea.h
* Declarations for BYTEA data type support.
*
*
* Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* src/include/utils/bytea.h
*
*-------------------------------------------------------------------------
*/ |
t-fresnel.c |
#include "acb_hypgeom.h"
int main()
{
slong iter;
flint_rand_t state;
flint_printf("fresnel....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
acb_t z, z2, s, c, u, v;
slong prec1, prec2;
int normalized;
prec1 = 2 + n_randint(state, 500);
prec2 = 2 + n_randint(state, 500);
acb_init(z);
acb_init(z2);
acb_init(s);
acb_init(c);
acb_init(u);
acb_init(v);
acb_randtest_special(z, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100));
acb_randtest_special(s, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100));
acb_randtest_special(c, state, 1 + n_randint(state, 500), 1 + n_randint(state, 100));
normalized = n_randint(state, 2);
/* test S(z) + i C(z) = sqrt(pi/2) (1+i)/2 erf((1+i)/sqrt(2) z) */
/* u = rhs */
acb_onei(u);
acb_sqrt(u, u, prec1);
acb_mul(u, u, z, prec1);
acb_hypgeom_erf(u, u, prec1);
acb_mul_onei(v, u);
acb_add(u, u, v, prec1);
acb_mul_2exp_si(u, u, -1);
acb_const_pi(v, prec1);
acb_mul_2exp_si(v, v, -1);
acb_sqrt(v, v, prec1);
acb_mul(u, u, v, prec1);
if (normalized)
{
acb_const_pi(v, prec2);
acb_mul_2exp_si(v, v, -1);
acb_sqrt(v, v, prec2);
acb_div(z2, z, v, prec2);
}
else
{
acb_set(z2, z);
}
switch (n_randint(state, 4))
{
case 0:
acb_hypgeom_fresnel(s, c, z2, normalized, prec2);
break;
case 1:
acb_hypgeom_fresnel(s, NULL, z2, normalized, prec2);
acb_hypgeom_fresnel(NULL, c, z2, normalized, prec2);
break;
case 2:
acb_set(s, z2);
acb_hypgeom_fresnel(s, c, s, normalized, prec2);
break;
case 3:
acb_set(c, z2);
acb_hypgeom_fresnel(s, c, c, normalized, prec2);
break;
default:
acb_hypgeom_fresnel(s, c, z2, normalized, prec2);
}
if (normalized)
{
acb_mul(s, s, v, prec2);
acb_mul(c, c, v, prec2);
}
acb_mul_onei(v, c);
acb_add(v, v, s, prec2);
if (!acb_overlaps(u, v))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("s = "); acb_printd(s, 30); flint_printf("\n\n");
flint_printf("c = "); acb_printd(c, 30); flint_printf("\n\n");
flint_printf("u = "); acb_printd(u, 30); flint_printf("\n\n");
flint_printf("v = "); acb_printd(v, 30); flint_printf("\n\n");
flint_abort();
}
acb_clear(z);
acb_clear(z2);
acb_clear(s);
acb_clear(c);
acb_clear(u);
acb_clear(v);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
| /*
Copyright (C) 2016 Fredrik Johansson
This file is part of Arb.
Arb is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License (LGPL) as published
by the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version. See <http://www.gnu.org/licenses/>.
*/ |
pattern.ml |
let f = match x with
| { x = 3 } ->
let x = 4 in
()
let f = match x with
| (X|Y) | (Z|U) -> 1
| K -> 2
let f = match x with
| X when foo = bar ->
fff
| Y when f = x
&& g = 3 ->
z
let f () =
match s with
(* Parenthesized ident ? *)
| x -> x, d
(* Regular ident *)
| _ -> g
;;
match x with
| X | Y -> 1
| X ->
2;
3
| A -> 2
;;
let f g =
(* haha *)
match z with
| Z | B _ -> x
| A (a, _, _, b) as x ->
let x = f a and hr = f b in
f
let unwind_to =
match t with KType | KModule -> true | Kblob -> false
| _ -> true
let f x = match x with
| A | B
| C ->
x
| z -> match z with
| _ -> function
| x ->
x
let fun_dep ulam = function
| A
| B
| C ->
()
let fun_dep ulam = function
|A
|B|C
|D ->
()
let _ =
(match bla
with bli)
| |
dune |
(tests
(names test_url test_color)
(libraries camyll))
| |
t-inv.c |
#include "ca_mat.h"
int main()
{
slong iter;
flint_rand_t state;
flint_printf("inv....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * calcium_test_multiplier(); iter++)
{
ca_ctx_t ctx;
ca_mat_t A, B, C;
slong n;
truth_t success;
ca_ctx_init(ctx);
n = n_randint(state, 6);
ca_mat_init(A, n, n, ctx);
ca_mat_init(B, n, n, ctx);
ca_mat_init(C, n, n, ctx);
if (n_randint(state, 2) || n > 3)
ca_mat_randtest_rational(A, state, 5, ctx);
else
ca_mat_randtest(A, state, 1, 5, ctx);
success = ca_mat_inv(B, A, ctx);
if (success == T_TRUE)
{
ca_mat_mul(C, A, B, ctx);
if (ca_mat_check_is_one(C, ctx) == T_FALSE)
{
flint_printf("FAIL\n\n");
flint_printf("A = "); ca_mat_print(A, ctx); flint_printf("\n");
flint_printf("B = "); ca_mat_print(B, ctx); flint_printf("\n");
flint_printf("C = "); ca_mat_print(C, ctx); flint_printf("\n");
flint_abort();
}
}
else if (success == T_FALSE)
{
ca_t det;
ca_init(det, ctx);
ca_mat_det(det, A, ctx);
if (ca_check_is_zero(det, ctx) == T_FALSE)
{
flint_printf("FAIL (singular)\n\n");
flint_printf("A = "); ca_mat_print(A, ctx); flint_printf("\n");
flint_printf("det = "); ca_print(det, ctx); flint_printf("\n");
flint_abort();
}
ca_clear(det, ctx);
}
ca_mat_clear(A, ctx);
ca_mat_clear(B, ctx);
ca_mat_clear(C, ctx);
ca_ctx_clear(ctx);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
| /*
Copyright (C) 2020 Fredrik Johansson
This file is part of Calcium.
Calcium is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License (LGPL) as published
by the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version. See <http://www.gnu.org/licenses/>.
*/ |
weak_array.mli | (** Module for dealing with weak pointers, i.e., pointers that don't prevent garbage
collection of what they point to.
This module is like the OCaml standard library module of the same name, except that it
requires that the values in the weak set are heap blocks. *)
open! Core
type 'a t [@@deriving sexp_of]
val create : len:int -> _ t
val length : _ t -> int
val set : 'a t -> int -> 'a Heap_block.t option -> unit
(** [set_exn] raises an exception if given [Some x] with [x] not being
a heap block. This is in addition to raising exceptions on bounds violation as [set]
does. *)
val set_exn : 'a t -> int -> 'a option -> unit
val get : 'a t -> int -> 'a Heap_block.t option
val is_some : _ t -> int -> bool
val is_none : _ t -> int -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(int -> 'a -> unit) -> unit
(**
Warning! [blit] often takes time linear in the size of the arrays, not in the size of
the range being copied. This issue is being tracked in
https://github.com/ocaml/ocaml/issues/9258.
Other than that, [blit] is generally preferred over [get] followed by [set]
because, unlike [get], it doesn't have to make the value strongly-referenced.
Making a value strongly-referenced, even temporarily, may result in delaying
its garbage collection by a whole GC cycle.
*)
val blit : src:'a t -> src_pos:int -> dst:'a t -> dst_pos:int -> len:int -> unit
| (** Module for dealing with weak pointers, i.e., pointers that don't prevent garbage
collection of what they point to.
This module is like the OCaml standard library module of the same name, except that it
requires that the values in the weak set are heap blocks. *) |
import.ml |
module Unix = Caml_unix
| |
storage_sigs.ml | (** {1 Entity Accessor Signatures} *)
(** The generic signature of a single data accessor (a single value
bound to a specific key in the hierarchical (key x value)
database). *)
module type Single_data_storage = sig
type t
type context = t
(** The type of the value *)
type value
(** Tells if the data is already defined *)
val mem : context -> bool Lwt.t
(** Retrieve the value from the storage bucket ; returns a
{!Storage_error} if the key is not set or if the deserialisation
fails *)
val get : context -> value tzresult Lwt.t
(** Retrieves the value from the storage bucket ; returns [None] if
the data is not initialized, or {!Storage_helpers.Storage_error}
if the deserialisation fails *)
val find : context -> value option tzresult Lwt.t
(** Allocates the storage bucket and initializes it ; returns a
{!Storage_error Existing_key} if the bucket exists *)
val init : context -> value -> Raw_context.t tzresult Lwt.t
(** Updates the content of the bucket ; returns a {!Storage_Error
Missing_key} if the value does not exists *)
val update : context -> value -> Raw_context.t tzresult Lwt.t
(** Allocates the data and initializes it with a value ; just
updates it if the bucket exists *)
val add : context -> value -> Raw_context.t Lwt.t
(** When the value is [Some v], allocates the data and initializes
it with [v] ; just updates it if the bucket exists. When the
value is [None], delete the storage bucket when the value ; does
nothing if the bucket does not exists. *)
val add_or_remove : context -> value option -> Raw_context.t Lwt.t
(** Delete the storage bucket ; returns a {!Storage_error
Missing_key} if the bucket does not exists *)
val remove_existing : context -> Raw_context.t tzresult Lwt.t
(** Removes the storage bucket and its contents ; does nothing if
the bucket does not exists *)
val remove : context -> Raw_context.t Lwt.t
end
[@@coq_precise_signature]
(** Restricted version of {!Indexed_data_storage} w/o iterators. *)
module type Non_iterable_indexed_data_storage = sig
type t
type context = t
(** An abstract type for keys *)
type key
(** The type of values *)
type value
(** Tells if a given key is already bound to a storage bucket *)
val mem : context -> key -> bool Lwt.t
(** Retrieve a value from the storage bucket at a given key ;
returns {!Storage_error Missing_key} if the key is not set ;
returns {!Storage_error Corrupted_data} if the deserialisation
fails. *)
val get : context -> key -> value tzresult Lwt.t
(** Retrieve a value from the storage bucket at a given key ;
returns [None] if the value is not set ; returns {!Storage_error
Corrupted_data} if the deserialisation fails. *)
val find : context -> key -> value option tzresult Lwt.t
(** Updates the content of a bucket ; returns A {!Storage_Error
Missing_key} if the value does not exists. *)
val update : context -> key -> value -> Raw_context.t tzresult Lwt.t
(** Allocates a storage bucket at the given key and initializes it ;
returns a {!Storage_error Existing_key} if the bucket exists. *)
val init : context -> key -> value -> Raw_context.t tzresult Lwt.t
(** Allocates a storage bucket at the given key and initializes it
with a value ; just updates it if the bucket exists. *)
val add : context -> key -> value -> Raw_context.t Lwt.t
(** When the value is [Some v], allocates the data and initializes
it with [v] ; just updates it if the bucket exists. When the
value is [None], delete the storage bucket when the value ; does
nothing if the bucket does not exists. *)
val add_or_remove : context -> key -> value option -> Raw_context.t Lwt.t
(** Delete a storage bucket and its contents ; returns a
{!Storage_error Missing_key} if the bucket does not exists. *)
val remove_existing : context -> key -> Raw_context.t tzresult Lwt.t
(** Removes a storage bucket and its contents ; does nothing if the
bucket does not exists. *)
val remove : context -> key -> Raw_context.t Lwt.t
end
[@@coq_precise_signature]
(** Variant of {!Non_iterable_indexed_data_storage} with gas accounting. *)
module type Non_iterable_indexed_carbonated_data_storage = sig
type t
type context = t
(** An abstract type for keys *)
type key
(** The type of values *)
type value
(** Tells if a given key is already bound to a storage bucket.
Consumes [Gas_repr.read_bytes_cost Z.zero]. *)
val mem : context -> key -> (Raw_context.t * bool) tzresult Lwt.t
(** Retrieve a value from the storage bucket at a given key ;
returns {!Storage_error Missing_key} if the key is not set ;
returns {!Storage_error Corrupted_data} if the deserialisation
fails.
Consumes [Gas_repr.read_bytes_cost <size of the value>]. *)
val get : context -> key -> (Raw_context.t * value) tzresult Lwt.t
(** Retrieve a value from the storage bucket at a given key ;
returns [None] if the value is not set ; returns {!Storage_error
Corrupted_data} if the deserialisation fails.
Consumes [Gas_repr.read_bytes_cost <size of the value>] if present
or [Gas_repr.read_bytes_cost Z.zero]. *)
val find : context -> key -> (Raw_context.t * value option) tzresult Lwt.t
(** Updates the content of a bucket ; returns A {!Storage_Error
Missing_key} if the value does not exists.
Consumes serialization cost.
Consumes [Gas_repr.write_bytes_cost <size of the new value>].
Returns the difference from the old to the new size. *)
val update : context -> key -> value -> (Raw_context.t * int) tzresult Lwt.t
(** Allocates a storage bucket at the given key and initializes it ;
returns a {!Storage_error Existing_key} if the bucket exists.
Consumes serialization cost.
Consumes [Gas_repr.write_bytes_cost <size of the value>].
Returns the size. *)
val init : context -> key -> value -> (Raw_context.t * int) tzresult Lwt.t
(** Allocates a storage bucket at the given key and initializes it
with a value ; just updates it if the bucket exists.
Consumes serialization cost.
Consumes [Gas_repr.write_bytes_cost <size of the new value>].
Returns the difference from the old (maybe 0) to the new size, and a boolean
indicating if a value was already associated to this key. *)
val add :
context -> key -> value -> (Raw_context.t * int * bool) tzresult Lwt.t
(** When the value is [Some v], allocates the data and initializes
it with [v] ; just updates it if the bucket exists. When the
value is [None], delete the storage bucket when the value ; does
nothing if the bucket does not exists.
Consumes serialization cost.
Consumes the same gas cost as either {!remove} or {!init_set}.
Returns the difference from the old (maybe 0) to the new size, and a boolean
indicating if a value was already associated to this key. *)
val add_or_remove :
context ->
key ->
value option ->
(Raw_context.t * int * bool) tzresult Lwt.t
(** Delete a storage bucket and its contents ; returns a
{!Storage_error Missing_key} if the bucket does not exists.
Consumes [Gas_repr.write_bytes_cost Z.zero].
Returns the freed size. *)
val remove_existing : context -> key -> (Raw_context.t * int) tzresult Lwt.t
(** Removes a storage bucket and its contents ; does nothing if the
bucket does not exists.
Consumes [Gas_repr.write_bytes_cost Z.zero].
Returns the freed size, and a boolean
indicating if a value was already associated to this key. *)
val remove : context -> key -> (Raw_context.t * int * bool) tzresult Lwt.t
end
[@@coq_precise_signature]
module type Non_iterable_indexed_carbonated_data_storage_with_values = sig
include Non_iterable_indexed_carbonated_data_storage
(* HACK *)
val list_values :
?offset:int ->
?length:int ->
t ->
(Raw_context.t * value list) tzresult Lwt.t
end
module type Non_iterable_indexed_carbonated_data_storage_INTERNAL = sig
include Non_iterable_indexed_carbonated_data_storage_with_values
val fold_keys_unaccounted :
context ->
order:[`Sorted | `Undefined] ->
init:'a ->
f:(key -> 'a -> 'a Lwt.t) ->
'a Lwt.t
end
(** The generic signature of indexed data accessors (a set of values
of the same type indexed by keys of the same form in the
hierarchical (key x value) database). *)
module type Indexed_data_storage = sig
include Non_iterable_indexed_data_storage
(** Empties all the keys and associated data. *)
val clear : context -> Raw_context.t Lwt.t
(** Lists all the keys. *)
val keys : context -> key list Lwt.t
(** Lists all the keys and associated data. *)
val bindings : context -> (key * value) list Lwt.t
(** Iterates over all the keys and associated data. *)
val fold :
context ->
order:[`Sorted | `Undefined] ->
init:'a ->
f:(key -> value -> 'a -> 'a Lwt.t) ->
'a Lwt.t
(** Iterate over all the keys. *)
val fold_keys :
context ->
order:[`Sorted | `Undefined] ->
init:'a ->
f:(key -> 'a -> 'a Lwt.t) ->
'a Lwt.t
end
module type Indexed_data_snapshotable_storage = sig
type snapshot
type key
include Indexed_data_storage with type key := key
module Snapshot :
Indexed_data_storage
with type key = snapshot * key
and type value = value
and type t = t
val snapshot_exists : context -> snapshot -> bool Lwt.t
val snapshot : context -> snapshot -> Raw_context.t tzresult Lwt.t
val fold_snapshot :
context ->
snapshot ->
order:[`Sorted | `Undefined] ->
init:'a ->
f:(key -> value -> 'a -> 'a tzresult Lwt.t) ->
'a tzresult Lwt.t
val delete_snapshot : context -> snapshot -> Raw_context.t Lwt.t
end
(** The generic signature of a data set accessor (a set of values
bound to a specific key prefix in the hierarchical (key x value)
database). *)
module type Data_set_storage = sig
type t
type context = t
(** The type of elements. *)
type elt
(** Tells if a elt is a member of the set *)
val mem : context -> elt -> bool Lwt.t
(** Adds a elt is a member of the set *)
val add : context -> elt -> Raw_context.t Lwt.t
(** Removes a elt of the set ; does nothing if not a member *)
val remove : context -> elt -> Raw_context.t Lwt.t
(** Returns the elements of the set, deserialized in a list in no
particular order. *)
val elements : context -> elt list Lwt.t
(** Iterates over the elements of the set. *)
val fold :
context ->
order:[`Sorted | `Undefined] ->
init:'a ->
f:(elt -> 'a -> 'a Lwt.t) ->
'a Lwt.t
(** Removes all elements in the set *)
val clear : context -> Raw_context.t Lwt.t
end
(** Variant of {!Data_set_storage} with gas accounting. *)
module type Carbonated_data_set_storage = sig
type t
type context = t
(** The type of elements. *)
type elt
(** Tells whether an elt is a member of the set.
Consumes [Gas_repr.read_bytes_cost Z.zero] *)
val mem : context -> elt -> (Raw_context.t * bool) tzresult Lwt.t
(** Adds an elt as a member of the set.
Consumes [Gas_repr.write_bytes_cost <size of the new value>].
Returns the the new size. *)
val init : context -> elt -> (Raw_context.t * int) tzresult Lwt.t
(** Adds an elt as a member of the set.
Consumes [Gas_repr.write_bytes_cost <size of the new value>].
Returns the new size, and true if the value previously existed. *)
val add : context -> elt -> (Raw_context.t * int * bool) tzresult Lwt.t
(** Removes an elt from the set ; does nothing if not a member.
Consumes [Gas_repr.write_bytes_cost Z.zero].
Returns the freed size, and a boolean
indicating if a value was already associated to this key. *)
val remove : context -> elt -> (Raw_context.t * int * bool) tzresult Lwt.t
val fold_keys_unaccounted :
context ->
order:[`Sorted | `Undefined] ->
init:'acc ->
f:(elt -> 'acc -> 'acc Lwt.t) ->
'acc Lwt.t
end
module type NAME = sig
val name : Raw_context.key
end
module type VALUE = sig
type t
val encoding : t Data_encoding.t
end
module type REGISTER = sig
val ghost : bool
end
module type Indexed_raw_context = sig
type t
type context = t
type key
type 'a ipath
val clear : context -> Raw_context.t Lwt.t
val fold_keys :
context ->
order:[`Sorted | `Undefined] ->
init:'a ->
f:(key -> 'a -> 'a Lwt.t) ->
'a Lwt.t
val keys : context -> key list Lwt.t
val remove : context -> key -> context Lwt.t
val copy : context -> from:key -> to_:key -> context tzresult Lwt.t
module Make_set (_ : REGISTER) (_ : NAME) :
Data_set_storage with type t = t and type elt = key
module Make_map (_ : NAME) (V : VALUE) :
Indexed_data_storage with type t = t and type key = key and type value = V.t
module Make_carbonated_map (_ : NAME) (V : VALUE) :
Non_iterable_indexed_carbonated_data_storage
with type t = t
and type key = key
and type value = V.t
module Raw_context : Raw_context.T with type t = t ipath
end
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* Copyright (c) 2019-2020 Nomadic Labs <contact@nomadic-labs.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
indexable.ml | type index_only = Index_only
type value_only = Value_only
type unknown = Unknown
type (_, 'a) t =
| Value : 'a -> (value_only, 'a) t
| Hidden_value : 'a -> (unknown, 'a) t
| Index : int32 -> (index_only, 'a) t
| Hidden_index : int32 -> (unknown, 'a) t
type error += Index_cannot_be_negative of int32
let () =
let open Data_encoding in
register_error_kind
`Permanent
~id:"indexable.index_cannot_be_negative"
~title:"Index of values cannot be negative"
~description:"A negative integer cannot be used as an index for a value."
~pp:(fun ppf wrong_id ->
Format.fprintf
ppf
"%ld cannot be used as an index because it is negative."
wrong_id)
(obj1 (req "wrong_index" int32))
(function Index_cannot_be_negative wrong_id -> Some wrong_id | _ -> None)
(fun wrong_id -> Index_cannot_be_negative wrong_id)
type 'a value = (value_only, 'a) t
type 'a index = (index_only, 'a) t
type 'a either = (unknown, 'a) t
let value : 'a -> 'a value = fun v -> Value v
let from_value : 'a -> 'a either = fun v -> Hidden_value v
let index : int32 -> 'a index tzresult =
fun i ->
if Compare.Int32.(0l <= i) then ok (Index i)
else error (Index_cannot_be_negative i)
let from_index : int32 -> 'a either tzresult =
fun i ->
if Compare.Int32.(0l <= i) then ok (Hidden_index i)
else error (Index_cannot_be_negative i)
let index_exn : int32 -> 'a index =
fun i ->
match index i with
| Ok x -> x
| Error _ -> raise (Invalid_argument "Indexable.index_exn")
let from_index_exn : int32 -> 'a either =
fun i ->
match from_index i with
| Ok x -> x
| Error _ -> raise (Invalid_argument "Indexable.from_index_exn")
let destruct : type state a. (state, a) t -> (a index, a) Either.t = function
| Hidden_value x | Value x -> Right x
| Hidden_index x | Index x -> Left (Index x)
let forget : type state a. (state, a) t -> (unknown, a) t = function
| Hidden_value x | Value x -> Hidden_value x
| Hidden_index x | Index x -> Hidden_index x
let to_int32 = function Index x -> x
let to_value = function Value x -> x
let is_value_e : error:'trace -> ('state, 'a) t -> ('a, 'trace) result =
fun ~error v ->
match destruct v with Left _ -> Result.error error | Right v -> Result.ok v
let compact val_encoding =
Data_encoding.Compact.(
conv
(function Hidden_index x -> Either.Left x | Hidden_value x -> Right x)
(function Left x -> Hidden_index x | Right x -> Hidden_value x)
@@ or_int32 ~int32_title:"index" ~alt_title:"value" val_encoding)
let encoding : 'a Data_encoding.t -> 'a either Data_encoding.t =
fun val_encoding ->
Data_encoding.Compact.make ~tag_size:`Uint8 @@ compact val_encoding
let pp :
type state a.
(Format.formatter -> a -> unit) -> Format.formatter -> (state, a) t -> unit
=
fun ppv fmt -> function
| Hidden_index x | Index x -> Format.(fprintf fmt "#%ld" x)
| Hidden_value x | Value x -> Format.(fprintf fmt "%a" ppv x)
let in_memory_size :
type state a.
(a -> Cache_memory_helpers.sint) ->
(state, a) t ->
Cache_memory_helpers.sint =
fun ims ->
let open Cache_memory_helpers in
function
| Hidden_value x | Value x -> header_size +! word_size +! ims x
| Hidden_index _ | Index _ -> header_size +! word_size +! int32_size
let size : type state a. (a -> int) -> (state, a) t -> int =
fun s -> function
| Hidden_value x | Value x -> 1 + s x
| Hidden_index _ | Index _ -> (* tag + int32 *) 1 + 4
let compare :
type state state' a. (a -> a -> int) -> (state, a) t -> (state', a) t -> int
=
fun c x y ->
match (x, y) with
| (Hidden_index x | Index x), (Hidden_index y | Index y) ->
Compare.Int32.compare x y
| (Hidden_value x | Value x), (Hidden_value y | Value y) -> c x y
| (Hidden_index _ | Index _), (Hidden_value _ | Value _) -> -1
| (Hidden_value _ | Value _), (Hidden_index _ | Index _) -> 1
let compare_values c : 'a value -> 'a value -> int =
fun (Value x) (Value y) -> c x y
let compare_indexes : 'a index -> 'a index -> int =
fun (Index x) (Index y) -> Compare.Int32.compare x y
module type VALUE = sig
type t
val encoding : t Data_encoding.t
val compare : t -> t -> int
val pp : Format.formatter -> t -> unit
end
module Make (V : VALUE) = struct
type nonrec 'state t = ('state, V.t) t
type nonrec index = V.t index
type nonrec value = V.t value
type nonrec either = V.t either
let value = value
let index = index
let index_exn = index_exn
let compact = compact V.encoding
let encoding = encoding V.encoding
let index_encoding : index Data_encoding.t =
Data_encoding.(
conv (fun (Index x) -> x) (fun x -> Index x) Data_encoding.int32)
let value_encoding : value Data_encoding.t =
Data_encoding.(conv (fun (Value x) -> x) (fun x -> Value x) V.encoding)
let pp : Format.formatter -> 'state t -> unit = fun fmt x -> pp V.pp fmt x
let compare_values = compare_values V.compare
let compare_indexes = compare_indexes
let compare : 'state t -> 'state' t -> int = fun x y -> compare V.compare x y
end
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2022 Nomadic Labs <contact@nomadic-labs.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
client_proto_multisig_commands.ml | open Protocol
open Alpha_context
open Client_proto_args
open Tezos_micheline
let group =
{
Clic.name = "multisig";
title = "Commands for managing a multisig smart contract";
}
let threshold_param () =
Clic.param
~name:"threshold"
~desc:"Number of required signatures"
Client_proto_args.int_parameter
let public_key_param () =
Client_keys.Public_key.source_param
~name:"key"
~desc:"Each signer of the multisig contract"
let secret_key_param () =
Client_keys.Secret_key.source_param
~name:"key"
~desc:
"Secret key corresponding to one of the public keys stored on the \
multisig contract"
let signature_param () =
Clic.param
~name:"signature"
~desc:"Each signer of the multisig contract"
Client_proto_args.signature_parameter
let lambda_param () =
Clic.param
~name:"lambda"
~desc:"the lambda to execute, of type lambda unit (list operation)"
string_parameter
let bytes_only_switch =
Clic.switch
~long:"bytes-only"
~doc:"return only the byte sequence to be signed"
()
let bytes_param ~name ~desc =
Clic.param ~name ~desc Client_proto_args.bytes_parameter
let transfer_options =
Clic.args15
Client_proto_args.fee_arg
Client_proto_context_commands.dry_run_switch
Client_proto_context_commands.verbose_signing_switch
Client_proto_args.gas_limit_arg
Client_proto_args.storage_limit_arg
Client_proto_args.counter_arg
Client_proto_args.arg_arg
Client_proto_args.no_print_source_flag
Client_proto_args.minimal_fees_arg
Client_proto_args.minimal_nanotez_per_byte_arg
Client_proto_args.minimal_nanotez_per_gas_unit_arg
Client_proto_args.force_low_fee_arg
Client_proto_args.fee_cap_arg
Client_proto_args.burn_cap_arg
Client_proto_args.entrypoint_arg
let non_transfer_options =
Clic.args13
Client_proto_args.fee_arg
Client_proto_context_commands.dry_run_switch
Client_proto_context_commands.verbose_signing_switch
Client_proto_args.gas_limit_arg
Client_proto_args.storage_limit_arg
Client_proto_args.counter_arg
Client_proto_args.no_print_source_flag
Client_proto_args.minimal_fees_arg
Client_proto_args.minimal_nanotez_per_byte_arg
Client_proto_args.minimal_nanotez_per_gas_unit_arg
Client_proto_args.force_low_fee_arg
Client_proto_args.fee_cap_arg
Client_proto_args.burn_cap_arg
let prepare_command_display prepared_command bytes_only =
if bytes_only then
Format.printf
"0x%a@."
Hex.pp
(Hex.of_bytes prepared_command.Client_proto_multisig.bytes)
else
Format.printf
"%a@.%a@.%a@.%a@."
(fun ppf x ->
Format.fprintf ppf "Bytes to sign: '0x%a'" Hex.pp (Hex.of_bytes x))
prepared_command.Client_proto_multisig.bytes
(fun ppf x ->
Format.fprintf
ppf
"Blake 2B Hash: '%s'"
(Base58.raw_encode Blake2B.(hash_bytes [x] |> to_string)))
prepared_command.Client_proto_multisig.bytes
(fun ppf z ->
Format.fprintf
ppf
"Threshold (number of signatures required): %s"
(Z.to_string z))
prepared_command.Client_proto_multisig.threshold
(fun ppf ->
Format.fprintf
ppf
"@[<2>Public keys of the signers:@ %a@]"
(Format.pp_print_list
~pp_sep:(fun ppf () -> Format.fprintf ppf "@ ")
Signature.Public_key.pp))
prepared_command.Client_proto_multisig.keys
let get_parameter_type (cctxt : #Protocol_client_context.full) ~destination
~entrypoint =
match Contract.is_implicit destination with
| Some _ ->
let open Micheline in
return @@ strip_locations @@ Prim (0, Script.T_unit, [], [])
| None -> (
Michelson_v1_entrypoints.contract_entrypoint_type
cctxt
~chain:cctxt#chain
~block:cctxt#block
~contract:destination
~entrypoint
>>=? function
| None ->
cctxt#error
"Contract %a has no entrypoint named %s"
Contract.pp
destination
entrypoint
| Some parameter_type -> return parameter_type)
let commands () : #Protocol_client_context.full Clic.command list =
Clic.
[
command
~group
~desc:"Originate a new multisig contract."
(args14
Client_proto_args.fee_arg
Client_proto_context_commands.dry_run_switch
Client_proto_args.gas_limit_arg
Client_proto_args.storage_limit_arg
Client_proto_args.delegate_arg
(Client_keys.force_switch ())
Client_proto_args.no_print_source_flag
Client_proto_args.minimal_fees_arg
Client_proto_args.minimal_nanotez_per_byte_arg
Client_proto_args.minimal_nanotez_per_gas_unit_arg
Client_proto_args.force_low_fee_arg
Client_proto_args.fee_cap_arg
Client_proto_context_commands.verbose_signing_switch
Client_proto_args.burn_cap_arg)
(prefixes ["deploy"; "multisig"]
@@ Client_proto_contracts.RawContractAlias.fresh_alias_param
~name:"new_multisig"
~desc:"name of the new multisig contract"
@@ prefix "transferring"
@@ Client_proto_args.tez_param
~name:"qty"
~desc:"amount taken from source"
@@ prefix "from"
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"src"
~desc:"name of the source contract"
@@ prefixes ["with"; "threshold"]
@@ threshold_param ()
@@ prefixes ["on"; "public"; "keys"]
@@ seq_of_param (public_key_param ()))
(fun ( fee,
dry_run,
gas_limit,
storage_limit,
delegate,
force,
no_print_source,
minimal_fees,
minimal_nanotez_per_byte,
minimal_nanotez_per_gas_unit,
force_low_fee,
fee_cap,
verbose_signing,
burn_cap )
alias_name
balance
(_, source)
threshold
keys
(cctxt : #Protocol_client_context.full) ->
Client_proto_contracts.RawContractAlias.of_fresh
cctxt
force
alias_name
>>=? fun alias_name ->
match Contract.is_implicit source with
| None ->
failwith
"only implicit accounts can be the source of an origination"
| Some source -> (
Client_keys.get_key cctxt source >>=? fun (_, src_pk, src_sk) ->
let fee_parameter =
{
Injection.minimal_fees;
minimal_nanotez_per_byte;
minimal_nanotez_per_gas_unit;
force_low_fee;
fee_cap;
burn_cap;
}
in
List.map_es
(fun (pk_uri, _) -> Client_keys.public_key pk_uri)
keys
>>=? fun keys ->
Client_proto_multisig.originate_multisig
cctxt
~chain:cctxt#chain
~block:cctxt#block
?confirmations:cctxt#confirmations
~dry_run
?fee
?gas_limit
?storage_limit
~verbose_signing
~delegate
~threshold:(Z.of_int threshold)
~keys
~balance
~source
~src_pk
~src_sk
~fee_parameter
()
>>= fun errors ->
Client_proto_context_commands.report_michelson_errors
~no_print_source
~msg:"multisig origination simulation failed"
cctxt
errors
>>= function
| None -> return_unit
| Some (_res, contract) ->
if dry_run then return_unit
else
Client_proto_context.save_contract
~force
cctxt
alias_name
contract
>>=? fun () -> return_unit));
command
~group
~desc:
"Display the threshold, public keys, and byte sequence to sign for a \
multisigned transfer."
(args3 bytes_only_switch arg_arg entrypoint_arg)
(prefixes ["prepare"; "multisig"; "transaction"; "on"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"multisig"
~desc:"name or address of the originated multisig contract"
@@ prefix "transferring"
@@ Client_proto_args.tez_param
~name:"qty"
~desc:"amount taken from source"
@@ prefix "to"
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"dst"
~desc:"name/literal of the destination contract"
@@ stop)
(fun (bytes_only, parameter, entrypoint)
(_, multisig_contract)
amount
(_, destination)
(cctxt : #Protocol_client_context.full) ->
let entrypoint = Option.value ~default:"default" entrypoint in
let parameter = Option.value ~default:"Unit" parameter in
Lwt.return @@ Micheline_parser.no_parsing_error
@@ Michelson_v1_parser.parse_expression parameter
>>=? fun {expanded = parameter; _} ->
get_parameter_type cctxt ~destination ~entrypoint
>>=? fun parameter_type ->
Client_proto_multisig.prepare_multisig_transaction
cctxt
~chain:cctxt#chain
~block:cctxt#block
~multisig_contract
~action:
(Client_proto_multisig.Transfer
{amount; destination; entrypoint; parameter_type; parameter})
()
>>=? fun prepared_command ->
return @@ prepare_command_display prepared_command bytes_only);
command
~group
~desc:
"Display the threshold, public keys, and byte sequence to sign for a \
multisigned lambda execution in a generic multisig contract."
(args1 bytes_only_switch)
(prefixes ["prepare"; "multisig"; "transaction"; "on"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"multisig"
~desc:"name or address of the originated multisig contract"
@@ prefixes ["running"; "lambda"]
@@ lambda_param () @@ stop)
(fun bytes_only
(_, multisig_contract)
lambda
(cctxt : #Protocol_client_context.full) ->
Lwt.return @@ Micheline_parser.no_parsing_error
@@ Michelson_v1_parser.parse_expression lambda
>>=? fun {expanded = lambda; _} ->
Client_proto_multisig.prepare_multisig_transaction
cctxt
~chain:cctxt#chain
~block:cctxt#block
~multisig_contract
~action:(Client_proto_multisig.Lambda lambda)
()
>>=? fun prepared_command ->
return @@ prepare_command_display prepared_command bytes_only);
command
~group
~desc:
"Display the threshold, public keys, and byte sequence to sign for a \
multisigned delegate change."
(args1 bytes_only_switch)
(prefixes ["prepare"; "multisig"; "transaction"; "on"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"multisig"
~desc:"name or address of the originated multisig contract"
@@ prefixes ["setting"; "delegate"; "to"]
@@ Client_keys.Public_key_hash.source_param
~name:"dlgt"
~desc:"new delegate of the new multisig contract"
@@ stop)
(fun bytes_only
(_, multisig_contract)
new_delegate
(cctxt : #Protocol_client_context.full) ->
Client_proto_multisig.prepare_multisig_transaction
cctxt
~chain:cctxt#chain
~block:cctxt#block
~multisig_contract
~action:(Client_proto_multisig.Change_delegate (Some new_delegate))
()
>>=? fun prepared_command ->
return @@ prepare_command_display prepared_command bytes_only);
command
~group
~desc:
"Display the threshold, public keys, and byte sequence to sign for a \
multisigned delegate withdraw."
(args1 bytes_only_switch)
(prefixes ["prepare"; "multisig"; "transaction"; "on"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"multisig"
~desc:"name or address of the originated multisig contract"
@@ prefixes ["withdrawing"; "delegate"]
@@ stop)
(fun bytes_only
(_, multisig_contract)
(cctxt : #Protocol_client_context.full) ->
Client_proto_multisig.prepare_multisig_transaction
cctxt
~chain:cctxt#chain
~block:cctxt#block
~multisig_contract
~action:(Client_proto_multisig.Change_delegate None)
()
>>=? fun prepared_command ->
return @@ prepare_command_display prepared_command bytes_only);
command
~group
~desc:
"Display the threshold, public keys, and byte sequence to sign for a \
multisigned change of keys and threshold."
(args1 bytes_only_switch)
(prefixes ["prepare"; "multisig"; "transaction"; "on"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"multisig"
~desc:"name or address of the originated multisig contract"
@@ prefixes ["setting"; "threshold"; "to"]
@@ threshold_param ()
@@ prefixes ["and"; "public"; "keys"; "to"]
@@ seq_of_param (public_key_param ()))
(fun bytes_only
(_, multisig_contract)
new_threshold
new_keys
(cctxt : #Protocol_client_context.full) ->
List.map_es
(fun (pk_uri, _) -> Client_keys.public_key pk_uri)
new_keys
>>=? fun keys ->
Client_proto_multisig.prepare_multisig_transaction
cctxt
~chain:cctxt#chain
~block:cctxt#block
~multisig_contract
~action:
(Client_proto_multisig.Change_keys (Z.of_int new_threshold, keys))
()
>>=? fun prepared_command ->
return @@ prepare_command_display prepared_command bytes_only);
command
~group
~desc:"Sign a transaction for a multisig contract."
(args2 arg_arg entrypoint_arg)
(prefixes ["sign"; "multisig"; "transaction"; "on"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"multisig"
~desc:"name or address of the originated multisig contract"
@@ prefix "transferring"
@@ Client_proto_args.tez_param
~name:"qty"
~desc:"amount taken from source"
@@ prefix "to"
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"dst"
~desc:"name/literal of the destination contract"
@@ prefixes ["using"; "secret"; "key"]
@@ secret_key_param () @@ stop)
(fun (parameter, entrypoint)
(_, multisig_contract)
amount
(_, destination)
sk
(cctxt : #Protocol_client_context.full) ->
let entrypoint = Option.value ~default:"default" entrypoint in
let parameter = Option.value ~default:"Unit" parameter in
Lwt.return @@ Micheline_parser.no_parsing_error
@@ Michelson_v1_parser.parse_expression parameter
>>=? fun {expanded = parameter; _} ->
get_parameter_type cctxt ~destination ~entrypoint
>>=? fun parameter_type ->
Client_proto_multisig.prepare_multisig_transaction
cctxt
~chain:cctxt#chain
~block:cctxt#block
~multisig_contract
~action:
(Client_proto_multisig.Transfer
{amount; destination; entrypoint; parameter_type; parameter})
()
>>=? fun prepared_command ->
Client_keys.sign cctxt sk prepared_command.bytes >>=? fun signature ->
return @@ Format.printf "%a@." Signature.pp signature);
command
~group
~desc:"Sign a lambda for a generic multisig contract."
no_options
(prefixes ["sign"; "multisig"; "transaction"; "on"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"multisig"
~desc:"name or address of the originated multisig contract"
@@ prefixes ["running"; "lambda"]
@@ lambda_param ()
@@ prefixes ["using"; "secret"; "key"]
@@ secret_key_param () @@ stop)
(fun ()
(_, multisig_contract)
lambda
sk
(cctxt : #Protocol_client_context.full) ->
Lwt.return @@ Micheline_parser.no_parsing_error
@@ Michelson_v1_parser.parse_expression lambda
>>=? fun {expanded = lambda; _} ->
Client_proto_multisig.prepare_multisig_transaction
cctxt
~chain:cctxt#chain
~block:cctxt#block
~multisig_contract
~action:(Lambda lambda)
()
>>=? fun prepared_command ->
Client_keys.sign cctxt sk prepared_command.bytes >>=? fun signature ->
return @@ Format.printf "%a@." Signature.pp signature);
command
~group
~desc:"Sign a delegate change for a multisig contract."
no_options
(prefixes ["sign"; "multisig"; "transaction"; "on"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"multisig"
~desc:"name or address of the originated multisig contract"
@@ prefixes ["setting"; "delegate"; "to"]
@@ Client_keys.Public_key_hash.source_param
~name:"dlgt"
~desc:"new delegate of the new multisig contract"
@@ prefixes ["using"; "secret"; "key"]
@@ secret_key_param () @@ stop)
(fun ()
(_, multisig_contract)
delegate
sk
(cctxt : #Protocol_client_context.full) ->
Client_proto_multisig.prepare_multisig_transaction
cctxt
~chain:cctxt#chain
~block:cctxt#block
~multisig_contract
~action:(Client_proto_multisig.Change_delegate (Some delegate))
()
>>=? fun prepared_command ->
Client_keys.sign cctxt sk prepared_command.bytes >>=? fun signature ->
return @@ Format.printf "%a@." Signature.pp signature);
command
~group
~desc:"Sign a delegate withdraw for a multisig contract."
no_options
(prefixes ["sign"; "multisig"; "transaction"; "on"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"multisig"
~desc:"name or address of the originated multisig contract"
@@ prefixes ["withdrawing"; "delegate"]
@@ prefixes ["using"; "secret"; "key"]
@@ secret_key_param () @@ stop)
(fun ()
(_, multisig_contract)
sk
(cctxt : #Protocol_client_context.full) ->
Client_proto_multisig.prepare_multisig_transaction
cctxt
~chain:cctxt#chain
~block:cctxt#block
~multisig_contract
~action:(Client_proto_multisig.Change_delegate None)
()
>>=? fun prepared_command ->
Client_keys.sign cctxt sk prepared_command.bytes >>=? fun signature ->
return @@ Format.printf "%a@." Signature.pp signature);
command
~group
~desc:
"Sign a change of public keys and threshold for a multisig contract."
no_options
(prefixes ["sign"; "multisig"; "transaction"; "on"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"multisig"
~desc:"name or address of the originated multisig contract"
@@ prefixes ["using"; "secret"; "key"]
@@ secret_key_param ()
@@ prefixes ["setting"; "threshold"; "to"]
@@ threshold_param ()
@@ prefixes ["and"; "public"; "keys"; "to"]
@@ seq_of_param (public_key_param ()))
(fun ()
(_, multisig_contract)
sk
new_threshold
new_keys
(cctxt : #Protocol_client_context.full) ->
List.map_es
(fun (pk_uri, _) -> Client_keys.public_key pk_uri)
new_keys
>>=? fun keys ->
Client_proto_multisig.prepare_multisig_transaction
cctxt
~chain:cctxt#chain
~block:cctxt#block
~multisig_contract
~action:
(Client_proto_multisig.Change_keys (Z.of_int new_threshold, keys))
()
>>=? fun prepared_command ->
Client_keys.sign cctxt sk prepared_command.bytes >>=? fun signature ->
return @@ Format.printf "%a@." Signature.pp signature);
command
~group
~desc:"Transfer tokens using a multisig contract."
transfer_options
(prefixes ["from"; "multisig"; "contract"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"multisig"
~desc:"name/literal of the multisig contract"
@@ prefix "transfer"
@@ Client_proto_args.tez_param
~name:"qty"
~desc:"amount taken from the multisig contract"
@@ prefix "to"
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"dst"
~desc:"name/literal of the destination contract"
@@ prefixes ["on"; "behalf"; "of"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"src"
~desc:"source calling the multisig contract"
@@ prefixes ["with"; "signatures"]
@@ seq_of_param (signature_param ()))
(fun ( fee,
dry_run,
verbose_signing,
gas_limit,
storage_limit,
counter,
parameter,
no_print_source,
minimal_fees,
minimal_nanotez_per_byte,
minimal_nanotez_per_gas_unit,
force_low_fee,
fee_cap,
burn_cap,
entrypoint )
(_, multisig_contract)
amount
(_, destination)
(_, source)
signatures
(cctxt : #Protocol_client_context.full) ->
let entrypoint = Option.value ~default:"default" entrypoint in
let parameter = Option.value ~default:"Unit" parameter in
Lwt.return @@ Micheline_parser.no_parsing_error
@@ Michelson_v1_parser.parse_expression parameter
>>=? fun {expanded = parameter; _} ->
get_parameter_type cctxt ~destination ~entrypoint
>>=? fun parameter_type ->
match Contract.is_implicit source with
| None ->
failwith
"only implicit accounts can be the source of a contract call"
| Some source -> (
Client_keys.get_key cctxt source >>=? fun (_, src_pk, src_sk) ->
let fee_parameter =
{
Injection.minimal_fees;
minimal_nanotez_per_byte;
minimal_nanotez_per_gas_unit;
force_low_fee;
fee_cap;
burn_cap;
}
in
Client_proto_multisig.call_multisig
cctxt
~chain:cctxt#chain
~block:cctxt#block
?confirmations:cctxt#confirmations
~dry_run
~verbose_signing
~fee_parameter
~source
?fee
~src_pk
~src_sk
~multisig_contract
~action:
(Client_proto_multisig.Transfer
{
amount;
destination;
entrypoint;
parameter_type;
parameter;
})
~signatures
~amount:Tez.zero
?gas_limit
?storage_limit
?counter
()
>>= Client_proto_context_commands.report_michelson_errors
~no_print_source
~msg:"transfer simulation failed"
cctxt
>>= function
| None -> return_unit
| Some (_res, _contracts) -> return_unit));
command
~group
~desc:"Run a lambda on a generic multisig contract."
non_transfer_options
(prefixes ["from"; "multisig"; "contract"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"multisig"
~desc:"name/literal of the multisig contract"
@@ prefixes ["run"; "lambda"]
@@ lambda_param ()
@@ prefixes ["on"; "behalf"; "of"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"src"
~desc:"source calling the multisig contract"
@@ prefixes ["with"; "signatures"]
@@ seq_of_param (signature_param ()))
(fun ( fee,
dry_run,
verbose_signing,
gas_limit,
storage_limit,
counter,
no_print_source,
minimal_fees,
minimal_nanotez_per_byte,
minimal_nanotez_per_gas_unit,
force_low_fee,
fee_cap,
burn_cap )
(_, multisig_contract)
lambda
(_, source)
signatures
(cctxt : #Protocol_client_context.full) ->
match Contract.is_implicit source with
| None ->
failwith
"only implicit accounts can be the source of a contract call"
| Some source -> (
Client_keys.get_key cctxt source >>=? fun (_, src_pk, src_sk) ->
let fee_parameter =
{
Injection.minimal_fees;
minimal_nanotez_per_byte;
minimal_nanotez_per_gas_unit;
force_low_fee;
fee_cap;
burn_cap;
}
in
Lwt.return @@ Micheline_parser.no_parsing_error
@@ Michelson_v1_parser.parse_expression lambda
>>=? fun {expanded = lambda; _} ->
Client_proto_multisig.call_multisig
cctxt
~chain:cctxt#chain
~block:cctxt#block
?confirmations:cctxt#confirmations
~dry_run
~verbose_signing
~fee_parameter
~source
?fee
~src_pk
~src_sk
~multisig_contract
~action:(Client_proto_multisig.Lambda lambda)
~signatures
~amount:Tez.zero
?gas_limit
?storage_limit
?counter
()
>>= Client_proto_context_commands.report_michelson_errors
~no_print_source
~msg:"transfer simulation failed"
cctxt
>>= function
| None -> return_unit
| Some (_res, _contracts) -> return_unit));
command
~group
~desc:"Change the delegate of a multisig contract."
non_transfer_options
(prefixes ["set"; "delegate"; "of"; "multisig"; "contract"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"multisig"
~desc:"name or address of the originated multisig contract"
@@ prefix "to"
@@ Client_keys.Public_key_hash.source_param
~name:"dlgt"
~desc:"new delegate of the new multisig contract"
@@ prefixes ["on"; "behalf"; "of"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"src"
~desc:"source calling the multisig contract"
@@ prefixes ["with"; "signatures"]
@@ seq_of_param (signature_param ()))
(fun ( fee,
dry_run,
verbose_signing,
gas_limit,
storage_limit,
counter,
no_print_source,
minimal_fees,
minimal_nanotez_per_byte,
minimal_nanotez_per_gas_unit,
force_low_fee,
fee_cap,
burn_cap )
(_, multisig_contract)
delegate
(_, source)
signatures
(cctxt : #Protocol_client_context.full) ->
match Contract.is_implicit source with
| None ->
failwith
"only implicit accounts can be the source of a contract call"
| Some source -> (
Client_keys.get_key cctxt source >>=? fun (_, src_pk, src_sk) ->
let fee_parameter =
{
Injection.minimal_fees;
minimal_nanotez_per_byte;
minimal_nanotez_per_gas_unit;
force_low_fee;
fee_cap;
burn_cap;
}
in
Client_proto_multisig.call_multisig
cctxt
~chain:cctxt#chain
~block:cctxt#block
?confirmations:cctxt#confirmations
~dry_run
~verbose_signing
~fee_parameter
~source
?fee
~src_pk
~src_sk
~multisig_contract
~action:(Client_proto_multisig.Change_delegate (Some delegate))
~signatures
~amount:Tez.zero
?gas_limit
?storage_limit
?counter
()
>>= Client_proto_context_commands.report_michelson_errors
~no_print_source
~msg:"transfer simulation failed"
cctxt
>>= function
| None -> return_unit
| Some (_res, _contracts) -> return_unit));
command
~group
~desc:"Withdraw the delegate of a multisig contract."
non_transfer_options
(prefixes ["withdraw"; "delegate"; "of"; "multisig"; "contract"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"multisig"
~desc:"name or address of the originated multisig contract"
@@ prefixes ["on"; "behalf"; "of"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"src"
~desc:"source calling the multisig contract"
@@ prefixes ["with"; "signatures"]
@@ seq_of_param (signature_param ()))
(fun ( fee,
dry_run,
verbose_signing,
gas_limit,
storage_limit,
counter,
no_print_source,
minimal_fees,
minimal_nanotez_per_byte,
minimal_nanotez_per_gas_unit,
force_low_fee,
fee_cap,
burn_cap )
(_, multisig_contract)
(_, source)
signatures
(cctxt : #Protocol_client_context.full) ->
match Contract.is_implicit source with
| None ->
failwith
"only implicit accounts can be the source of a contract call"
| Some source -> (
Client_keys.get_key cctxt source >>=? fun (_, src_pk, src_sk) ->
let fee_parameter =
{
Injection.minimal_fees;
minimal_nanotez_per_byte;
minimal_nanotez_per_gas_unit;
force_low_fee;
fee_cap;
burn_cap;
}
in
Client_proto_multisig.call_multisig
cctxt
~chain:cctxt#chain
~block:cctxt#block
?confirmations:cctxt#confirmations
~dry_run
~verbose_signing
~fee_parameter
~source
?fee
~src_pk
~src_sk
~multisig_contract
~action:(Client_proto_multisig.Change_delegate None)
~signatures
~amount:Tez.zero
?gas_limit
?storage_limit
?counter
()
>>= Client_proto_context_commands.report_michelson_errors
~no_print_source
~msg:"transfer simulation failed"
cctxt
>>= function
| None -> return_unit
| Some (_res, _contracts) -> return_unit));
command
~group
~desc:"Change public keys and threshold for a multisig contract."
non_transfer_options
(prefixes ["set"; "threshold"; "of"; "multisig"; "contract"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"multisig"
~desc:"name or address of the originated multisig contract"
@@ prefixes ["to"]
@@ threshold_param ()
@@ prefixes ["and"; "public"; "keys"; "to"]
@@ non_terminal_seq (public_key_param ()) ~suffix:["on"; "behalf"; "of"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"src"
~desc:"source calling the multisig contract"
@@ prefixes ["with"; "signatures"]
@@ seq_of_param (signature_param ()))
(fun ( fee,
dry_run,
verbose_signing,
gas_limit,
storage_limit,
counter,
no_print_source,
minimal_fees,
minimal_nanotez_per_byte,
minimal_nanotez_per_gas_unit,
force_low_fee,
fee_cap,
burn_cap )
(_, multisig_contract)
new_threshold
new_keys
(_, source)
signatures
(cctxt : #Protocol_client_context.full) ->
match Contract.is_implicit source with
| None ->
failwith
"only implicit accounts can be the source of a contract call"
| Some source -> (
Client_keys.get_key cctxt source >>=? fun (_, src_pk, src_sk) ->
List.map_es
(fun (pk_uri, _) -> Client_keys.public_key pk_uri)
new_keys
>>=? fun keys ->
let fee_parameter =
{
Injection.minimal_fees;
minimal_nanotez_per_byte;
minimal_nanotez_per_gas_unit;
force_low_fee;
fee_cap;
burn_cap;
}
in
Client_proto_multisig.call_multisig
cctxt
~chain:cctxt#chain
~block:cctxt#block
?confirmations:cctxt#confirmations
~dry_run
~verbose_signing
~fee_parameter
~source
?fee
~src_pk
~src_sk
~multisig_contract
~action:
(Client_proto_multisig.Change_keys
(Z.of_int new_threshold, keys))
~signatures
~amount:Tez.zero
?gas_limit
?storage_limit
?counter
()
>>= Client_proto_context_commands.report_michelson_errors
~no_print_source
~msg:"transfer simulation failed"
cctxt
>>= function
| None -> return_unit
| Some (_res, _contracts) -> return_unit));
(* This command is no longer necessary as Clic now supports non terminal
lists of parameters, however, it is kept for compatibility. *)
command
~group
~desc:
"Run a transaction described by a sequence of bytes on a multisig \
contract."
non_transfer_options
(prefixes ["run"; "transaction"]
@@ bytes_param
~name:"bytes"
~desc:
"the sequence of bytes to deserialize as a multisig action, can \
be obtained by one of the \"prepare multisig transaction\" \
commands"
@@ prefixes ["on"; "multisig"; "contract"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"multisig"
~desc:"name or address of the originated multisig contract"
@@ prefixes ["on"; "behalf"; "of"]
@@ Client_proto_contracts.ContractAlias.destination_param
~name:"src"
~desc:"source calling the multisig contract"
@@ prefixes ["with"; "signatures"]
@@ seq_of_param (signature_param ()))
(fun ( fee,
dry_run,
verbose_signing,
gas_limit,
storage_limit,
counter,
no_print_source,
minimal_fees,
minimal_nanotez_per_byte,
minimal_nanotez_per_gas_unit,
force_low_fee,
fee_cap,
burn_cap )
bytes
(_, multisig_contract)
(_, source)
signatures
(cctxt : #Protocol_client_context.full) ->
match Contract.is_implicit source with
| None ->
failwith
"only implicit accounts can be the source of a contract call"
| Some source -> (
Client_keys.get_key cctxt source >>=? fun (_, src_pk, src_sk) ->
let fee_parameter =
{
Injection.minimal_fees;
minimal_nanotez_per_byte;
minimal_nanotez_per_gas_unit;
force_low_fee;
fee_cap;
burn_cap;
}
in
Client_proto_multisig.call_multisig_on_bytes
cctxt
~chain:cctxt#chain
~block:cctxt#block
?confirmations:cctxt#confirmations
~dry_run
~verbose_signing
~fee_parameter
~source
?fee
~src_pk
~src_sk
~multisig_contract
~bytes
~signatures
~amount:Tez.zero
?gas_limit
?storage_limit
?counter
()
>>= Client_proto_context_commands.report_michelson_errors
~no_print_source
~msg:"transfer simulation failed"
cctxt
>>= function
| None -> return_unit
| Some (_res, _contracts) -> return_unit));
command
~group
~desc:"Show the hashes of the supported multisig contracts."
no_options
(fixed ["show"; "supported"; "multisig"; "hashes"])
(fun () _cctxt ->
Format.printf "Hashes of supported multisig contracts:@." ;
List.iter
(fun h -> Format.printf "%a@." Script_expr_hash.pp h)
Client_proto_multisig.known_multisig_hashes ;
return_unit);
command
~group
~desc:"Show the script of the recommended multisig contract."
no_options
(fixed ["show"; "multisig"; "script"])
(fun () _cctxt ->
let {Michelson_v1_parser.source; _} =
Michelson_v1_printer.unparse_toplevel
Client_proto_multisig.multisig_script
in
Format.printf "%s@." source ;
return_unit);
]
| (*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2019-2021 Nomadic Labs <contact@nomadic-labs.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
|
util.mli | (** A module containing some utility functions. *)
(** join strings together using command and "and" for the last element *)
val join: string list -> string
| (** A module containing some utility functions. *)
|
option.mli | (** Option Monad *)
open Module_types
(** Optional values *)
include MONAD with type 'a t = 'a option
val to_list: 'a t -> 'a list
val use: 'a t -> 'b -> ('a -> 'b) -> 'b
val fold: 'z -> ('a -> 'z) -> 'a t -> 'z
val has: 'a t -> bool
val value: 'a t -> 'a
val of_bool: bool -> unit t
val iter: ('a -> unit) -> 'a t -> unit
val fold_interval: ('a->int->'a t) -> 'a -> int -> int -> 'a t
val fold_array: ('a->'b->int->'a t) -> 'a -> 'b array -> 'a t
(** [fold_array f start arr] folds the function [f] over the array [arr] with
start value [start].
The function [f] maps an element of type ['a], an element of the array with
its position in the array into an element of type ['a]. *)
| (** Option Monad *)
|