[med-svn] [Git][med-team/pplacer][master] 3 commits: Pull and modify upstream PR to fix FTBFS
Nilesh Patra
gitlab at salsa.debian.org
Tue Dec 1 14:28:54 GMT 2020
Nilesh Patra pushed to branch master at Debian Med / pplacer
Commits:
8e46618a by Nilesh Patra at 2020-12-01T19:53:40+05:30
Pull and modify upstream PR to fix FTBFS
- - - - -
eda52ef7 by Nilesh Patra at 2020-12-01T19:54:03+05:30
Standards version: 4.5.1
- - - - -
7ba42a80 by Nilesh Patra at 2020-12-01T19:58:27+05:30
Update changelog
- - - - -
4 changed files:
- debian/changelog
- debian/control
- + debian/patches/PR-337.patch
- debian/patches/series
Changes:
=====================================
debian/changelog
=====================================
@@ -1,3 +1,12 @@
+pplacer (1.1~alpha19-4) unstable; urgency=medium
+
+ * Team Upload.
+ * Pull and modify upstream PR to fix FTBFS w/ new
+ version of libocamlgsl-ocaml-dev
+ * Standards version: 4.5.1
+
+ -- Nilesh Patra <npatra974 at gmail.com> Tue, 01 Dec 2020 19:54:07 +0530
+
pplacer (1.1~alpha19-3) unstable; urgency=medium
* Include /usr/share/ocaml/ocamlvars.mk
=====================================
debian/control
=====================================
@@ -17,7 +17,7 @@ Build-Depends: debhelper-compat (= 13),
libzip-ocaml-dev,
mcl,
libounit-ocaml-dev
-Standards-Version: 4.5.0
+Standards-Version: 4.5.1
Vcs-Browser: https://salsa.debian.org/med-team/pplacer
Vcs-Git: https://salsa.debian.org/med-team/pplacer.git
Homepage: https://github.com/matsen/pplacer
=====================================
debian/patches/PR-337.patch
=====================================
@@ -0,0 +1,1925 @@
+From d7a805ef8a140aaa6a92c9353f3423d21856dbfc Mon Sep 17 00:00:00 2001
+From: Connor McCoy <cmccoy at fhcrc.org>
+Date: Mon, 2 Jun 2014 10:20:20 -0700
+Subject: [PATCH 1/3] (hopefully) support compilation on older OS X
+
+---
+ myocamlbuild.ml | 6 +++++-
+ 1 file changed, 5 insertions(+), 1 deletion(-)
+
+--- a/common_src/alignment.ml
++++ b/common_src/alignment.ml
+@@ -190,14 +190,14 @@
+ CharMap.map (
+ fun like_vect ->
+ Linear_utils.alloc_l1_normalize like_vect) like_map)) in
+- let total = Gsl_vector.create ~init:0. nstates in
++ let total = Gsl.Vector.create ~init:0. nstates in
+ Array.iter (
+ fun (name, seq) ->
+ String.iter (
+ fun base ->
+ if base <> '-' && base <> '?' then
+ if CharMap.mem base no_missing_normed then
+- Gsl_vector.add total (CharMap.find base no_missing_normed)
++ Gsl.Vector.add total (CharMap.find base no_missing_normed)
+ else
+ failwith (Printf.sprintf "'%c' not a known base in %s!" base name)
+ ) seq
+@@ -209,7 +209,7 @@
+ "emper freqs: %a at ."
+ Linear_utils.ppr_gsl_vector
+ total;
+- let a = Gsl_vector.to_array total in
++ let a = Gsl.Vector.to_array total in
+ if Array.exists (fun x -> x < 1e-10) a then
+ dprintf
+ "\nWarning: zero-indexed state %d is zero in empirical frequency.\n\n"
+--- a/common_src/linear_utils.ml
++++ b/common_src/linear_utils.ml
+@@ -1,11 +1,11 @@
+-(* Some nicer ways to make and use Gsl_vectors and Gsl_matrices.
++(* Some nicer ways to make and use Gsl.Vectors and Gsl.Matrices.
+ *
+ * look at
+ http://www.gnu.org/software/gsl/manual/html_node/GSL-BLAS-Interface.html
+ and
+- http://oandrieu.nerim.net/ocaml/gsl/doc/Gsl_blas.html
++ http://oandrieu.nerim.net/ocaml/gsl/doc/Gsl.Blas.html
+ *
+- * Reminder: the Gsl_matrix is made with c_layout.
++ * Reminder: the Gsl.Matrix is made with c_layout.
+ *)
+
+ let tolerance = 1e-12
+@@ -17,44 +17,44 @@
+ (* *** Vector operations *** *)
+
+ let vec_init n f =
+- let v = Gsl_vector.create n in
++ let v = Gsl.Vector.create n in
+ for i=0 to n-1 do Array1.unsafe_set v i (f i) done;
+ v
+
+ let vec_fold_left f start v =
+ let x = ref start
+- and n = Gsl_vector.length v in
++ and n = Gsl.Vector.length v in
+ for i=0 to n-1 do
+ x := f !x (Array1.unsafe_get v i)
+ done;
+ !x
+
+ let vec_map f v =
+- vec_init (Gsl_vector.length v) (fun i -> f (Array1.unsafe_get v i))
++ vec_init (Gsl.Vector.length v) (fun i -> f (Array1.unsafe_get v i))
+
+ let vec_iter f a =
+- let n = Gsl_vector.length a in
++ let n = Gsl.Vector.length a in
+ for i=0 to n-1 do
+ f (Array1.unsafe_get a i)
+ done
+
+ let vec_iteri f a =
+- let n = Gsl_vector.length a in
++ let n = Gsl.Vector.length a in
+ for i=0 to n-1 do
+ f i (Array1.unsafe_get a i)
+ done
+
+ let vec_iter2 f a b =
+- let n = Gsl_vector.length a in
+- assert(n = Gsl_vector.length b);
++ let n = Gsl.Vector.length a in
++ assert(n = Gsl.Vector.length b);
+ for i=0 to n-1 do
+ f (Array1.unsafe_get a i) (Array1.unsafe_get b i)
+ done
+
+ let vec_map2_into f ~dst a b =
+- let n = Gsl_vector.length dst in
+- assert(n = Gsl_vector.length a);
+- assert(n = Gsl_vector.length b);
++ let n = Gsl.Vector.length dst in
++ assert(n = Gsl.Vector.length a);
++ assert(n = Gsl.Vector.length b);
+ for i=0 to n-1 do
+ Array1.unsafe_set dst i
+ (f (Array1.unsafe_get a i) (Array1.unsafe_get b i))
+@@ -66,7 +66,7 @@
+
+ (* Maximum element after applying f. *)
+ let vec_fmax_index f v =
+- assert(0 <> Gsl_vector.length v);
++ assert(0 <> Gsl.Vector.length v);
+ let max_val = ref (f v.{0})
+ and max_ind = ref 0
+ in
+@@ -84,7 +84,7 @@
+ let lp_norm p v =
+ assert(p > 0.);
+ let x = ref 0. in
+- for i=0 to (Gsl_vector.length v)-1 do
++ for i=0 to (Gsl.Vector.length v)-1 do
+ x := !x +. (v.{i} ** p)
+ done;
+ !x ** (1. /. p)
+@@ -94,13 +94,13 @@
+
+ (* normalize in place *)
+ let gen_normalize norm_fun v =
+- Gsl_vector.scale v (1. /. (norm_fun v))
++ Gsl.Vector.scale v (1. /. (norm_fun v))
+ let l1_normalize v = gen_normalize l1_norm v
+ let l2_normalize v = gen_normalize l2_norm v
+
+ let alloc_gen_normalize norm_fun v =
+- let normed = Gsl_vector.copy v in
+- Gsl_vector.scale normed (1. /. (norm_fun normed));
++ let normed = Gsl.Vector.copy v in
++ Gsl.Vector.scale normed (1. /. (norm_fun normed));
+ normed
+ let alloc_l1_normalize v = alloc_gen_normalize l1_norm v
+ let alloc_l2_normalize v = alloc_gen_normalize l2_norm v
+@@ -109,7 +109,7 @@
+ (* *** Matrix operations *** *)
+
+ let mat_init n_rows n_cols f =
+- let m = Gsl_matrix.create n_rows n_cols in
++ let m = Gsl.Matrix.create n_rows n_cols in
+ for i=0 to n_rows-1 do
+ let row = Array2.slice_left m i in
+ for j=0 to n_cols-1 do
+@@ -119,12 +119,12 @@
+ m
+
+ let mat_map f m =
+- let (rows, cols) = Gsl_matrix.dims m in
++ let (rows, cols) = Gsl.Matrix.dims m in
+ mat_init rows cols (fun i j -> f m.{i,j})
+
+ let diag v =
+- let n = Gsl_vector.length v in
+- let m = Gsl_matrix.create ~init:0. n n in
++ let n = Gsl.Vector.length v in
++ let m = Gsl.Matrix.create ~init:0. n n in
+ for i=0 to n-1 do
+ m.{i,i} <- v.{i}
+ done;
+@@ -132,7 +132,7 @@
+
+ (* information about vectors and matrices *)
+ let assert_symmetric m =
+- let n, cols = Gsl_matrix.dims m in
++ let n, cols = Gsl.Matrix.dims m in
+ assert(n = cols);
+ for i=0 to n-1 do
+ for j=i to n-1 do
+@@ -144,8 +144,8 @@
+ done
+
+ let alloc_transpose m =
+- let mt = Gsl_matrix.copy m in
+- Gsl_matrix.transpose_in_place mt;
++ let mt = Gsl.Matrix.copy m in
++ Gsl.Matrix.transpose_in_place mt;
+ mt
+
+ let mat_dim_asserting_square m =
+@@ -154,7 +154,7 @@
+ n
+
+ let qform m v =
+- let n = Gsl_vector.length v in
++ let n = Gsl.Vector.length v in
+ assert(n = Array2.dim1 m && n = Array2.dim2 m);
+ let x = ref 0. in
+ for i=0 to n-1 do
+@@ -177,48 +177,48 @@
+ !x
+
+ let mat_vec_mul dest a v =
+- Gsl_blas.gemv
+- Gsl_blas.NoTrans ~alpha:1.
++ Gsl.Blas.gemv
++ Gsl.Blas.NoTrans ~alpha:1.
+ ~a:a ~x:v ~beta:0. ~y:dest
+
+ let alloc_mat_vec_mul a v =
+- let (rows, midA) = Gsl_matrix.dims a
+- and midV = Gsl_vector.length v in
++ let (rows, midA) = Gsl.Matrix.dims a
++ and midV = Gsl.Vector.length v in
+ assert(midA = midV);
+- let w = Gsl_vector.create rows in
++ let w = Gsl.Vector.create rows in
+ mat_vec_mul w a v;
+ w
+
+ let mat_mat_mul dest a b =
+- Gsl_blas.gemm
+- ~ta:Gsl_blas.NoTrans ~tb:Gsl_blas.NoTrans
++ Gsl.Blas.gemm
++ ~ta:Gsl.Blas.NoTrans ~tb:Gsl.Blas.NoTrans
+ ~alpha:1. ~a:a ~b:b ~beta:0. ~c:dest
+
+ let alloc_mat_mat_mul a b =
+- let (rows, midA) = Gsl_matrix.dims a
+- and (midB, cols) = Gsl_matrix.dims b in
++ let (rows, midA) = Gsl.Matrix.dims a
++ and (midB, cols) = Gsl.Matrix.dims b in
+ assert(midA = midB);
+- let m = Gsl_matrix.create rows cols in
++ let m = Gsl.Matrix.create rows cols in
+ mat_mat_mul m a b;
+ m
+
+ (* gives a matrix such that the columns are the eigenvectors. *)
+ let symm_eigs m =
+ assert_symmetric m;
+- Gsl_eigen.symmv (`M(m))
++ Gsl.Eigen.symmv (`M(m))
+
+ (* pretty printers *)
+ let ppr_gsl_vector ff y =
+ Legacy.Format.fprintf ff "@[{";
+ Ppr.ppr_list_inners Legacy.Format.pp_print_float ff (
+- Array.to_list (Gsl_vector.to_array y));
++ Array.to_list (Gsl.Vector.to_array y));
+ Legacy.Format.fprintf ff "}@]"
+
+ let ppr_gsl_matrix ff m =
+- let nrows, _ = Gsl_matrix.dims m in
++ let nrows, _ = Gsl.Matrix.dims m in
+ Legacy.Format.fprintf ff "@[{";
+ for i=0 to nrows-1 do
+- ppr_gsl_vector ff (Gsl_matrix.row m i);
++ ppr_gsl_vector ff (Gsl.Matrix.row m i);
+ if i < nrows-1 then Legacy.Format.fprintf ff ";@ "
+ done;
+ Legacy.Format.fprintf ff "}@]"
+--- a/common_src/power_iteration.ml
++++ b/common_src/power_iteration.ml
+@@ -9,11 +9,11 @@
+
+ type eig =
+ {
+- v: Gsl_vector.vector;
++ v: Gsl.Vector.vector;
+ l: float;
+ }
+
+-let scale_by_l2 v = Gsl_vector.scale v (1. /. (Gsl_blas.nrm2 v))
++let scale_by_l2 v = Gsl.Vector.scale v (1. /. (Gsl.Blas.nrm2 v))
+
+ let big_entry_ratio v1 v2 =
+ let i = vec_fmax_index abs_float v2 in
+@@ -37,12 +37,12 @@
+
+ (* Find the top eigenvalue of a symmetric matrix by power iteration. *)
+ let top_eig m tol max_iter =
+- let (rows, cols) = Gsl_matrix.dims m in
++ let (rows, cols) = Gsl.Matrix.dims m in
+ assert(rows = cols);
+- let v = Gsl_vector.create ~init:1. rows in
+- let scratch = Gsl_vector.copy v in
++ let v = Gsl.Vector.create ~init:1. rows in
++ let scratch = Gsl.Vector.copy v in
+ let mat_vec_mul ~a =
+- Gsl_blas.symv Gsl_blas.Upper ~alpha:1. ~a ~beta:0. in
++ Gsl.Blas.symv Gsl.Blas.Upper ~alpha:1. ~a ~beta:0. in
+ let mul_and_scale x dst =
+ mat_vec_mul ~a:m ~x ~y:dst;
+ scale_by_l2 dst
+@@ -62,13 +62,13 @@
+
+ (* Calculates the outer product (scalar v v^T) and puts it in m. *)
+ let outer_product ?(scalar=1.) m v =
+- let len = Gsl_vector.length v in
+- let (n_rows, n_cols) = Gsl_matrix.dims m in
++ let len = Gsl.Vector.length v in
++ let (n_rows, n_cols) = Gsl.Matrix.dims m in
+ assert(n_rows = len && n_cols = len);
+ for i=0 to len-1 do
+ let row = Array2.slice_left m i in
+ Array1.blit v row; (* copy v to row *)
+- Gsl_vector.scale row (scalar *. v.{i});
++ Gsl.Vector.scale row (scalar *. v.{i});
+ done;;
+
+ let projector_of_eig m eig =
+@@ -76,15 +76,15 @@
+
+ (* Make an array of the top n eigs. *)
+ let top_eigs m tol max_iter n_eigs =
+- let m' = Gsl_matrix.copy m in
+- let proj = Gsl_matrix.copy m in
++ let m' = Gsl.Matrix.copy m in
++ let proj = Gsl.Matrix.copy m in
+ let rec aux n_left accu =
+ if n_left <= 0 then accu
+ else
+ let eig = top_eig m' tol max_iter in
+ projector_of_eig proj eig;
+ (* Subtract the projector from m'. *)
+- Gsl_matrix.sub m' proj;
++ Gsl.Matrix.sub m' proj;
+ aux (n_left - 1) (eig::accu)
+ in
+ Array.of_list (List.rev (aux n_eigs []))
+--- a/common_src/ppatteries.ml
++++ b/common_src/ppatteries.ml
+@@ -781,7 +781,7 @@
+ let exn_wrap f = Printexc.pass f ()
+
+ let () =
+- Gsl_error.init ();
++ Gsl.Error.init ();
+ Printexc.register_printer
+ (function
+ | Unix.Unix_error (errno, fn, param) ->
+--- a/pplacer_src/bootstrap.ml
++++ b/pplacer_src/bootstrap.ml
+@@ -10,7 +10,7 @@
+ let pqa = Array.of_list (Placerun.get_pqueries pr) in
+ let multip = Array.map Pquery.multiplicity pqa in
+ (* multa has the resampled multiplicity of each of the pqueries. *)
+- let multa = Gsl_randist.multinomial
++ let multa = Gsl.Randist.multinomial
+ rng
+ (int_of_float (Array.fold_left ( +. ) 0. multip)) (* get total multiplicity *)
+ multip
+--- a/pplacer_src/core.ml
++++ b/pplacer_src/core.ml
+@@ -87,11 +87,11 @@
+ and prior_fun =
+ match prior with
+ | Uniform_prior -> (fun _ _ -> 1.)
+- | Flat_exp_prior mean -> fun _ -> Gsl_randist.exponential_pdf ~mu:mean
++ | Flat_exp_prior mean -> fun _ -> Gsl.Randist.exponential_pdf ~mu:mean
+ | Informative_exp_prior mean_map ->
+- fun id -> Gsl_randist.exponential_pdf ~mu:(IntMap.find id mean_map)
++ fun id -> Gsl.Randist.exponential_pdf ~mu:(IntMap.find id mean_map)
+ and ref_length = Alignment.length ref_align in
+- let utilv_nsites = Gsl_vector.create ref_length in
++ let utilv_nsites = Gsl.Vector.create ref_length in
+ (* Set up the number of pitches and strikes according to the prefs. *)
+ let (t_max_pitches, t_max_strikes) =
+ if fantasy prefs <> 0. then
+@@ -271,7 +271,7 @@
+ in
+ let safe_ml_optimize_location tol loc =
+ try ml_optimize_location tol loc with
+- | Gsl_error.Gsl_exn(_,_) -> begin
++ | Gsl.Error.Gsl_exn(_,_) -> begin
+ (* try again starting with default branch lengths *)
+ tt_edges_default loc;
+ ml_optimize_location tol loc
+@@ -286,7 +286,7 @@
+ begin match begin
+ try
+ Some (safe_ml_optimize_location (initial_tolerance prefs) loc)
+- with Gsl_error.Gsl_exn(_,warn_str) ->
++ with Gsl.Error.Gsl_exn(_,warn_str) ->
+ dprintf
+ "Warning: GSL problem with location %d for query %s; Skipped with warning \"%s\".\n"
+ loc
+@@ -359,7 +359,7 @@
+ try
+ (loc, safe_ml_optimize_location final_tolerance loc)
+ with
+- | Gsl_error.Gsl_exn(_,warn_str) ->
++ | Gsl.Error.Gsl_exn(_,warn_str) ->
+ dprintf
+ "Warning: GSL problem with final branch length optimization for location %d. %s\n"
+ loc
+--- a/pplacer_src/diagd.ml
++++ b/pplacer_src/diagd.ml
+@@ -25,33 +25,33 @@
+ open Linear_utils
+
+ let mm = alloc_mat_mat_mul
+-let get1 a i = Bigarray.Array1.unsafe_get (a:Gsl_vector.vector) i
+-let set1 a i = Bigarray.Array1.unsafe_set (a:Gsl_vector.vector) i
++let get1 a i = Bigarray.Array1.unsafe_get (a:Gsl.Vector.vector) i
++let set1 a i = Bigarray.Array1.unsafe_set (a:Gsl.Vector.vector) i
+
+
+ (* the setup is that X diag(\lambda) X^{-1} is the matrix of interest. *)
+ type t =
+ {
+- x: Gsl_matrix.matrix;
+- l: Gsl_vector.vector; (* lambda *)
+- xit: Gsl_matrix.matrix; (* x inverse transpose *)
+- util: Gsl_vector.vector;
++ x: Gsl.Matrix.matrix;
++ l: Gsl.Vector.vector; (* lambda *)
++ xit: Gsl.Matrix.matrix; (* x inverse transpose *)
++ util: Gsl.Vector.vector;
+ }
+
+ let make ~x ~l ~xit =
+- let n = Gsl_vector.length l in
+- assert((n,n) = Gsl_matrix.dims x);
+- assert((n,n) = Gsl_matrix.dims xit);
++ let n = Gsl.Vector.length l in
++ assert((n,n) = Gsl.Matrix.dims x);
++ assert((n,n) = Gsl.Matrix.dims xit);
+ {
+ x; l; xit;
+- util = Gsl_vector.create n;
++ util = Gsl.Vector.create n;
+ }
+
+
+ (* *** utils *** *)
+
+-let dim dd = Gsl_vector.length dd.l
+-let matrix_of_same_dims dd = Gsl_matrix.create (dim dd) (dim dd)
++let dim dd = Gsl.Vector.length dd.l
++let matrix_of_same_dims dd = Gsl.Matrix.create (dim dd) (dim dd)
+
+
+ (* *** into matrices *** *)
+@@ -64,7 +64,7 @@
+ (* return an exponentiated matrix *)
+ let to_exp dd bl =
+ let dst = matrix_of_same_dims dd in
+- for i=0 to (Gsl_vector.length dd.l)-1 do
++ for i=0 to (Gsl.Vector.length dd.l)-1 do
+ set1 dd.util i (exp (bl *. (get1 dd.l i)))
+ done;
+ Linear.dediagonalize dst dd.x dd.util dd.xit;
+@@ -82,7 +82,7 @@
+ | None -> fun _ -> true (* no mask, do everything *)
+ | Some m -> fun r -> m.(r) = true (* compute if specified *)
+ in
+- let n = Gsl_vector.length dd.l in
++ let n = Gsl.Vector.length dd.l in
+ try
+ Tensor.set_all dst 0.;
+ for r=0 to (Array.length rates)-1 do
+@@ -138,10 +138,10 @@
+ * resulting matrix gets multiplied on the left by something that zeroes out
+ * the ith row for every i that has a zero entry in pi. *)
+ let b_of_exchangeable_pair r pi =
+- let n = Gsl_vector.length pi in
++ let n = Gsl.Vector.length pi in
+ mat_init n n
+ (fun i j ->
+- if i <> j then Gsl_matrix.get r i j
++ if i <> j then Gsl.Matrix.get r i j
+ else
+ (* r_ii = - (pi_i)^{-1} \sum_{k \ne i} r_ki pi_k *)
+ (let total = ref 0. in
+@@ -159,12 +159,12 @@
+ let q = to_matrix dd in
+ let rate = ref 0. in
+ for i=0 to (dim dd)-1 do
+- rate := !rate -. q.{i,i} *. (Gsl_vector.get pi i)
++ rate := !rate -. q.{i,i} *. (Gsl.Vector.get pi i)
+ done;
+ !rate
+
+ let normalize_rate dd pi =
+- Gsl_vector.scale dd.l (1. /. (find_rate dd pi))
++ Gsl.Vector.scale dd.l (1. /. (find_rate dd pi))
+
+ let normed_of_exchangeable_pair m pi =
+ let dd = of_exchangeable_pair m pi in
+--- a/pplacer_src/gamma.ml
++++ b/pplacer_src/gamma.ml
+@@ -19,10 +19,10 @@
+ *
+ * y < C(epsilon) <=> Cinv(y) < epsilon *)
+
+- if y < Gsl_cdf.gamma_P ~a:alpha ~b:beta ~x:epsilon then
++ if y < Gsl.Cdf.gamma_P ~a:alpha ~b:beta ~x:epsilon then
+ 0.
+ else
+- Gsl_cdf.gamma_Pinv ~a:alpha ~b:beta ~p:y
++ Gsl.Cdf.gamma_Pinv ~a:alpha ~b:beta ~p:y
+
+ let make_mean_one v =
+ let tot = Array.fold_left (+.) 0. v
+@@ -37,7 +37,7 @@
+ * which is what Yang calls the incomplete gamma function.
+ * We use his terminology here.
+ *)
+-let incomplete_gamma ~alpha x = Gsl_sf.gamma_inc_P alpha x
++let incomplete_gamma ~alpha x = Gsl.Sf.gamma_inc_P alpha x
+
+ let int_div i j = (float_of_int i) /. (float_of_int j)
+
+--- a/pplacer_src/gaussian_approx.ml
++++ b/pplacer_src/gaussian_approx.ml
+@@ -89,7 +89,7 @@
+ (* The sampling routine. *)
+ let sample_gaussians () =
+ Array.iteri
+- (fun i _ -> sample.(i) <- Gsl_randist.gaussian rng ~sigma:1.)
++ (fun i _ -> sample.(i) <- Gsl.Randist.gaussian rng ~sigma:1.)
+ sample
+ in
+ (* Go "past" a labeled mass. *)
+--- a/pplacer_src/gcat_model.ml
++++ b/pplacer_src/gcat_model.ml
+@@ -31,7 +31,7 @@
+ struct
+
+ type t = {
+- statd: Gsl_vector.vector;
++ statd: Gsl.Vector.vector;
+ diagdq: Diagd.t;
+ seq_type: Alignment.seq_type;
+ rates: float array;
+@@ -186,7 +186,7 @@
+ let prep_constant_rate_glv_from_lv_arr g lv_arr =
+ assert(lv_arr <> [||]);
+ assert(get_n_sites g = Array.length lv_arr);
+- assert(get_n_states g = Gsl_vector.length lv_arr.(0));
++ assert(get_n_states g = Gsl.Vector.length lv_arr.(0));
+ seti g
+ (fun _ -> 0)
+ (fun ~site ~state -> lv_arr.(site).{state})
+@@ -201,13 +201,13 @@
+ (* cycle through sites *)
+ for site=0 to n_sites-1 do
+ let _, twoexp = Matrix.slice_left g.a site
+- |> Gsl_vector.max
++ |> Gsl.Vector.max
+ |> frexp
+ in
+ (* now scale if it's needed *)
+ if twoexp < min_allowed_twoexp then begin
+ (* take the negative so that we "divide" by 2^our_twoexp *)
+- Gsl_vector.scale
++ Gsl.Vector.scale
+ (Matrix.slice_left g.a site)
+ (of_twoexp (-twoexp));
+ (* bring the exponent out *)
+@@ -273,9 +273,9 @@
+ let n_sites = get_n_sites g
+ and n_states = get_n_states g in
+ let summary = Array.make n_sites initial
+- and u = Gsl_vector.create ~init:0. n_states in
++ and u = Gsl.Vector.create ~init:0. n_states in
+ for site=0 to n_sites-1 do
+- Gsl_vector.set_all u 0.;
++ Gsl.Vector.set_all u 0.;
+ for state=0 to n_states-1 do
+ u.{state} <- u.{state} +. (get_a ~site ~state g)
+ done;
+@@ -311,7 +311,7 @@
+ assert(lv_arr <> [||]);
+ let g = Glv.make
+ ~n_sites:(Array.length lv_arr)
+- ~n_states:(Gsl_vector.length lv_arr.(0)) in
++ ~n_states:(Gsl.Vector.length lv_arr.(0)) in
+ Glv.prep_constant_rate_glv_from_lv_arr g lv_arr;
+ g
+
+@@ -447,7 +447,7 @@
+ val site_log_like_arr:
+ Model.t ->
+ Newick_gtree.t ->
+- Gsl_vector.vector array IntMap.t ->
++ Gsl.Vector.vector array IntMap.t ->
+ Model.Glv.t array -> Model.Glv.t array -> float array
+ end = LSM(Model)
+
+--- a/pplacer_src/glvm.ml
++++ b/pplacer_src/glvm.ml
+@@ -16,7 +16,7 @@
+ val seq_type: t -> Alignment.seq_type
+ val rates: t -> float array
+ val refine: t -> int -> Newick_gtree.t ->
+- Gsl_vector.vector array IntMap.t -> glv_t array -> glv_t array -> unit
++ Gsl.Vector.vector array IntMap.t -> glv_t array -> glv_t array -> unit
+ val check: t -> Alignment.t -> unit
+ val mask_sites: t -> bool array -> unit
+ val write: unit IO.output -> t -> unit
+@@ -33,20 +33,20 @@
+ val fp_classify: t -> fpclass
+ val mask_into: bool array -> src:t -> dst:t -> unit
+ val perhaps_pull_exponent: int -> t -> unit
+- val masked_logdot: Gsl_vector.vector -> t -> t -> Linear.uint16_vector -> float
+- val bounded_logdot: Gsl_vector.vector -> t -> t -> int -> int -> float
+- val logdot: Gsl_vector.vector -> t -> t -> float
++ val masked_logdot: Gsl.Vector.vector -> t -> t -> Linear.uint16_vector -> float
++ val bounded_logdot: Gsl.Vector.vector -> t -> t -> int -> int -> float
++ val logdot: Gsl.Vector.vector -> t -> t -> float
+ val listwise_prod: t -> t list -> unit
+- val prep_constant_rate_glv_from_lv_arr: t -> Gsl_vector.vector array -> unit
+- val summarize_post: (Gsl_vector.vector -> 'a) -> 'a -> t -> 'a array
++ val prep_constant_rate_glv_from_lv_arr: t -> Gsl.Vector.vector array -> unit
++ val summarize_post: (Gsl.Vector.vector -> 'a) -> 'a -> t -> 'a array
+ end
+
+ val make_glv: t -> n_sites:int -> Glv.t
+ val mmap_glv_arrays:
+ t -> Unix.file_descr -> bool -> int -> int -> n_sites:int -> Glv.t array array
+ val size_of_glv_arrays: t -> int -> int -> n_sites:int -> int
+- val make_constant_rate_glv_from_lv_arr: t -> Gsl_vector.vector array -> Glv.t
+- val log_like3: t -> Gsl_vector.vector -> Glv.t -> Glv.t -> Glv.t -> float
++ val make_constant_rate_glv_from_lv_arr: t -> Gsl.Vector.vector array -> Glv.t
++ val log_like3: t -> Gsl.Vector.vector -> Glv.t -> Glv.t -> Glv.t -> float
+ val site_log_like_arr3: t -> Glv.t -> Glv.t -> Glv.t -> float array
+ val slow_log_like3: t -> Glv.t -> Glv.t -> Glv.t -> float
+ val evolve_into: t -> ?reind_arr:int array -> dst:Glv.t -> src:Glv.t -> float -> unit
+--- a/pplacer_src/gmix_model.ml
++++ b/pplacer_src/gmix_model.ml
+@@ -8,7 +8,7 @@
+ struct
+
+ type t = {
+- statd: Gsl_vector.vector;
++ statd: Gsl.Vector.vector;
+ diagdq: Diagd.t;
+ seq_type: Alignment.seq_type;
+ rates: float array;
+@@ -150,7 +150,7 @@
+ let prep_constant_rate_glv_from_lv_arr g lv_arr =
+ assert(lv_arr <> [||]);
+ assert(get_n_sites g = Array.length lv_arr);
+- assert(get_n_states g = Gsl_vector.length lv_arr.(0));
++ assert(get_n_states g = Gsl.Vector.length lv_arr.(0));
+ seti g
+ (fun _ -> 0)
+ (fun ~rate:_ ~site ~state ->
+@@ -171,14 +171,14 @@
+ (* first find the max twoexp *)
+ for rate=0 to n_rates-1 do
+ let s = BA3.slice_left_1 g.a rate site in
+- let (_, twoexp) = frexp (Gsl_vector.max s) in
++ let (_, twoexp) = frexp (Gsl.Vector.max s) in
+ if twoexp > !max_twoexp then max_twoexp := twoexp
+ done;
+ (* now scale if it's needed *)
+ if !max_twoexp < min_allowed_twoexp then begin
+ for rate=0 to n_rates-1 do
+ (* take the negative so that we "divide" by 2^our_twoexp *)
+- Gsl_vector.scale
++ Gsl.Vector.scale
+ (BA3.slice_left_1 g.a rate site)
+ (of_twoexp (-(!max_twoexp)));
+ done;
+@@ -244,9 +244,9 @@
+ and n_states = get_n_states g
+ and n_rates = get_n_rates g in
+ let summary = Array.make n_sites initial
+- and u = Gsl_vector.create ~init:0. n_states in
++ and u = Gsl.Vector.create ~init:0. n_states in
+ for site=0 to n_sites-1 do
+- Gsl_vector.set_all u 0.;
++ Gsl.Vector.set_all u 0.;
+ for rate=0 to n_rates-1 do
+ for state=0 to n_states-1 do
+ u.{state} <- u.{state} +. (get_a ~rate ~site ~state g)
+@@ -290,7 +290,7 @@
+ let g = Glv.make
+ ~n_rates:(n_rates model)
+ ~n_sites:(Array.length lv_arr)
+- ~n_states:(Gsl_vector.length lv_arr.(0)) in
++ ~n_states:(Gsl.Vector.length lv_arr.(0)) in
+ Glv.prep_constant_rate_glv_from_lv_arr g lv_arr;
+ g
+
+--- a/pplacer_src/guppy_cmdobjs.ml
++++ b/pplacer_src/guppy_cmdobjs.ml
+@@ -129,12 +129,12 @@
+
+ method private set_default_seed =
+ let seed = fv seed in
+- Gsl_rng.set_default_seed (Nativeint.of_int seed);
++ Gsl.Rng.set_default_seed (Nativeint.of_int seed);
+ Random.init seed
+
+ method private rng =
+ self#set_default_seed;
+- Gsl_rng.make Gsl_rng.KNUTHRAN2002
++ Gsl.Rng.make Gsl.Rng.KNUTHRAN2002
+
+ method private random_state =
+ Random.State.make [| fv seed |]
+@@ -717,7 +717,7 @@
+ and n_leaves = fvo leaf_cutoff
+ and max_adcl = fvo adcl_cutoff in
+ (* setting the default seed will affect C code, so this sets PAM's seed
+- * even though PAM gets a Gsl_rng.t through C. *)
++ * even though PAM gets a Gsl.Rng.t through C. *)
+ self#set_default_seed;
+ Voronoi.Full.csv_log :=
+ fvo soln_log
+--- a/pplacer_src/guppy_kr.ml
++++ b/pplacer_src/guppy_kr.ml
+@@ -15,7 +15,7 @@
+ let shuffle rng a =
+ let swap i j = let x = a.(i) in a.(i) <- a.(j); a.(j) <- x in
+ for i = Array.length a - 1 downto 1 do
+- swap i (Gsl_rng.uniform_int rng (i+1))
++ swap i (Gsl.Rng.uniform_int rng (i+1))
+ done
+
+ (* just calculate the fraction of elements of a which are geq x.
+--- a/pplacer_src/guppy_lpca.ml
++++ b/pplacer_src/guppy_lpca.ml
+@@ -5,9 +5,9 @@
+
+ (* Normalize the rows of a matrix m to unit vectors. *)
+ let norm_rows m =
+- let n_rows, _ = Gsl_matrix.dims m in
++ let n_rows, _ = Gsl.Matrix.dims m in
+ for i=0 to (n_rows-1) do
+- Linear_utils.l2_normalize (Gsl_matrix.row m i);
++ Linear_utils.l2_normalize (Gsl.Matrix.row m i);
+ done
+
+ (* Compute the n largest singular values of a matrix m (or its transpose) as
+@@ -16,17 +16,17 @@
+ for simplicity. *)
+ let singular_values ~trans m n =
+ let real c =
+- let open Gsl_complex in
++ let open Gsl.Gsl_complex in
+ c.re
+ in
+- let n_rows, n_cols = Gsl_matrix.dims m in
++ let n_rows, n_cols = Gsl.Matrix.dims m in
+ let n_mm, ta, tb =
+- if trans then (n_rows, Gsl_blas.NoTrans, Gsl_blas.Trans) else (n_cols, Gsl_blas.Trans, Gsl_blas.NoTrans)
++ if trans then (n_rows, Gsl.Blas.NoTrans, Gsl.Blas.Trans) else (n_cols, Gsl.Blas.Trans, Gsl.Blas.NoTrans)
+ in
+- let mm = Gsl_matrix.create n_mm n_mm in
+- Gsl_blas.gemm ~ta ~tb ~alpha:1. ~a:m ~b:m ~beta:0. ~c:mm;
+- let eval_c = Gsl_eigen.nonsymm ~protect:false (`M(mm)) in
+- let eval = Array.map real (Gsl_vector_complex.to_array eval_c) in
++ let mm = Gsl.Matrix.create n_mm n_mm in
++ Gsl.Blas.gemm ~ta ~tb ~alpha:1. ~a:m ~b:m ~beta:0. ~c:mm;
++ let eval_c = Gsl.Eigen.nonsymm ~protect:false (`M(mm)) in
++ let eval = Array.map real (Gsl.Vector_complex.to_array eval_c) in
+ Array.sort (flip compare) eval;
+ Array.map sqrt (Array.sub eval 0 n)
+
+@@ -54,21 +54,21 @@
+ Lpca.gen_data sl t
+
+ method private check_data data write_n =
+- let fal = Array.to_list (Gsl_matrix.to_arrays data.fplf) in
++ let fal = Array.to_list (Gsl.Matrix.to_arrays data.fplf) in
+ self#check_uniqueness fal write_n
+
+ method private gen_pca ~use_raw_eval ~scale ~symmv n_components data _ =
+- let (eval, evect) = Pca.gen_pca ~use_raw_eval ~scale ~symmv n_components (Gsl_matrix.to_arrays data.fplf) in
++ let (eval, evect) = Pca.gen_pca ~use_raw_eval ~scale ~symmv n_components (Gsl.Matrix.to_arrays data.fplf) in
+ (* Populate the edge-averaged e x s matrix AF from its
+ IntMap encoding. See eq:f_tilde. *)
+- let af = Gsl_matrix.of_arrays (Array.of_list (List.map Gsl_vector.to_array (List.of_enum (IntMap.values data.af))))
+- and w' = Gsl_matrix.of_arrays evect in
+- let n_edges, _ = Gsl_matrix.dims af in
+- let afw = Gsl_matrix.create n_edges n_components in
++ let af = Gsl.Matrix.of_arrays (Array.of_list (List.map Gsl.Vector.to_array (List.of_enum (IntMap.values data.af))))
++ and w' = Gsl.Matrix.of_arrays evect in
++ let n_edges, _ = Gsl.Matrix.dims af in
++ let afw = Gsl.Matrix.create n_edges n_components in
+ (* Compute the edge-averaged eigenvectors. *)
+- Gsl_blas.gemm ~ta:Gsl_blas.NoTrans ~tb:Gsl_blas.Trans ~alpha:1. ~a:af ~b:w' ~beta:0. ~c:afw;
+- let afw' = Gsl_matrix.create n_components n_edges in
+- Gsl_matrix.transpose afw' afw;
++ Gsl.Blas.gemm ~ta:Gsl.Blas.NoTrans ~tb:Gsl.Blas.Trans ~alpha:1. ~a:af ~b:w' ~beta:0. ~c:afw;
++ let afw' = Gsl.Matrix.create n_components n_edges in
++ Gsl.Matrix.transpose afw' afw;
+ (* Normalize the eigenvectors and the edge-averaged eigenvectors to unit
+ length. *)
+ norm_rows w';
+@@ -83,12 +83,12 @@
+ (*
+ let weighting, criterion = self#mass_opts in
+ let sufa = singular_values ~trans:false data.ufl n_components
+- and sua = singular_values ~trans:true (Gsl_matrix.of_arrays (Array.of_list (List.map (self#splitify_placerun_nx weighting criterion) prl))) n_components in
++ and sua = singular_values ~trans:true (Gsl.Matrix.of_arrays (Array.of_list (List.map (self#splitify_placerun_nx weighting criterion) prl))) n_components in
+ let sfa = Array.map2 (/.) sufa sua in
+- Array.iteri (fun i x -> Gsl_vector.scale (Gsl_matrix.row w' i) (1. /. x)) sfa;
++ Array.iteri (fun i x -> Gsl.Vector.scale (Gsl.Matrix.row w' i) (1. /. x)) sfa;
+ *)
+- let norm_evect = Gsl_matrix.to_arrays w'
+- and edge_evect = Gsl_matrix.to_arrays afw' in
++ let norm_evect = Gsl.Matrix.to_arrays w'
++ and edge_evect = Gsl.Matrix.to_arrays afw' in
+ { eval; evect = norm_evect; edge_evect }
+
+ method private post_pca result data prl =
+@@ -134,7 +134,7 @@
+ (prefix^".proj")
+ (List.combine
+ names
+- (List.map (fun d -> Array.map (Pca.dot d) vects) (Array.to_list (Gsl_matrix.to_arrays data.ufl))))
++ (List.map (fun d -> Array.map (Pca.dot d) vects) (Array.to_list (Gsl.Matrix.to_arrays data.ufl))))
+ in
+
+ write_results result.eval result.evect prefix;
+--- a/pplacer_src/guppy_pmlpca.ml
++++ b/pplacer_src/guppy_pmlpca.ml
+@@ -5,37 +5,37 @@
+
+ (* Multiplication of matrices by diagonal vectors on left and right sides. The
+ * examples below are based on:
+-let vd = Gsl_vector.of_array [|1.; 2.; 3.;|];;
++let vd = Gsl.Vector.of_array [|1.; 2.; 3.;|];;
+ let faa = [| [| 2.; 1.; 5.; |]; [| 2.; 4.; 0.; |] |];;
+ *)
+
+ (*
+-let m = Gsl_matrix.of_arrays faa;;
++let m = Gsl.Matrix.of_arrays faa;;
+ left_diag_mul_mat vd m;;
+-- : Gsl_matrix.matrix = {{2.; 1.; 5.}; {4.; 8.; 0.}}
++- : Gsl.Matrix.matrix = {{2.; 1.; 5.}; {4.; 8.; 0.}}
+ *)
+ let left_diag_mul_mat vd m =
+- for i=0 to (fst (Gsl_matrix.dims m))-1 do
+- Gsl_vector.scale (Gsl_matrix.row m i) vd.{i}
++ for i=0 to (fst (Gsl.Matrix.dims m))-1 do
++ Gsl.Vector.scale (Gsl.Matrix.row m i) vd.{i}
+ done
+
+ (*
+-let m = Gsl_matrix.of_arrays faa;;
++let m = Gsl.Matrix.of_arrays faa;;
+ right_diag_mul_mat m vd;;
+-- : Gsl_matrix.matrix = {{2.; 2.; 15.}; {2.; 8.; 0.}}
++- : Gsl.Matrix.matrix = {{2.; 2.; 15.}; {2.; 8.; 0.}}
+ *)
+ let right_diag_mul_mat m vd =
+- for i=0 to (fst (Gsl_matrix.dims m))-1 do
+- Gsl_vector.mul (Gsl_matrix.row m i) vd
++ for i=0 to (fst (Gsl.Matrix.dims m))-1 do
++ Gsl.Vector.mul (Gsl.Matrix.row m i) vd
+ done
+
+ (*
+-let va = Array.map Gsl_vector.of_array faa;;
++let va = Array.map Gsl.Vector.of_array faa;;
+ right_diag_mul_va va vd;;
+-- : Gsl_vector.vector array = [|{2.; 2.; 15.}; {2.; 8.; 0.}|]
++- : Gsl.Vector.vector array = [|{2.; 2.; 15.}; {2.; 8.; 0.}|]
+ *)
+ let right_diag_mul_va va vd =
+- Array.iter (fun v -> Gsl_vector.mul v vd) va
++ Array.iter (fun v -> Gsl.Vector.mul v vd) va
+
+ type epca_result = { eval: float array; evect: float array array }
+
+@@ -65,20 +65,20 @@
+
+ method private gen_pca ~use_raw_eval ~scale ~symmv write_n data prl =
+ let _ = use_raw_eval in
+- let faa_z = Gsl_matrix.of_arrays (Array.of_list data.edge_diff) in
+- let n_samples, n_edges = Gsl_matrix.dims faa_z in
+- let tmp = Gsl_matrix.create n_edges n_samples in
+- Gsl_matrix.transpose tmp faa_z;
++ let faa_z = Gsl.Matrix.of_arrays (Array.of_list data.edge_diff) in
++ let n_samples, n_edges = Gsl.Matrix.dims faa_z in
++ let tmp = Gsl.Matrix.create n_edges n_samples in
++ Gsl.Matrix.transpose tmp faa_z;
+ for i=0 to n_edges-1 do
+- let col = Gsl_matrix.row tmp i in
+- Gsl_vector.add_constant col (-. Lpca.vec_mean col);
++ let col = Gsl.Matrix.row tmp i in
++ Gsl.Vector.add_constant col (-. Lpca.vec_mean col);
+ done;
+- Gsl_matrix.transpose faa_z tmp;
++ Gsl.Matrix.transpose faa_z tmp;
+ let inv_sqrt_smo = 1. /. (sqrt (float (n_samples - 1))) in
+- Gsl_matrix.scale faa_z inv_sqrt_smo;
+- let faa = Gsl_matrix.to_arrays faa_z in
++ Gsl.Matrix.scale faa_z inv_sqrt_smo;
++ let faa = Gsl.Matrix.to_arrays faa_z in
+ let m = Pca.covariance_matrix ~scale faa
+- and d = Gsl_vector.create ~init:0. n_edges
++ and d = Gsl.Vector.create ~init:0. n_edges
+ and ref_tree = self#get_ref_tree prl in
+ for i=0 to n_edges-1 do
+ d.{i} <- (Gtree.get_bl ref_tree i);
+@@ -96,7 +96,7 @@
+ * However, according to length PCA we must multiply on the right by d,
+ * which ends up just being right multiplication by d_root. *)
+ right_diag_mul_va u d_root;
+- { eval = l; evect = Array.map Gsl_vector.to_array u }
++ { eval = l; evect = Array.map Gsl.Vector.to_array u }
+
+ method private post_pca result data prl =
+ let combol = (List.combine (Array.to_list result.eval) (Array.to_list result.evect))
+--- a/pplacer_src/guppy_rarefy.ml
++++ b/pplacer_src/guppy_rarefy.ml
+@@ -40,7 +40,7 @@
+ let dst = Array.map (const 0) p in
+ 0 --^ n
+ |> Enum.iter (fun _ ->
+- let i = Gsl_randist.discrete rng (Gsl_randist.discrete_preproc src) in
++ let i = Gsl.Randist.discrete rng (Gsl.Randist.discrete_preproc src) in
+ src.(i) <- src.(i) -. 1.; dst.(i) <- succ dst.(i));
+ dst
+
+@@ -70,7 +70,7 @@
+ method private placefile_action prl =
+ let sample_fun =
+ if fv weight_as_count then multivariate_hypergeometric_sample
+- else Gsl_randist.multinomial
++ else Gsl.Randist.multinomial
+ in
+ let sample = sample_fun self#rng ~n:(fv n_taken)
+ and gt = Mokaphy_common.list_get_same_tree prl in
+--- a/pplacer_src/integration.ml
++++ b/pplacer_src/integration.ml
+@@ -25,7 +25,7 @@
+
+ (* non-adaptive Gauss-Kronrod integration *)
+ let integrate f a b ~abs_err ~rel_err =
+- Gsl_integration.qng f ~a:a ~b:b ~epsabs:abs_err ~epsrel:rel_err
++ Gsl.Integration.qng f ~a:a ~b:b ~epsabs:abs_err ~epsrel:rel_err
+
+ let value_integrate f a b ~abs_err ~rel_err =
+ value_of_triple (integrate f a b ~abs_err ~rel_err)
+--- a/pplacer_src/linear.ml
++++ b/pplacer_src/linear.ml
+@@ -10,40 +10,40 @@
+ (* *** Matrices, used for transformation. *** *)
+
+ (* dst = a * b *)
+-external gemmish : Gsl_matrix.matrix -> Gsl_matrix.matrix -> Gsl_matrix.matrix -> unit = "gemmish_c"
++external gemmish : Gsl.Matrix.matrix -> Gsl.Matrix.matrix -> Gsl.Matrix.matrix -> unit = "gemmish_c"
+
+ (* dst u lambda uit
+ * where uit is u inverse transpose
+ * dst_ij = sum_k (lambda_k *. u_ik *. uit_jk)
+ * *)
+-external dediagonalize : Gsl_matrix.matrix -> Gsl_matrix.matrix -> Gsl_vector.vector -> Gsl_matrix.matrix -> unit = "dediagonalize"
++external dediagonalize : Gsl.Matrix.matrix -> Gsl.Matrix.matrix -> Gsl.Vector.vector -> Gsl.Matrix.matrix -> unit = "dediagonalize"
+
+
+ (* *** Matrices, that are used for gcat. *** *)
+
+ (* print *)
+-external mat_print : Gsl_matrix.matrix -> unit = "mat_print_c"
++external mat_print : Gsl.Matrix.matrix -> unit = "mat_print_c"
+
+ (* statd x y z util *)
+-external mat_log_like3 : Gsl_vector.vector -> Gsl_matrix.matrix -> Gsl_matrix.matrix -> Gsl_matrix.matrix -> float = "mat_log_like3_c"
++external mat_log_like3 : Gsl.Vector.vector -> Gsl.Matrix.matrix -> Gsl.Matrix.matrix -> Gsl.Matrix.matrix -> float = "mat_log_like3_c"
+
+ (* dst x y *)
+-external mat_pairwise_prod : Gsl_matrix.matrix -> Gsl_matrix.matrix -> Gsl_matrix.matrix -> unit = "mat_pairwise_prod_c"
++external mat_pairwise_prod : Gsl.Matrix.matrix -> Gsl.Matrix.matrix -> Gsl.Matrix.matrix -> unit = "mat_pairwise_prod_c"
+
+ (* statd dst a b *)
+-external mat_statd_pairwise_prod : Gsl_vector.vector -> Gsl_matrix.matrix -> Gsl_matrix.matrix -> Gsl_matrix.matrix -> unit = "mat_statd_pairwise_prod_c"
++external mat_statd_pairwise_prod : Gsl.Vector.vector -> Gsl.Matrix.matrix -> Gsl.Matrix.matrix -> Gsl.Matrix.matrix -> unit = "mat_statd_pairwise_prod_c"
+
+ (* x y mask
+ * Take the across-sites sum of the logarithm of the per-site dot products of x
+ * and y restricted to the sites that have a nonzero value in the mask.
+ * *)
+-external mat_masked_logdot : Gsl_matrix.matrix -> Gsl_matrix.matrix -> uint16_vector -> float = "mat_masked_logdot_c"
++external mat_masked_logdot : Gsl.Matrix.matrix -> Gsl.Matrix.matrix -> uint16_vector -> float = "mat_masked_logdot_c"
+
+ (* x y first last
+ * take the logarithm of the dot product of x and y restricted to the interval
+ * [start, last]. start and last are 0-indexed, of course.
+ * *)
+-external mat_bounded_logdot : Gsl_matrix.matrix -> Gsl_matrix.matrix -> int -> int -> float = "mat_bounded_logdot_c"
++external mat_bounded_logdot : Gsl.Matrix.matrix -> Gsl.Matrix.matrix -> int -> int -> float = "mat_bounded_logdot_c"
+
+
+ (* *** Tensors, that are used for gmix. *** *)
+@@ -52,28 +52,28 @@
+ external ten_print : Tensor.tensor -> unit = "ten_print_c"
+
+ (* statd x y z util *)
+-external ten_log_like3 : Gsl_vector.vector -> Tensor.tensor -> Tensor.tensor -> Tensor.tensor -> Gsl_vector.vector -> float = "ten_log_like3_c"
++external ten_log_like3 : Gsl.Vector.vector -> Tensor.tensor -> Tensor.tensor -> Tensor.tensor -> Gsl.Vector.vector -> float = "ten_log_like3_c"
+
+ (* dst x y *)
+ external ten_pairwise_prod : Tensor.tensor -> Tensor.tensor -> Tensor.tensor -> unit = "ten_pairwise_prod_c"
+
+ (* statd dst a b *)
+-external ten_statd_pairwise_prod : Gsl_vector.vector -> Tensor.tensor -> Tensor.tensor -> Tensor.tensor -> unit = "ten_statd_pairwise_prod_c"
++external ten_statd_pairwise_prod : Gsl.Vector.vector -> Tensor.tensor -> Tensor.tensor -> Tensor.tensor -> unit = "ten_statd_pairwise_prod_c"
+
+ (* x y mask util
+ * Take the logarithm of the dot product of x and y restricted to the sites
+ * that have a nonzero value in the mask.
+ * *)
+-external ten_masked_logdot : Tensor.tensor -> Tensor.tensor -> uint16_vector -> Gsl_vector.vector -> float = "ten_masked_logdot_c"
++external ten_masked_logdot : Tensor.tensor -> Tensor.tensor -> uint16_vector -> Gsl.Vector.vector -> float = "ten_masked_logdot_c"
+
+ (* x y first last util
+ * take the logarithm of the dot product of x and y restricted to the interval
+ * [start, last]. start and last are 0-indexed, of course.
+ * *)
+-external ten_bounded_logdot : Tensor.tensor -> Tensor.tensor -> int -> int -> Gsl_vector.vector -> float = "ten_bounded_logdot_c"
++external ten_bounded_logdot : Tensor.tensor -> Tensor.tensor -> int -> int -> Gsl.Vector.vector -> float = "ten_bounded_logdot_c"
+
+ (* vec_pairwise_prod dst x y *)
+-external vec_pairwise_prod : Gsl_vector.vector -> Gsl_vector.vector -> Gsl_vector.vector -> unit = "vec_pairwise_prod_c"
++external vec_pairwise_prod : Gsl.Vector.vector -> Gsl.Vector.vector -> Gsl.Vector.vector -> unit = "vec_pairwise_prod_c"
+
+ (* int_vec_tot x
+ * The total of an integer vector. *)
+@@ -86,4 +86,4 @@
+ * Left multiply the integer vector by the float matrix. This routine
+ * specializes in being fast when the integer is sparse.
+ * *)
+-external float_mat_int_vec_mul : Gsl_vector.vector -> Gsl_matrix.matrix -> uint16_vector -> unit = "float_mat_int_vec_mul_c"
++external float_mat_int_vec_mul : Gsl.Vector.vector -> Gsl.Matrix.matrix -> uint16_vector -> unit = "float_mat_int_vec_mul_c"
+--- a/pplacer_src/lpca.ml
++++ b/pplacer_src/lpca.ml
+@@ -17,7 +17,7 @@
+
+ (* Compute the mean of a vector v. *)
+ let vec_mean v =
+- (vec_fold_left (+.) 0. v) /. (float (Gsl_vector.length v))
++ (vec_fold_left (+.) 0. v) /. (float (Gsl.Vector.length v))
+
+ (* Compute the mean of a vector v and subtract it from each element, i.e. apply
+ * a centering matrix: http://en.wikipedia.org/wiki/Centering_matrix
+@@ -28,7 +28,7 @@
+
+ (* Replicate the upper triangle of a matrix m to the lower triangle. *)
+ let mat_rep_uptri m =
+- let (n_rows, _) = Gsl_matrix.dims m in
++ let (n_rows, _) = Gsl.Matrix.dims m in
+ for i=1 to n_rows-1 do
+ for j=0 to i-1 do
+ m.{i, j} <- m.{j, i}
+@@ -41,18 +41,18 @@
+
+ (* An intermediate edge result record with the following meanings in terms of
+ the length_pca writeup. *)
+-type lpca_data = { f: Gsl_vector.vector;
++type lpca_data = { f: Gsl.Vector.vector;
+ (* $f_k$, the proximal minus the distal mass
+ * (WRT current position). *)
+- ufl: Gsl_matrix.matrix;
++ ufl: Gsl.Matrix.matrix;
+ (* $uFL$, an s x s accumulator matrix of partial inner products
+ * later used in projecting a sample $u$ onto $Fw$. See
+ * eq:ufl. *)
+- af: Gsl_vector.vector IntMap.t;
++ af: Gsl.Vector.vector IntMap.t;
+ (* $AF$, which is an e x s matrix, here encoded as a map
+ * (edges) to a vector indexed by sample number. See
+ * eq:f_tilde. *)
+- fplf: Gsl_matrix.matrix }
++ fplf: Gsl.Matrix.matrix }
+ (* $F'LF$, which is the "proxy" that we use to avoid computing
+ * the eigenvectors of the full matrix GL. See prop:gl_fplf
+ * and eq:fplf. *)
+@@ -89,10 +89,10 @@
+ lpca_tot_edge_nz that no placements occurred precisely at the proximal
+ node of the edge. Here b is used for the contribution of a branch. *)
+ let attached_mass b =
+- let m = Gsl_vector.copy b.f in
+- Gsl_vector.scale m (-1.);
+- Gsl_vector.add_constant m 1.;
+- Gsl_vector.scale m (1. /. 2.);
++ let m = Gsl.Vector.copy b.f in
++ Gsl.Vector.scale m (-1.);
++ Gsl.Vector.add_constant m 1.;
++ Gsl.Vector.scale m (1. /. 2.);
+ m
+ in
+ match l with
+@@ -102,11 +102,11 @@
+ (* axpy is y := a*x + y, so the below means a.f += -2 m, where m is
+ the amount of mass attached to subtree bj. This accomplishes the
+ update described by eq:node_crossing, *)
+- Gsl_blas.axpy (-2.) (attached_mass bj) a.f;
+- Gsl_matrix.add a.ufl bj.ufl;
++ Gsl.Blas.axpy (-2.) (attached_mass bj) a.f;
++ Gsl.Matrix.add a.ufl bj.ufl;
+ (* Add the sibling branch's contribution to F'LF, as in
+ eq:piecewise_edge. *)
+- Gsl_matrix.add a.fplf bj.fplf;
++ Gsl.Matrix.add a.fplf bj.fplf;
+ { a with af = map_union a.af bj.af })
+ b bs
+ in
+@@ -124,11 +124,11 @@
+ with
+ | Not_found -> []
+ in
+- let n_samples = Gsl_vector.length data_0.f in
++ let n_samples = Gsl.Vector.length data_0.f in
+ (* af_e is an accumulator for this edge's row in the $\tilde{F} = AF$ matrix,
+ defined in eq:f_tilde and later used in computing edge-averaged
+ eigenvectors as described in the text. *)
+- let af_e = Gsl_vector.create ~init:0. n_samples in
++ let af_e = Gsl.Vector.create ~init:0. n_samples in
+ (* In aux, i counts the number of "constant regions" along the edge. *)
+ let rec aux i pl prev_distal_bl data =
+ let update_data sample_id mass len =
+@@ -141,13 +141,13 @@
+ * is "hidden" in this call as the outer product f_cen * f_cen^T, which is
+ * then weighted by the region length and added to the F'LF accumulator,
+ * as in eq:fplf_update. *)
+- Gsl_blas.syr Gsl_blas.Upper ~alpha:len ~x:f_cen ~a:data.fplf;
++ Gsl.Blas.syr Gsl.Blas.Upper ~alpha:len ~x:f_cen ~a:data.fplf;
+ (* Add this region's contribution to \tilde{F}, as in eq:f_tilde. *)
+- Gsl_vector.add af_e f_cen;
++ Gsl.Vector.add af_e f_cen;
+ (* dger is rank-1 update A = \alpha x y^T + A of the matrix A. This is
+ the update computation for the inner term of eq:ufl, but for all the
+ samples at once. *)
+- Gsl_blas.dger ~alpha:len ~x:data.f ~y:f_cen ~a:data.ufl;
++ Gsl.Blas.dger ~alpha:len ~x:data.f ~y:f_cen ~a:data.ufl;
+ (* Terminate this region and update f_k as we pass. *)
+ data.f.{sample_id} <- data.f.{sample_id} -. (2. *. mass)
+ in
+@@ -170,7 +170,7 @@
+ assert(len > 0.);
+ update_data 0 0. len;
+ (* Multiplying on left by averaging matrix as just before eq:f_tilde. *)
+- Gsl_vector.scale af_e (1. /. (float (succ i)));
++ Gsl.Vector.scale af_e (1. /. (float (succ i)));
+ { data with af = IntMap.add edge_id af_e data.af }
+ in
+ aux 0 pl 0. data_0
+@@ -224,10 +224,10 @@
+ let sm = make_n_lpca_map sl in
+ let tot_edge = lpca_tot_edge sm in
+ let n_samples = List.length sl in
+- let data_0 = { f = Gsl_vector.create ~init:1. n_samples; (* prox - distal *)
+- ufl = Gsl_matrix.create ~init:0. n_samples n_samples;
++ let data_0 = { f = Gsl.Vector.create ~init:1. n_samples; (* prox - distal *)
++ ufl = Gsl.Matrix.create ~init:0. n_samples n_samples;
+ af = IntMap.empty;
+- fplf = Gsl_matrix.create ~init:0. n_samples n_samples } in
++ fplf = Gsl.Matrix.create ~init:0. n_samples n_samples } in
+ let data =
+ Stree.recur
+ (fun edge_id dl -> (* internal nodes *)
+@@ -239,17 +239,17 @@
+ tot_edge
+ edge_id
+ (Gtree.get_bl ref_tree edge_id)
+- { data_0 with f = Gsl_vector.copy data_0.f;
+- ufl = Gsl_matrix.copy data_0.ufl;
+- fplf = Gsl_matrix.copy data_0.fplf })
++ { data_0 with f = Gsl.Vector.copy data_0.f;
++ ufl = Gsl.Matrix.copy data_0.ufl;
++ fplf = Gsl.Matrix.copy data_0.fplf })
+ (Gtree.get_stree ref_tree)
+ in
+ let inv_smo = 1. /. (float (n_samples - 1)) in (* Samples Minus One. *)
+ let inv_sqrt_smo = sqrt inv_smo in
+- Gsl_matrix.scale data.fplf inv_smo;
+- Gsl_matrix.scale data.ufl inv_sqrt_smo;
++ Gsl.Matrix.scale data.fplf inv_smo;
++ Gsl.Matrix.scale data.ufl inv_sqrt_smo;
+ mat_rep_uptri data.fplf;
+ IntMap.iter
+- (fun _ v -> Gsl_vector.scale v inv_sqrt_smo)
++ (fun _ v -> Gsl.Vector.scale v inv_sqrt_smo)
+ data.af;
+ data
+--- a/pplacer_src/map_seq.ml
++++ b/pplacer_src/map_seq.ml
+@@ -16,7 +16,7 @@
+ let module Model = (val m: Glvm.Model with type t = a and type glv_t = b) in
+ let module Seq_post = Seq_post.Make(Model) in
+ let bounded_max_index vec =
+- let idx = Gsl_vector.max_index vec in
++ let idx = Gsl.Vector.max_index vec in
+ if vec.{idx} /. (Linear_utils.l1_norm vec) < cutoff then -1 else idx
+ and code = Model.seq_type model |> Glvm.code in
+ IntMap.mapi
+--- a/pplacer_src/mass_map.ml
++++ b/pplacer_src/mass_map.ml
+@@ -250,7 +250,7 @@
+ let no_transform = identity
+ let unit_transform _ = 1.
+ let log_transform x = log x
+-let asinh_transform x = Gsl_math.asinh x
++let asinh_transform x = Gsl.Math.asinh x
+
+ let transform_map = StringMap.of_pairlist
+ [
+--- a/pplacer_src/matrix.ml
++++ b/pplacer_src/matrix.ml
+@@ -1,6 +1,6 @@
+ open Ppatteries
+ include Bigarray.Array2
+-include Gsl_matrix
++include Gsl.Matrix
+
+ let create a b = Bigarray.Array2.create Bigarray.float64 Bigarray.c_layout a b
+ let mimic a = create (dim1 a) (dim2 a)
+--- a/pplacer_src/matrix.mli
++++ b/pplacer_src/matrix.mli
+@@ -10,7 +10,7 @@
+ val set_id: matrix -> unit
+ val memcpy: src:matrix -> dst:matrix -> unit
+ val copy: matrix -> matrix
+-val row: matrix -> int -> Gsl_vector.vector
++val row: matrix -> int -> Gsl.Vector.vector
+ val add: matrix -> matrix -> unit
+ val sub: matrix -> matrix -> unit
+ val mul_elements: matrix -> matrix -> unit
+--- a/pplacer_src/matrix_sig.ml
++++ b/pplacer_src/matrix_sig.ml
+@@ -25,7 +25,7 @@
+ let n = Array.length pquerya
+ and ca_info = Edge_rdist.build_ca_info t
+ in
+- let m = Gsl_matrix.create n n in
++ let m = Gsl.Matrix.create n n in
+ let dist_fun =
+ (Pquery_distances.dist_fun_of_point_spread weighting) criterion ca_info
+ in
+@@ -44,7 +44,7 @@
+ let mt = matrix_of_pqueries weighting criterion t
+ ((Placerun.get_pqueries pr1)@(Placerun.get_pqueries pr2))
+ in
+- Gsl_matrix.scale mt (1. /. (Gtree.tree_length t));
++ Gsl.Matrix.scale mt (1. /. (Gtree.tree_length t));
+ mt
+
+ let vec_tot = vec_fold_left (+.) 0.
+@@ -79,24 +79,24 @@
+ * applying f to each of the rows of m *)
+ let map_rows_to_vector f m =
+ let n_rows = Array2.dim1 m in
+- let v = Gsl_vector.create n_rows in
++ let v = Gsl.Vector.create n_rows in
+ for i=0 to n_rows-1 do
+- Array1.unsafe_set v i (f (Gsl_matrix.row m i))
++ Array1.unsafe_set v i (f (Gsl.Matrix.row m i))
+ done;
+ v
+
+ (* the average of each of the rows *)
+ let row_avg m =
+- let (_, n_cols) = Gsl_matrix.dims m
++ let (_, n_cols) = Gsl.Matrix.dims m
+ and ra = map_rows_to_vector vec_tot m in
+- Gsl_vector.scale ra (1. /. (float_of_int n_cols));
++ Gsl.Vector.scale ra (1. /. (float_of_int n_cols));
+ ra
+
+ (* if m is mtilde then convert it to an m. n1 and n2 are the number of pqueries
+ * in pr1 and pr2 *)
+ let m_of_mtilde m n1 n2 =
+ (* it's mtilde so far *)
+- let (n,_) = Gsl_matrix.dims m in
++ let (n,_) = Gsl.Matrix.dims m in
+ assert(n = n1+n2);
+ let ra = row_avg m in
+ let avg = (vec_tot ra) /. (float_of_int n) in
+@@ -116,13 +116,13 @@
+ (* get expectation of w within some tolerance *)
+ let w_expectation rng tol m =
+ let n = mat_dim_asserting_square m in
+- let v = Gsl_vector.create n in
++ let v = Gsl.Vector.create n in
+ let n_samples = ref 0
+ and sample_total = ref 0.
+ in
+ let next_expectation () =
+ for i=0 to n-1 do
+- v.{i} <- Gsl_randist.gaussian rng ~sigma:1.
++ v.{i} <- Gsl.Randist.gaussian rng ~sigma:1.
+ done;
+ incr n_samples;
+ sample_total := !sample_total +. rooted_qform m v;
+@@ -140,13 +140,13 @@
+
+ let write_matrix_normal_dist rng name1 name2 m w n_samples =
+ let n = Array2.dim1 m in
+- let v = Gsl_vector.create n in
++ let v = Gsl.Vector.create n in
+ let normal_ws =
+ List.init
+ n_samples
+ (fun _ ->
+ for i=0 to n-1 do
+- v.{i} <- Gsl_randist.gaussian rng ~sigma:1.
++ v.{i} <- Gsl.Randist.gaussian rng ~sigma:1.
+ done;
+ rooted_qform m v)
+ in
+--- a/pplacer_src/minimization.ml
++++ b/pplacer_src/minimization.ml
+@@ -84,14 +84,14 @@
+ try
+ let start = start_finder ~max_iters f raw_start left right tolerance in
+ let iterator =
+- Gsl_min.make Gsl_min.BRENT f start left right in
++ Gsl.Min.make Gsl.Min.BRENT f start left right in
+ let rec run whichStep =
+ if whichStep > max_iters then raise ExceededMaxIter
+ else begin
+- Gsl_min.iterate iterator;
+- let interLow, interHigh = Gsl_min.interval iterator in
++ Gsl.Min.iterate iterator;
++ let interLow, interHigh = Gsl.Min.interval iterator in
+ if interHigh -. interLow < tolerance then
+- Gsl_min.minimum iterator
++ Gsl.Min.minimum iterator
+ else
+ run (whichStep+1)
+ end
+--- a/pplacer_src/nbc.ml
++++ b/pplacer_src/nbc.ml
+@@ -182,7 +182,7 @@
+ (* The matrix of randomly-generated bootstraps. *)
+ boot_matrix: (int, BA.int16_unsigned_elt, BA.c_layout) BA2.t;
+ (* A vector to hold the results of a classification multiplication. *)
+- classify_vec: Gsl_vector.vector;
++ classify_vec: Gsl.Vector.vector;
+ }
+
+ type rank = Rank of int | Auto_rank | All_ranks
+@@ -216,7 +216,7 @@
+ BA.c_layout
+ boot_rows
+ c.base.n_words
+- and classify_vec = Gsl_vector.create ~init:0. n_taxids in
++ and classify_vec = Gsl.Vector.create ~init:0. n_taxids in
+ if fill_counts then
+ Preclassifier.to_taxid_word_counts c taxid_word_counts;
+ BA2.fill boot_matrix 0;
+@@ -228,10 +228,10 @@
+ let classify_vec ?(random_tie_break = false) cf vec =
+ let open Preclassifier in
+ let dest = cf.classify_vec in
+- Gsl_vector.set_zero dest;
++ Gsl.Vector.set_zero dest;
+ Linear.float_mat_int_vec_mul dest cf.taxid_word_counts vec;
+ (if random_tie_break then random_winner_max_index dest
+- else Gsl_vector.max_index dest)
++ else Gsl.Vector.max_index dest)
+ |> Array.get cf.pc.tax_ids
+
+ (* fill a vector with counts for a sequence *)
+--- a/pplacer_src/nuc_models.ml
++++ b/pplacer_src/nuc_models.ml
+@@ -23,7 +23,7 @@
+
+ let nuc_map =
+ CharMap.of_pairlist (
+- List.map (fun (c, v) -> (c, Gsl_vector.of_array v)) (
++ List.map (fun (c, v) -> (c, Gsl.Vector.of_array v)) (
+ (* A C G T *)
+ ['A', [|1.; 0.; 0.; 0.|];
+ 'C', [|0.; 1.; 0.; 0.|];
+@@ -81,5 +81,5 @@
+ for i=0 to 5 do
+ set_both m (transform 3 i) v.(i)
+ done;
+- Gsl_matrix.of_arrays m
++ Gsl.Matrix.of_arrays m
+
+--- a/pplacer_src/ocaml_linear.ml
++++ b/pplacer_src/ocaml_linear.ml
+@@ -101,7 +101,7 @@
+ done
+
+ let dediagonalize dst u lambda uit =
+- let n = Gsl_vector.length lambda in
++ let n = Gsl.Vector.length lambda in
+ for i=0 to n-1 do
+ for j=0 to n-1 do
+ dst.{i,j} <- 0.;
+--- a/pplacer_src/pca.ml
++++ b/pplacer_src/pca.ml
+@@ -20,12 +20,12 @@
+
+ (* Alternative version that uses symmv rather than power iteration. *)
+ let symmv_eigen n_keep m =
+- let (evalv, evectm) = Gsl_eigen.symmv (`M (m)) in
+- Gsl_eigen.symmv_sort (evalv, evectm) Gsl_eigen.ABS_DESC;
++ let (evalv, evectm) = Gsl.Eigen.symmv (`M (m)) in
++ Gsl.Eigen.symmv_sort (evalv, evectm) Gsl.Eigen.ABS_DESC;
+ (* GSL makes nice column vectors *)
+- Gsl_matrix.transpose_in_place evectm;
+- (Array.sub (Gsl_vector.to_array evalv) 0 n_keep,
+- Array.init n_keep (Gsl_matrix.row evectm))
++ Gsl.Matrix.transpose_in_place evectm;
++ (Array.sub (Gsl.Vector.to_array evalv) 0 n_keep,
++ Array.init n_keep (Gsl.Matrix.row evectm))
+
+ (* Pass in an n by p array of arrays, and make the corresponding p by p
+ * sample covariance matrix (i.e. such that divisor is n-1). Scale determines
+@@ -34,17 +34,17 @@
+ * Eigenvalues returned as a float array, and eigenvects as an array of GSL
+ * vectors. *)
+ let covariance_matrix ?scale faa =
+- let x = Gsl_matrix.of_arrays faa
++ let x = Gsl.Matrix.of_arrays faa
+ and inv k = 1./.(float_of_int k)
+ in
+- let (n, p) = Gsl_matrix.dims x in
++ let (n, p) = Gsl.Matrix.dims x in
+ let h = Linear_utils.mat_init n n
+ (fun i j -> if i=j then 1.-.(inv n) else -.(inv n))
+- and a = Gsl_matrix.create n p
+- and cov = Gsl_matrix.create p p
++ and a = Gsl.Matrix.create n p
++ and cov = Gsl.Matrix.create p p
+ in
+ Linear_utils.mat_mat_mul a h x;
+- Gsl_blas.syrk Gsl_blas.Upper Gsl_blas.Trans ~alpha:(inv (n-1)) ~a:a ~beta:0. ~c:cov;
++ Gsl.Blas.syrk Gsl.Blas.Upper Gsl.Blas.Trans ~alpha:(inv (n-1)) ~a:a ~beta:0. ~c:cov;
+ let scale_f = match scale with
+ | None | Some false -> (fun x _ _ -> x)
+ | Some true ->
+@@ -70,7 +70,7 @@
+ let eigen = if symmv then symmv_eigen else power_eigen in
+ let cov = covariance_matrix ?scale faa in
+ let (raw_evals, raw_evects) = eigen n_keep cov in
+- let evects = Array.map Gsl_vector.to_array raw_evects in
++ let evects = Array.map Gsl.Vector.to_array raw_evects in
+ if use_raw_eval then (raw_evals, evects)
+ else
+ (let tr = Linear_utils.trace cov in
+--- a/pplacer_src/pplacer_run.ml
++++ b/pplacer_src/pplacer_run.ml
+@@ -347,7 +347,7 @@
+ if fpc > FP_zero then
+ Printf.printf "%s is a %s\n" str (string_of_fpclass fpc)
+ in
+- let utilv_nsites = Gsl_vector.create n_sites
++ let utilv_nsites = Gsl.Vector.create n_sites
+ and util_d = Glv.mimic darr.(0)
+ and util_p = Glv.mimic parr.(0)
+ and util_one = Glv.mimic darr.(0)
+--- a/pplacer_src/prot_models.ml
++++ b/pplacer_src/prot_models.ml
+@@ -8,24 +8,24 @@
+ let pm = ref CharMap.empty in
+ Array.iteri (
+ fun i c ->
+- let v = Gsl_vector.create ~init:0. 20 in
++ let v = Gsl.Vector.create ~init:0. 20 in
+ v.{i} <- 1.;
+ pm := CharMap.add c v !pm;
+ ) prot_code;
+- let any = Gsl_vector.create ~init:1. 20
+- and b_vector = Gsl_vector.create ~init:0. 20
+- and j_vector = Gsl_vector.create ~init:0. 20
+- and z_vector = Gsl_vector.create ~init:0. 20
++ let any = Gsl.Vector.create ~init:1. 20
++ and b_vector = Gsl.Vector.create ~init:0. 20
++ and j_vector = Gsl.Vector.create ~init:0. 20
++ and z_vector = Gsl.Vector.create ~init:0. 20
+ in
+ (* B is D or N. *)
+- Gsl_vector.add b_vector (CharMap.find 'D' !pm);
+- Gsl_vector.add b_vector (CharMap.find 'N' !pm);
++ Gsl.Vector.add b_vector (CharMap.find 'D' !pm);
++ Gsl.Vector.add b_vector (CharMap.find 'N' !pm);
+ (* J is I or L. *)
+- Gsl_vector.add j_vector (CharMap.find 'I' !pm);
+- Gsl_vector.add j_vector (CharMap.find 'L' !pm);
++ Gsl.Vector.add j_vector (CharMap.find 'I' !pm);
++ Gsl.Vector.add j_vector (CharMap.find 'L' !pm);
+ (* Z is E or Q. *)
+- Gsl_vector.add z_vector (CharMap.find 'E' !pm);
+- Gsl_vector.add z_vector (CharMap.find 'Q' !pm);
++ Gsl.Vector.add z_vector (CharMap.find 'E' !pm);
++ Gsl.Vector.add z_vector (CharMap.find 'Q' !pm);
+ (*
+ Format.print_char 'B';
+ Format.printf " %a@\n" Linear_utils.ppr_gsl_vector b_vector;
+@@ -67,7 +67,7 @@
+ else lowerTriMat.((max i j)-1).(min i j)) in
+ qMat
+
+-let parseFreq str = Gsl_vector.of_array (parseLine str)
++let parseFreq str = Gsl.Vector.of_array (parseLine str)
+
+ let littleWag =
+ parseProtModel [|
+--- a/pplacer_src/som.ml
++++ b/pplacer_src/som.ml
+@@ -8,7 +8,7 @@
+
+
+ let trans_a_mat_mul =
+- Gsl_blas.gemm ~ta:Gsl_blas.Trans ~tb:Gsl_blas.NoTrans ~alpha:1. ~beta:0.
++ Gsl.Blas.gemm ~ta:Gsl.Blas.Trans ~tb:Gsl.Blas.NoTrans ~alpha:1. ~beta:0.
+
+ (*
+ Rotation matrix in terms of Euler angles [|phi; theta; psi|]
+@@ -39,7 +39,7 @@
+ Cos[theta]
+ *)
+ let rot_mat angles =
+- let m = Gsl_matrix.create 3 3
++ let m = Gsl.Matrix.create 3 3
+ and cos_phi = cos angles.(0)
+ and sin_phi = sin angles.(0)
+ and cos_theta = cos angles.(1)
+@@ -67,7 +67,7 @@
+ * of the eigenvector matrix, so we multiply on the left by the transpose.
+ *)
+ let rotate_vects vects_part angles =
+- let result = Gsl_matrix.copy vects_part in
++ let result = Gsl.Matrix.copy vects_part in
+ trans_a_mat_mul ~a:(rot_mat angles) ~b:vects_part ~c:result;
+ result
+
+@@ -81,21 +81,21 @@
+ * \sum_j a_{ij}^2 Var(X_j).
+ * As can be seen, we do this for a maximum of three dimensions. *)
+ let rotate_vals vals angles =
+- let vals_part = Gsl_vector.of_array (Array.sub vals 0 3) in
+- let vals_result = Gsl_vector.create ~init:0. 3 in
++ let vals_part = Gsl.Vector.of_array (Array.sub vals 0 3) in
++ let vals_result = Gsl.Vector.create ~init:0. 3 in
+ let vals_rest = Array.sub vals 3 ((Array.length vals) - 3) in
+ let rot = rot_mat angles in
+ (* Square the elements of the rotation matrix. *)
+- Gsl_matrix.mul_elements rot rot;
++ Gsl.Matrix.mul_elements rot rot;
+ (* Multiply its transpose by our vals to get the rotated vals. *)
+- Gsl_blas.gemv Gsl_blas.Trans ~alpha:1. ~beta:0. ~a:rot ~x:vals_part ~y:vals_result;
+- Array.append (Gsl_vector.to_array vals_result) vals_rest
++ Gsl.Blas.gemv Gsl.Blas.Trans ~alpha:1. ~beta:0. ~a:rot ~x:vals_part ~y:vals_result;
++ Array.append (Gsl.Vector.to_array vals_result) vals_rest
+
+ (* Measures the overlap between the tranform vector components when rotated
+ * through the given angles. *)
+ let overlap vects_part dims angles =
+ let rotated_vects = rotate_vects vects_part angles in
+- let row i = Gsl_matrix.row rotated_vects i
++ let row i = Gsl.Matrix.row rotated_vects i
+ and indices = match dims with
+ | 2 -> [(0, 1)]
+ | 3 -> [(0, 1); (0, 2); (1, 2)]
+@@ -104,10 +104,10 @@
+ let rec overlapper = function
+ | [] -> 0.
+ | (i, j)::rest ->
+- let mult = Gsl_vector.copy (row i) in
+- Gsl_vector.mul mult (row j);
++ let mult = Gsl.Vector.copy (row i) in
++ Gsl.Vector.mul mult (row j);
+ (* asum because we want to take the absolute value dot product. *)
+- Gsl_blas.asum mult +. overlapper rest
++ Gsl.Blas.asum mult +. overlapper rest
+ in
+ overlapper indices
+
+@@ -121,15 +121,15 @@
+ ~start_finder:Minimization.robust_start_finder
+ obj_fun
+ 0.
+- (-. Gsl_math.pi_4)
+- Gsl_math.pi_4 tolerance
++ (-. Gsl.Math.pi_4)
++ Gsl.Math.pi_4 tolerance
+ in
+ [|min; 0.; 0.|]
+ | 3 ->
+ let obj_fun = overlap vects_part dims
+ and start = [|0.; 0.; 0.|]
+- and lower = Array.make 3 (-. Gsl_math.pi)
+- and upper = Array.make 3 (Gsl_math.pi)
++ and lower = Array.make 3 (-. Gsl.Math.pi)
++ and upper = Array.make 3 (Gsl.Math.pi)
+ in
+ let run_one_3d index_order =
+ Minimization.multimin ~index_order obj_fun start lower upper tolerance
+@@ -187,11 +187,11 @@
+ (* Returns a tuple of the roated vects (as an array of arrays), the rotated
+ * vals. *)
+ let som_rotation vects dims vals =
+- let vects_part = Gsl_matrix.of_arrays (Array.sub vects 0 3) in
++ let vects_part = Gsl.Matrix.of_arrays (Array.sub vects 0 3) in
+ (* Where all the real work is - find min(s) *)
+ let min = min_overlap vects_part dims in
+ let vals = rotate_vals vals min
+- and vects_part = Gsl_matrix.to_arrays (rotate_vects vects_part min)
++ and vects_part = Gsl.Matrix.to_arrays (rotate_vects vects_part min)
+ in
+ let vals, vects_part = reordered_by_vals vals vects_part dims in
+ let flipped_vects = flip_axes ~orig_vects:vects ~new_vects:vects_part in
+--- a/pplacer_src/three_tax.ml
++++ b/pplacer_src/three_tax.ml
+@@ -14,7 +14,7 @@
+
+ type three_tax = {
+ model: Model.t;
+- util_v: Gsl_vector.vector; (* should be as long as the number of sites *)
++ util_v: Gsl.Vector.vector; (* should be as long as the number of sites *)
+ prox: Glv_edge.t; (* the proximal glv *)
+ dist: Glv_edge.t; (* the distal glv *)
+ pend: Glv_edge.t; (* the pendant, i.e. query glv *)
+@@ -155,7 +155,7 @@
+ with
+ (* Points may not enclose a minimum when close to max_pend -
+ * just integrate to max_pend *)
+- | Gsl_error.Gsl_exn(Gsl_error.EINVAL, _) -> max_pend
++ | Gsl.Error.Gsl_exn(Gsl.Error.EINVAL, _) -> max_pend
+ end
+
+ (* The idea here is to properly integrate log likelihood functions by removing
+@@ -202,7 +202,7 @@
+ |> log
+ |> (+.) base_ll
+ with
+- | Gsl_error.Gsl_exn (Gsl_error.ETOL, _) ->
++ | Gsl.Error.Gsl_exn (Gsl.Error.ETOL, _) ->
+ (* Integration failed to reach tolerance with highest-order rule. Because
+ * these functions are smooth, the problem is too-wide integration bounds.
+ * We halve and try again. This is obviously pretty rough, but if we
+--- a/pplacer_src/top_tests/t-normal_approx.ml
++++ b/pplacer_src/top_tests/t-normal_approx.ml
+@@ -1,7 +1,7 @@
+ open New_normal_approx
+
+-let rng = Gsl_rng.make Gsl_rng.KNUTHRAN2002;;
+-Gsl_rng.set rng (Nativeint.of_int 1);;
++let rng = Gsl.Rng.make Gsl.Rng.KNUTHRAN2002;;
++Gsl.Rng.set rng (Nativeint.of_int 1);;
+
+ let pr1 = Placerun_io.of_file "top_tests/test1.place";;
+ let pr3 = Placerun_io.of_file "top_tests/test3.place";;
+--- a/pplacer_src/top_tests/t-top_eig.ml
++++ b/pplacer_src/top_tests/t-top_eig.ml
+@@ -1,14 +1,14 @@
+ open Top_eig;;
+-open Gsl_blas;;
++open Gsl.Blas;;
+
+-let v = Gsl_vector.of_array [|1.;2.;3.|];;
+-let n = Gsl_blas.nrm2 v;;
++let v = Gsl.Vector.of_array [|1.;2.;3.|];;
++let n = Gsl.Blas.nrm2 v;;
+ scale_by_l2 v;;
+ v;;
+
+ (* top eigenvalue 8, with eigenvector (2,1,2) *)
+ let m =
+- Gsl_matrix.of_arrays
++ Gsl.Matrix.of_arrays
+ [|
+ [| 3.; 2.; 4.; |];
+ [| 2.; 0.; 2.; |];
+@@ -22,7 +22,7 @@
+ top_eig m 1e-9 300;;
+
+ let random_symmetric n =
+- let m = Gsl_matrix.create n n in
++ let m = Gsl.Matrix.create n n in
+ for i=0 to n-1 do
+ for j=i to n-1 do
+ let x = Random.float 1. in
+@@ -38,9 +38,9 @@
+ let ours = top_eig m 1e-3 500 in
+ Printf.printf "ours took %g\n" ((Sys.time ()) -. time);
+ let time = Sys.time () in
+- let theirs = Gsl_eigen.symm (`M(m)) in
++ let theirs = Gsl.Eigen.symm (`M(m)) in
+ Printf.printf "theirs took %g\n" ((Sys.time ()) -. time);
+- (ours, Gsl_vector.max theirs);;
++ (ours, Gsl.Vector.max theirs);;
+
+ let test size =
+ let m = random_symmetric size in
+--- a/tests/guppy/test_pca.ml
++++ b/tests/guppy/test_pca.ml
+@@ -60,10 +60,10 @@
+ 0.1652807 0.6576928 -0.7349302
+ 0.6467657 0.4902907 0.5842167"
+ (* we have the vectors be rows in matrix, so we can get at them *)
+-let () = Gsl_matrix.transpose_in_place prcomp_vects
++let () = Gsl.Matrix.transpose_in_place prcomp_vects
+
+ let (variances, pv) = gen_pca ~use_raw_eval:true 3 x;;
+-let vects = Gsl_matrix.of_arrays pv;;
++let vects = Gsl.Matrix.of_arrays pv;;
+ let stddevs = Array.map sqrt variances;;
+
+ (*
+@@ -86,10 +86,10 @@
+ 0.5030103 0.8305398 -0.2391325
+ 0.6341729 -0.1666971 0.7550079"
+ (* we have the vectors be rows in matrix, so we can get at them *)
+-let () = Gsl_matrix.transpose_in_place sprcomp_vects
++let () = Gsl.Matrix.transpose_in_place sprcomp_vects
+
+ let (svariances, spv) = gen_pca ~scale:true ~use_raw_eval:true 3 x;;
+-let svects = Gsl_matrix.of_arrays spv;;
++let svects = Gsl.Matrix.of_arrays spv;;
+ let sstddevs = Array.map sqrt svariances;;
+
+ let test_pca stddev1 stddev2 vect1 vect2 =
+--- a/tests/guppy/test_power_iteration.ml
++++ b/tests/guppy/test_power_iteration.ml
+@@ -11,7 +11,7 @@
+ let symmv_l, symmv_v = symmv_eigen 5 m;;
+
+ let first_coord_pos_vec v =
+- if v.{0} < 0. then Gsl_vector.scale v (-.1.)
++ if v.{0} < 0. then Gsl.Vector.scale v (-.1.)
+
+ let first_coord_pos_arr_vec aa =
+ Array.iter first_coord_pos_vec aa
+--- a/tests/guppy/test_som.ml
++++ b/tests/guppy/test_som.ml
+@@ -10,15 +10,15 @@
+ let id = mat_of_string "1.0 0.0 0.0
+ 0.0 1.0 0.0
+ 0.0 0.0 1.0"
+- and res = Gsl_matrix.copy mat1 in
+- Gsl_blas.gemm ~ta:Gsl_blas.NoTrans ~tb:Gsl_blas.NoTrans ~alpha:1.0 ~beta:0.0 ~a:mat1 ~b:mat2 ~c:res;
++ and res = Gsl.Matrix.copy mat1 in
++ Gsl.Blas.gemm ~ta:Gsl.Blas.NoTrans ~tb:Gsl.Blas.NoTrans ~alpha:1.0 ~beta:0.0 ~a:mat1 ~b:mat2 ~c:res;
+ mat_approx_equal res id
+
+ let test_rot_mat_orth angles () =
+ let orig = rot_mat angles in
+- let dim = fst (Gsl_matrix.dims orig) in
+- let trans = Gsl_matrix.create dim dim in
+- Gsl_matrix.transpose trans orig;
++ let dim = fst (Gsl.Matrix.dims orig) in
++ let trans = Gsl.Matrix.create dim dim in
++ Gsl.Matrix.transpose trans orig;
+ "non orthogonality in rotation matrix" @? is_inverse orig trans
+
+ let to_rotate = mat_of_string
+@@ -29,12 +29,12 @@
+ let extra_row = farr_of_string "1.0 4.0 3.0 2.0 -8.0"
+
+ let we_would_like_this_back =
+- Array.append (Gsl_matrix.to_arrays to_rotate) [| extra_row |]
++ Array.append (Gsl.Matrix.to_arrays to_rotate) [| extra_row |]
+
+ let mat_for_som_test angles =
+- let c = Gsl_matrix.copy to_rotate in
++ let c = Gsl.Matrix.copy to_rotate in
+ Som.trans_a_mat_mul ~a:(rot_mat angles) ~b:to_rotate ~c;
+- Array.append (Gsl_matrix.to_arrays c) [| extra_row |]
++ Array.append (Gsl.Matrix.to_arrays c) [| extra_row |]
+
+ let dummy_vars = farr_of_string "0.5 0.25 0.15 0.1"
+
+--- a/tests/pplacer/test_diagd.ml
++++ b/tests/pplacer/test_diagd.ml
+@@ -4,8 +4,8 @@
+ open Diagd;;
+ open Linear_utils;;
+
+-let b = Gsl_matrix.of_arrays [|[|-. 1.; 0.15|];[|0.15; -.2.|]|];;
+-let d = Gsl_vector.of_array [|0.25; 0.75|];;
++let b = Gsl.Matrix.of_arrays [|[|-. 1.; 0.15|];[|0.15; -.2.|]|];;
++let d = Gsl.Vector.of_array [|0.25; 0.75|];;
+ let diagd = of_d_b d b;;
+ let noep = normed_of_exchangeable_pair b d;;
+
+@@ -14,12 +14,12 @@
+ and a_alt = to_matrix diagd in
+ "dediag not remaking the matrix" @? (a ^=^ a_alt)
+
+-let exp1 = Gsl_matrix.of_arrays
++let exp1 = Gsl.Matrix.of_arrays
+ [|
+ [|0.77992929; 0.01668155|];
+ [|0.05004464; 0.22387769|];
+ |]
+-let exp4 = Gsl_matrix.of_arrays
++let exp4 = Gsl.Matrix.of_arrays
+ [|
+ [|0.37187386; 0.011053085|];
+ [|0.03315925; 0.003437709|];
+@@ -41,7 +41,7 @@
+
+ let column_sums_one m =
+ try
+- let (rows,cols) = Gsl_matrix.dims m in
++ let (rows,cols) = Gsl.Matrix.dims m in
+ for j=0 to cols-1 do
+ let sum = ref 0. in
+ for i=0 to rows-1 do
+--- a/tests/pplacer/test_like.ml
++++ b/tests/pplacer/test_like.ml
+@@ -48,7 +48,7 @@
+ [darr; parr;];
+ let half_bl_fun loc = (Gtree.get_bl tree loc) /. 2. in
+ Glv_arr.prep_supernodes model ~dst:snodes darr parr half_bl_fun;
+- let utilv_nsites = Gsl_vector.create n_sites
++ let utilv_nsites = Gsl.Vector.create n_sites
+ and util_d = Glv.mimic darr.(0)
+ and util_p = Glv.mimic parr.(0)
+ and util_one = Glv.mimic darr.(0)
+--- a/tests/pplacer/test_linear.ml
++++ b/tests/pplacer/test_linear.ml
+@@ -8,8 +8,8 @@
+ Bigarray.Array1.of_array Bigarray.int16_unsigned Bigarray.c_layout [|1; 0; 1;|]
+ in
+ (* Mat! *)
+- let m1 = Gsl_matrix.of_arrays [|[|-. 1.; 0.; 1.|]; [|1000.; 1.; 3.|]; [|0.; 0.; 2.|];|]
+- and m2 = Gsl_matrix.of_arrays [|[|-. 1.; 1.; 2.|]; [|1.; 3.; 0.|]; [|0.; 1.; 2.|];|]
++ let m1 = Gsl.Matrix.of_arrays [|[|-. 1.; 0.; 1.|]; [|1000.; 1.; 3.|]; [|0.; 0.; 2.|];|]
++ and m2 = Gsl.Matrix.of_arrays [|[|-. 1.; 1.; 2.|]; [|1.; 3.; 0.|]; [|0.; 1.; 2.|];|]
+ in
+ "mat_masked_logdot" @? (log 3. +. log 4. =~ Linear.mat_masked_logdot m1 m2 mask_vec);
+ (* Ten! *)
+@@ -25,7 +25,7 @@
+ |]
+ in
+ let ten_expected = (log (1. +. 3.) +. log (4. +. 6.)) -. 2. *. log 2. in
+- let ten_util = Gsl_vector.create 3 in
++ let ten_util = Gsl.Vector.create 3 in
+ "ten_masked_logdot" @?
+ (ten_expected =~ Linear.ten_masked_logdot t1 t2 mask_vec ten_util);
+ ()
+--- a/tests/pplacer/test_matrix.ml
++++ b/tests/pplacer/test_matrix.ml
+@@ -7,12 +7,12 @@
+ (* this checks to make sure that symmv is giving us the eigenvectors as
+ * column vectors. *)
+ let check_symmv m =
+- let (l,v) = Gsl_eigen.symmv (`M(m)) in
++ let (l,v) = Gsl.Eigen.symmv (`M(m)) in
+ let m' = mm v (mm (diag l) (alloc_transpose v)) in
+ "symmEigs not giving column vectors" @? mat_approx_equal m m'
+
+ let test_symmv _ =
+- let b = Gsl_matrix.of_arrays [|[|-. 1.; 0.15|];[|0.15; -.2.|]|] in
++ let b = Gsl.Matrix.of_arrays [|[|-. 1.; 0.15|];[|0.15; -.2.|]|] in
+ check_symmv b
+
+ let suite = [
+--- a/tests/rppr/test_voronoi.ml
++++ b/tests/rppr/test_voronoi.ml
+@@ -135,7 +135,7 @@
+ let mass = Mass_map.Indiv.of_placerun Mass_map.Point Placement.ml_ratio pr
+ and gt = Placerun.get_ref_tree pr in
+ let get_sols = IntMap.find 2 in
+- Gsl_rng.set_default_seed 0n;
++ Gsl.Rng.set_default_seed 0n;
+ (* yes, I know. the alternative is worse. I dare you to try it. *)
+ let full_sols = Voronoi.Full.solve ~n_leaves:2 gt mass |> get_sols
+ and pam_sols = Voronoi.PAM.solve ~n_leaves:2 gt mass |> get_sols
+--- a/tests/test_util.ml
++++ b/tests/test_util.ml
+@@ -40,8 +40,8 @@
+ let farrarr_of_string s =
+ Array.of_list (List.map farr_of_string (Str.split (Str.regexp "\n") s))
+
+-let vec_of_string s = Gsl_vector.of_array (farr_of_string s)
+-let mat_of_string s = Gsl_matrix.of_arrays (farrarr_of_string s)
++let vec_of_string s = Gsl.Vector.of_array (farr_of_string s)
++let mat_of_string s = Gsl.Matrix.of_arrays (farrarr_of_string s)
+
+
+ (* *** equalities *** *)
+@@ -79,9 +79,9 @@
+ (* *** approximate equalities *** *)
+
+ let vec_approx_equal ?(epsilon = 1e-5) v1 v2 =
+- let dim = Gsl_vector.length v1 in
++ let dim = Gsl.Vector.length v1 in
+ try
+- assert(dim = Gsl_vector.length v2);
++ assert(dim = Gsl.Vector.length v2);
+ for i=0 to dim-1 do
+ if not (approx_equal ~epsilon v1.{i} v2.{i}) then raise Exit
+ done;
+@@ -90,9 +90,9 @@
+ | Exit -> false
+
+ let mat_approx_equal ?(epsilon = 1e-5) m1 m2 =
+- let (rows,cols) as dim1 = Gsl_matrix.dims m1 in
++ let (rows,cols) as dim1 = Gsl.Matrix.dims m1 in
+ try
+- assert(dim1 = Gsl_matrix.dims m2);
++ assert(dim1 = Gsl.Matrix.dims m2);
+ for i=0 to rows-1 do
+ for j=0 to cols-1 do
+ if not (approx_equal ~epsilon m1.{i,j} m2.{i,j}) then raise Exit
+@@ -165,7 +165,7 @@
+ (* *** random stuff *** *)
+
+ let rand_symmetric n =
+- let m = Gsl_matrix.create n n in
++ let m = Gsl.Matrix.create n n in
+ for i=0 to n-1 do
+ for j=i to n-1 do
+ m.{i,j} <- 1. -. Random.float 2.;
+@@ -175,8 +175,8 @@
+ m;;
+
+ let make_rng seed =
+- let rng = Gsl_rng.make Gsl_rng.KNUTHRAN2002 in
+- Gsl_rng.set rng (Nativeint.of_int seed);
++ let rng = Gsl.Rng.make Gsl.Rng.KNUTHRAN2002 in
++ Gsl.Rng.set rng (Nativeint.of_int seed);
+ rng
+
+ let colorset_of_strings = List.map Tax_id.of_string |- Convex.ColorSet.of_list
=====================================
debian/patches/series
=====================================
@@ -4,3 +4,4 @@ ocaml_stdlib
ocaml_bytes
spelling.patch
ocaml-batteries.patch
+PR-337.patch
View it on GitLab: https://salsa.debian.org/med-team/pplacer/-/compare/45daec7ebd867a33efe9d76c0d21bd79c3c99d6f...7ba42a8085fb0dca8647131d3fed193429a9c70b
--
View it on GitLab: https://salsa.debian.org/med-team/pplacer/-/compare/45daec7ebd867a33efe9d76c0d21bd79c3c99d6f...7ba42a8085fb0dca8647131d3fed193429a9c70b
You're receiving this email because of your account on salsa.debian.org.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://alioth-lists.debian.net/pipermail/debian-med-commit/attachments/20201201/d7ce61cc/attachment-0001.html>
More information about the debian-med-commit
mailing list