From e59d016ae7b81d416fccfd92e307a75a8dd4e340 Mon Sep 17 00:00:00 2001
From: Anthony Scemama <scemama@irsamc.ups-tlse.fr>
Date: Wed, 17 Jan 2024 13:59:05 +0100
Subject: [PATCH] Removing org-mode

---
 common/lib/powers.ml        |  49 +----
 common/lib/powers.mli       |  56 ++++--
 common/lib/range.ml         |  16 +-
 common/lib/range.mli        |  27 +--
 common/lib/spin.ml          |  20 +--
 common/lib/spin.mli         |  26 +--
 common/lib/zkey.ml          | 100 ++++++-----
 common/lib/zkey.mli         |  51 ++++--
 common/lib/zmap.ml          |   2 -
 common/lib/zmap.mli         |   9 +-
 common/powers.org           | 131 --------------
 common/range.org            |  97 ----------
 common/spin.org             |  64 -------
 common/zkey.org             | 348 ------------------------------------
 common/zmap.org             |  30 ----
 top/lib/install_printers.ml |   2 -
 16 files changed, 181 insertions(+), 847 deletions(-)
 delete mode 100644 common/powers.org
 delete mode 100644 common/range.org
 delete mode 100644 common/spin.org
 delete mode 100644 common/zkey.org
 delete mode 100644 common/zmap.org

diff --git a/common/lib/powers.ml b/common/lib/powers.ml
index 2e60db5..77a7970 100644
--- a/common/lib/powers.ml
+++ b/common/lib/powers.ml
@@ -1,30 +1,15 @@
+(** Type *)
 
-
-(* ~tot~ always contains ~x+y+z~. *)
-
-
-(* [[file:~/QCaml/common/powers.org::*Type][Type:2]] *)
 type t = {
   x   : int ;
   y   : int ;
   z   : int ;
-  tot : int ;
+  tot : int ; (* ~tot~ always contains ~x+y+z~. *)
 }
-(* Type:2 ends here *)
 
 
+(** Conversions *)
 
-(*    Example:
- *     #+begin_example
- * Powers.of_int_tuple (2,3,1);;
- * - : Powers.t = x^2 + y^3 + z^1
- * 
- * Powers.(to_int_tuple (of_int_tuple (2,3,1)));;
- * - : int * int * int = (2, 3, 1)
- *     #+end_example *)
-
-
-(* [[file:~/QCaml/common/powers.org::*Conversions][Conversions:2]] *)
 let of_int_tuple t =
   let result =
     match t with
@@ -39,29 +24,10 @@ let of_int_tuple t =
 
 
 let to_int_tuple { x ; y ; z ; _ } = (x,y,z)
-(* Conversions:2 ends here *)
 
 
+(** Operations *)
 
-(* | ~get~ | Returns the value of the power for $x$, $y$ or $z$
- * | ~incr~ | Returns a new ~Powers.t~ with the power on the given axis incremented |
- * | ~decr~ | Returns a new ~Powers.t~ with the power on the given axis decremented. As opposed to ~of_int_tuple~, the values may become negative|
- * 
- *    Example:
- *     #+begin_example
- * Powers.get Coordinate.Y (Powers.of_int_tuple (2,3,1));;
- * - : int = 3
- * 
- * Powers.incr Coordinate.Y (Powers.of_int_tuple (2,3,1));;
- * - : Powers.t = x^2 + y^4 + z^1
- * 
- * Powers.decr Coordinate.Y (Powers.of_int_tuple (2,3,1));;
- * - : Powers.t = x^2 + y^2 + z^1
- *     #+end_example *)
-
-
-
-(* [[file:~/QCaml/common/powers.org::*Operations][Operations:2]] *)
 let get coord t =
   match coord with
   | Coordinate.X -> t.x
@@ -79,9 +45,10 @@ let decr coord t =
   | Coordinate.X -> let r = t.x-1 in { t with x = r ; tot = t.tot-1 }
   | Coordinate.Y -> let r = t.y-1 in { t with y = r ; tot = t.tot-1 }
   | Coordinate.Z -> let r = t.z-1 in { t with z = r ; tot = t.tot-1 }
-(* Operations:2 ends here *)
 
-(* [[file:~/QCaml/common/powers.org::*Printers][Printers:2]] *)
+
+(** Printers *)
+
 let pp ppf t =
   Format.fprintf ppf "@[x^%d + y^%d + z^%d@]" t.x t.y t.z
-(* Printers:2 ends here *)
+
diff --git a/common/lib/powers.mli b/common/lib/powers.mli
index c2ac295..7b2d60e 100644
--- a/common/lib/powers.mli
+++ b/common/lib/powers.mli
@@ -1,36 +1,58 @@
-(* Type
- * 
- *    <<<~Powers.t~>>> *)
+(** Powers *)
+
+(* Contains powers of $x$, $y$ and $z$ describing the polynomials in
+ * atomic basis sets.
+ *)
+
+(** Type *)
 
-(* [[file:~/QCaml/common/powers.org::*Type][Type:1]] *)
 type t = private {
   x   : int ;
   y   : int ;
   z   : int ;
-  tot : int ;
+  tot : int ; (* ~tot~ always contains ~x+y+z~. *)
 }
-(* Type:1 ends here *)
 
-(* Conversions *)
+(** Conversions *)
 
-
-(* [[file:~/QCaml/common/powers.org::*Conversions][Conversions:1]] *)
 val of_int_tuple : int * int * int -> t
+(** Powers.of_int_tuple (2,3,1);;
+ *  - : Powers.t = x^2 + y^3 + z^1
+ *)
+
 val to_int_tuple : t -> int * int * int
-(* Conversions:1 ends here *)
 
-(* Operations *)
+(** Powers.(to_int_tuple (of_int_tuple (2,3,1)));;
+ *  - : int * int * int = (2, 3, 1)
+ *)
 
 
-(* [[file:~/QCaml/common/powers.org::*Operations][Operations:1]] *)
+(** Operations *)
+
 val get  : Coordinate.axis -> t -> int
+(** Returns the value of the power for $x$, $y$ or $z$.
+ *
+ *  Powers.get Coordinate.Y (Powers.of_int_tuple (2,3,1));;
+ *  - : int = 3
+ *
+ *)
+
 val incr : Coordinate.axis -> t -> t
+(** Returns a new ~Powers.t~ with the power on the given axis incremented.
+ *
+ * Powers.incr Coordinate.Y (Powers.of_int_tuple (2,3,1));;
+ * - : Powers.t = x^2 + y^4 + z^1
+ *)
+
 val decr : Coordinate.axis -> t -> t
-(* Operations:1 ends here *)
-
-(* Printers *)
+(** Returns a new ~Powers.t~ with the power on the given axis decremented.
+ *  As opposed to ~of_int_tuple~, the values may become negative.
+ *
+ * Powers.decr Coordinate.Y (Powers.of_int_tuple (2,3,1));;
+ * - : Powers.t = x^2 + y^2 + z^1
+ *)
 
 
-(* [[file:~/QCaml/common/powers.org::*Printers][Printers:1]] *)
+(** Printers *)
+
 val pp : Format.formatter -> t -> unit
-(* Printers:1 ends here *)
diff --git a/common/lib/range.ml b/common/lib/range.ml
index 886e313..17129fd 100644
--- a/common/lib/range.ml
+++ b/common/lib/range.ml
@@ -1,8 +1,10 @@
-(* [[file:~/QCaml/common/range.org::*Type][Type:2]] *)
-type t = int list
-(* Type:2 ends here *)
+(** Type *)
+
+type t = int list
+
+
+(** Conversion *)
 
-(* [[file:~/QCaml/common/range.org::*Conversion][Conversion:2]] *)
 let to_int_list r = r
 
 let expand_range r =
@@ -41,9 +43,9 @@ let to_string l =
   (List.map string_of_int l
    |> String.concat ",") ^
   "]"
-(* Conversion:2 ends here *)
 
-(* [[file:~/QCaml/common/range.org::*Printers][Printers:2]] *)
+
+(** Printers *)
+
 let pp ppf t =
   Format.fprintf ppf "@[%s@]" (to_string t)
-(* Printers:2 ends here *)
diff --git a/common/lib/range.mli b/common/lib/range.mli
index b99a18c..454e17d 100644
--- a/common/lib/range.mli
+++ b/common/lib/range.mli
@@ -1,23 +1,26 @@
-(* Type
+(* Range *)
+
+(* A range is a sorted list of integers in an interval.
  * 
- *    <<<~Range.t~>>> *)
+ * - ~"[a-b]"~ : range between a and b (included)
+ * - ~"[a]"~   : the list with only one integer a
+ * - ~"a"~     : equivalent to "[a]"
+ * - ~"[36-53,72-107,126-131]"~ represents the list of integers
+ *   [ 37 ; 37 ; 38 ; ... ; 52 ; 53 ; 72 ; 73 ; ... ; 106 ; 107 ; 126 ; 127 ; ... ; 130 ; 131 ].
+ *)
+
+(** Type *)
 
-(* [[file:~/QCaml/common/range.org::*Type][Type:1]] *)
 type t
-(* Type:1 ends here *)
-
-(* Conversion *)
 
 
-(* [[file:~/QCaml/common/range.org::*Conversion][Conversion:1]] *)
+(** Conversion *)
+
 val of_string   : string -> t
 val to_string   : t -> string
 val to_int_list : t -> int list
-(* Conversion:1 ends here *)
-
-(* Printers *)
 
 
-(* [[file:~/QCaml/common/range.org::*Printers][Printers:1]] *)
+(** Printers *)
+
 val pp : Format.formatter -> t -> unit
-(* Printers:1 ends here *)
diff --git a/common/lib/spin.ml b/common/lib/spin.ml
index 2210f2a..d473632 100644
--- a/common/lib/spin.ml
+++ b/common/lib/spin.ml
@@ -1,22 +1,14 @@
+(** Spin *)
 
+(** Type *)
 
-(* Note :
- * ~Alfa~ if written with an 'f' instead of 'ph' because it has the same number of
- * letters as ~Beta~, so the alignment of the code is nicer. *)
-
-
-(* [[file:~/QCaml/common/spin.org::*Type][Type:2]] *)
 type t =  (* m_s *)
   | Alfa (* {% $m_s = +1/2$ %} *)
   | Beta (* {% $m_s = -1/2$ %} *)
-(* Type:2 ends here *)
 
 
+(** Functions *)
 
-(* Returns the opposite spin *)
-
-
-(* [[file:~/QCaml/common/spin.org::*Functions][Functions:2]] *)
 let other = function
   | Alfa -> Beta
   | Beta -> Alfa
@@ -24,9 +16,9 @@ let other = function
 let to_string = function
   | Alfa -> "Alpha"
   | Beta -> "Beta "
-(* Functions:2 ends here *)
 
-(* [[file:~/QCaml/common/spin.org::*Printers][Printers:2]] *)
+
+(** Printers *)
+
 let pp ppf t =
   Format.fprintf ppf "@[%s@]" (to_string t)
-(* Printers:2 ends here *)
diff --git a/common/lib/spin.mli b/common/lib/spin.mli
index 0b2391a..0738969 100644
--- a/common/lib/spin.mli
+++ b/common/lib/spin.mli
@@ -1,21 +1,23 @@
-(* Type
- * 
- *    <<<~Spin.t~>>> *)
+(** Spin *)
 
-(* [[file:~/QCaml/common/spin.org::*Type][Type:1]] *)
+(* Electron spin *)
+
+
+(** Type *)
 type t = Alfa | Beta
-(* Type:1 ends here *)
 
-(* Functions *)
+(** Note :
+   ~Alfa~ if written with an 'f' instead of 'ph' because it has the same
+   number of letters as ~Beta~, so the alignment of the code is nicer.
+ *)
 
 
-(* [[file:~/QCaml/common/spin.org::*Functions][Functions:1]] *)
+(** Functions *)
+
 val other : t -> t
-(* Functions:1 ends here *)
-
-(* Printers *)
+(** Returns the opposite spin. *)
 
 
-(* [[file:~/QCaml/common/spin.org::*Printers][Printers:1]] *)
+(** Printers *)
+
 val pp : Format.formatter -> t -> unit
-(* Printers:1 ends here *)
diff --git a/common/lib/zkey.ml b/common/lib/zkey.ml
index da41ef9..7f88fac 100644
--- a/common/lib/zkey.ml
+++ b/common/lib/zkey.ml
@@ -1,5 +1,36 @@
-(* [[file:~/QCaml/common/zkey.org::*Types][Types:2]] *)
-type t = 
+(** ZKey *)
+
+(*
+ * Encodes the powers of x, y, z in a compact form, suitable for being
+ * used as keys in a hash table.
+ *
+ * Internally, the ~Zkey.t~ is made of two integers, ~left~ and ~right~.
+ * The small integers x, y and z are stored compactly in this 126-bits
+ * space:
+ *
+ *  Example:
+ *                               Left                                                                Right
+ *  3 [--------------------------------------------------------------]       [------------------|---------------|---------------|---------------]
+ *                                                                                                    x               y               z        
+ *
+ *  6 [--------------------------------------------------------------]       [---|----------|----------|----------|----------|----------|---------]
+ *                                                                                 x1         y1         z1         x2         y2         z2        
+ *
+ *  9 [---------------------------------|----------|----------|---------]    [---|----------|----------|----------|----------|----------|---------]
+ *                                      x1         y1         z1                 x2         y2         z2         x3         y3         z3        
+ *
+ * 12 [---|----------|----------|----------|----------|----------|---------] [---|----------|----------|----------|----------|----------|---------]
+ *        x1         y1         z1         x2         y2         z2              x3         y3         z3         x4         y4         z4
+ *
+ *
+ * The values of x,y,z should be positive and should not exceed 32767 for
+ * ~kind=3~. For all other kinds kinds the values should not exceed 1023.
+ *
+ *)
+
+(** Types *)
+
+type t =
   {
     mutable left   : int;
     mutable right  : int;
@@ -8,46 +39,31 @@ type t =
 
 open Powers
 
-type kind = 
+type kind =
   | Three  of  Powers.t
   | Four   of (int * int * int * int)
   | Six    of (Powers.t * Powers.t)
   | Nine   of (Powers.t * Powers.t * Powers.t)
   | Twelve of (Powers.t * Powers.t * Powers.t * Powers.t)
-(* Types:2 ends here *)
 
 
-
-(* | ~of_powers_three~ | Create from a ~Powers.t~       |
- * | ~of_powers_six~   | Create from two ~Powers.t~     |
- * | ~of_powers_nine~  | Create from three ~Powers.t~   |
- * | ~of_powers_twelve~ | Create from four ~Powers.t~    |
- * | ~of_powers~       | Create using the ~kind~ type   |
- * | ~of_int_array~    | Convert from an ~int~ array    |
- * | ~of_int_four~     | Create from four ~ints~        |
- * | ~to_int_array~    | Convert to an ~int~ array      |
- * | ~to_powers~       | Convert to an ~Powers.t~ array |
- * | ~to_string~       | Pretty printing                | *)
-
-
-(* [[file:~/QCaml/common/zkey.org::*Conversions][Conversions:2]] *)
 (** Creates a Zkey. *)
 let make ~kind right =
   { left = 0 ; right ; kind }
 
 (** Move [right] to [left] and set [right = x] *)
-let (<|) z x = 
+let (<|) z x =
   z.left  <- z.right;
   z.right <- x;
   z
 
 (** Shift left [right] by 10 bits, and add [x]. *)
-let (<<) z x =  
+let (<<) z x =
   z.right <- (z.right lsl 10) lor x ;
   z
 
 (** Shift left [right] by 10 bits, and add [x]. *)
-let (<+) z x =  
+let (<+) z x =
   z.right <- (z.right lsl 15) lor x ;
   z
 
@@ -71,34 +87,34 @@ let of_int_four i j k l =
 let of_powers_six   { x=a ; y=b ; z=c ; _ } { x=d ; y=e ; z=f ; _ } =
   assert (
     let alpha = a lor b lor c lor d lor e lor f in
-    alpha >= 0 && alpha < (1 lsl 10) 
+    alpha >= 0 && alpha < (1 lsl 10)
   );
-  make ~kind:6 a << b << c << d << e << f 
+  make ~kind:6 a << b << c << d << e << f
 
 
 let of_powers_nine { x=a ; y=b ; z=c ; _ } { x=d ; y=e ; z=f ; _ }
-    { x=g ; y=h ; z=i ; _ } = 
+    { x=g ; y=h ; z=i ; _ } =
   assert (
     let alpha = a lor b lor c lor d lor e lor f lor g lor h lor i in
-    alpha >= 0 && alpha < (1 lsl 10) 
+    alpha >= 0 && alpha < (1 lsl 10)
   );
   make ~kind:9 a << b << c << d << e << f
-  <| g << h << i 
+  <| g << h << i
 
 
 let of_powers_twelve { x=a ; y=b ; z=c ; _ } { x=d ; y=e ; z=f ; _ }
-    { x=g ; y=h ; z=i ; _ } { x=j ; y=k ; z=l ; _ }  = 
+    { x=g ; y=h ; z=i ; _ } { x=j ; y=k ; z=l ; _ }  =
   assert (
     let alpha = a lor b lor c lor d lor e lor f
                 lor g lor h lor i lor j lor k lor l
     in
-    alpha >= 0 && alpha < (1 lsl 10) 
+    alpha >= 0 && alpha < (1 lsl 10)
   );
   make ~kind:12  a << b << c << d << e << f
   <| g << h << i << j << k << l
 
 
-let of_powers a = 
+let of_powers a =
   match a with
   | Three   a        -> of_powers_three  a
   | Six    (a,b)     -> of_powers_six    a b
@@ -117,7 +133,7 @@ let of_int_array = function
 
 
 (** Transform the Zkey into an int array *)
-let to_int_array { left ; right ; kind }  = 
+let to_int_array { left ; right ; kind }  =
   match kind with
   | 3  -> [|
       mask15 land (right lsr 30) ;
@@ -132,7 +148,7 @@ let to_int_array { left ; right ; kind }  =
       mask15 land  right
     |]
 
-  | 6  -> [| 
+  | 6  -> [|
       mask10 land (right lsr 50) ;
       mask10 land (right lsr 40) ;
       mask10 land (right lsr 30) ;
@@ -172,7 +188,7 @@ let to_int_array { left ; right ; kind }  =
 
 
 (** Transform the Zkey into an int tuple *)
-let to_powers { left ; right ; kind } = 
+let to_powers { left ; right ; kind } =
   match kind with
   | 3  -> Three (Powers.of_int_tuple (
     mask15 land (right lsr 30) ,
@@ -180,7 +196,7 @@ let to_powers { left ; right ; kind } =
     mask15 land  right
   ))
 
-  | 6  -> Six (Powers.of_int_tuple 
+  | 6  -> Six (Powers.of_int_tuple
                  ( mask10 land (right lsr 50) ,
                    mask10 land (right lsr 40) ,
                    mask10 land (right lsr 30)),
@@ -190,7 +206,7 @@ let to_powers { left ; right ; kind } =
                    mask10 land right )
               )
 
-  | 12 -> Twelve (Powers.of_int_tuple 
+  | 12 -> Twelve (Powers.of_int_tuple
                     ( mask10 land (left  lsr 50) ,
                       mask10 land (left  lsr 40) ,
                       mask10 land (left  lsr 30)),
@@ -208,7 +224,7 @@ let to_powers { left ; right ; kind } =
                       mask10 land  right )
                  )
 
-  | 9  -> Nine (Powers.of_int_tuple 
+  | 9  -> Nine (Powers.of_int_tuple
                   ( mask10 land (left  lsr 20) ,
                     mask10 land (left  lsr 10) ,
                     mask10 land  left ) ,
@@ -223,17 +239,9 @@ let to_powers { left ; right ; kind } =
                )
 
   | _ -> invalid_arg (__FILE__^": to_powers")
-(* Conversions:2 ends here *)
 
 
-
-(* | ~hash~    | Associates a nonnegative integer to any Zkey    |
- * | ~equal~   | The equal function. True if two Zkeys are equal |
- * | ~compare~ | Comparison function, used for sorting           | *)
-
-
-(* [[file:~/QCaml/common/zkey.org::*Functions for hash tables][Functions for hash tables:2]] *)
-let hash = Hashtbl.hash 
+let hash = Hashtbl.hash
 
 let equal
     { right = r1 ; left = l1 ; kind = k1 }
@@ -259,9 +267,7 @@ let to_string { left ; right ; kind } =
     |> Array.to_list
     |> String.concat ", "
   ) ^ " >"
-(* Functions for hash tables:2 ends here *)
 
-(* [[file:~/QCaml/common/zkey.org::*Printers][Printers:2]] *)
+(** Printers *)
 let pp ppf t =
   Format.fprintf ppf "@[%s@]" (to_string t)
-(* Printers:2 ends here *)
diff --git a/common/lib/zkey.mli b/common/lib/zkey.mli
index b4ea3f3..f841f53 100644
--- a/common/lib/zkey.mli
+++ b/common/lib/zkey.mli
@@ -1,9 +1,6 @@
-(* Types
- * 
- *    <<<~Zkey.t~>>> *)
+(** Types *)
 
-(* [[file:~/QCaml/common/zkey.org::*Types][Types:1]] *)
-type t 
+type t
 
 type kind =
   | Three  of  Powers.t
@@ -11,36 +8,54 @@ type kind =
   | Six    of (Powers.t * Powers.t)
   | Nine   of (Powers.t * Powers.t * Powers.t)
   | Twelve of (Powers.t * Powers.t * Powers.t * Powers.t)
-(* Types:1 ends here *)
-
-(* Conversions *)
 
 
-(* [[file:~/QCaml/common/zkey.org::*Conversions][Conversions:1]] *)
+(** Conversions *)
+
 val of_powers_three  : Powers.t -> t
+(** Create from a ~Powers.t~ *)
+
 val of_powers_six    : Powers.t -> Powers.t -> t
+(** Create from two ~Powers.t~ *)
+
 val of_powers_nine   : Powers.t -> Powers.t -> Powers.t -> t
+(** Create from three ~Powers.t~ *)
+
 val of_powers_twelve : Powers.t -> Powers.t -> Powers.t -> Powers.t -> t
+(** Create from four ~Powers.t~ *)
+
 val of_powers        : kind -> t
+(** Create using the ~kind~ type *)
+
 val of_int_array     : int array -> t
+(** Convert from an ~int~ array *)
+
 val of_int_four      : int -> int -> int -> int -> t
+(** Create from four ~ints~ *)
+
 val to_int_array     : t -> int array
+(** Convert to an ~int~ array *)
+
 val to_powers        : t -> kind
+(** Convert to an ~Powers.t~ array *)
+
 val to_string        : t -> string
-(* Conversions:1 ends here *)
-
-(* Functions for hash tables *)
+(** Pretty printing *)
 
 
-(* [[file:~/QCaml/common/zkey.org::*Functions for hash tables][Functions for hash tables:1]] *)
+(** Functions for hash tables *)
+
 val hash    : t -> int
+(** Associates a nonnegative integer to any Zkey *)
+
 val equal   : t -> t -> bool
+(** The equal function. True if two Zkeys are equal *)
+
 val compare : t -> t -> int
-(* Functions for hash tables:1 ends here *)
-
-(* Printers *)
+(** Comparison function, used for sorting *)
 
 
-(* [[file:~/QCaml/common/zkey.org::*Printers][Printers:1]] *)
+(** Printers *)
+
 val pp : Format.formatter -> t -> unit
-(* Printers:1 ends here *)
+
diff --git a/common/lib/zmap.ml b/common/lib/zmap.ml
index e8a7aff..5e26ad5 100644
--- a/common/lib/zmap.ml
+++ b/common/lib/zmap.ml
@@ -1,4 +1,2 @@
-(* [[file:~/QCaml/common/zmap.org::*Type][Type:2]] *)
 module Zmap = Hashtbl.Make(Zkey)
 include Zmap
-(* Type:2 ends here *)
diff --git a/common/lib/zmap.mli b/common/lib/zmap.mli
index 198e7ce..4a747c6 100644
--- a/common/lib/zmap.mli
+++ b/common/lib/zmap.mli
@@ -1,7 +1,6 @@
-(* Type
- * 
- *    <<<~Zmap.t~>>> *)
+(** ZMap *)
 
-(* [[file:~/QCaml/common/zmap.org::*Type][Type:1]] *)
+(*  A hash table where the keys are ~Zkey~ *)
+
+(** Type *)
 include module type of Hashtbl.Make(Zkey)
-(* Type:1 ends here *)
diff --git a/common/powers.org b/common/powers.org
deleted file mode 100644
index f8f72a0..0000000
--- a/common/powers.org
+++ /dev/null
@@ -1,131 +0,0 @@
-#+begin_src elisp tangle: no :results none :exports none
-(setq pwd (file-name-directory buffer-file-name))
-(setq name (file-name-nondirectory (substring buffer-file-name 0 -4)))
-(setq lib (concat pwd "lib/"))
-(setq testdir (concat pwd "test/"))
-(setq mli (concat lib name ".mli"))
-(setq ml  (concat lib name ".ml"))
-(setq test-ml  (concat testdir name ".ml"))
-(org-babel-tangle)
-#+end_src
-
-* Powers
-  :PROPERTIES:
-  :header-args: :noweb yes :comments both
-  :END:
-
- Contains powers of $x$, $y$ and $z$ describing the polynomials in atomic basis sets.
-
-** Type
-
-   <<<~Powers.t~>>>
-   #+begin_src ocaml :tangle (eval mli)
-type t = private {
-  x   : int ;
-  y   : int ;
-  z   : int ;
-  tot : int ;
-}
-   #+end_src
-
-   ~tot~ always contains ~x+y+z~.
-
-   #+begin_src ocaml :tangle (eval ml) :exports none
-type t = {
-  x   : int ;
-  y   : int ;
-  z   : int ;
-  tot : int ;
-}
-   #+end_src
-
-** Conversions
-
-    #+begin_src ocaml :tangle (eval mli)
-val of_int_tuple : int * int * int -> t
-val to_int_tuple : t -> int * int * int
-    #+end_src
-
-   Example:
-    #+begin_example
-Powers.of_int_tuple (2,3,1);;
-- : Powers.t = x^2 + y^3 + z^1
-
-Powers.(to_int_tuple (of_int_tuple (2,3,1)));;
-- : int * int * int = (2, 3, 1)
-    #+end_example
-
-    #+begin_src ocaml :tangle (eval ml) :exports none
-let of_int_tuple t =
-  let result =
-    match t with
-    | (x,y,z) -> { x ; y ; z ; tot=x+y+z }
-  in
-  if result.x < 0 ||
-     result.y < 0 ||
-     result.z < 0 ||
-     result.tot < 0 then
-      invalid_arg (__FILE__^": of_int_tuple");
-  result
-
-
-let to_int_tuple { x ; y ; z ; _ } = (x,y,z)
-    #+end_src
-
-** Operations
-
-    #+begin_src ocaml :tangle (eval mli)
-val get  : Coordinate.axis -> t -> int
-val incr : Coordinate.axis -> t -> t
-val decr : Coordinate.axis -> t -> t
-    #+end_src
-
-| ~get~ | Returns the value of the power for $x$, $y$ or $z$
-| ~incr~ | Returns a new ~Powers.t~ with the power on the given axis incremented |
-| ~decr~ | Returns a new ~Powers.t~ with the power on the given axis decremented. As opposed to ~of_int_tuple~, the values may become negative|
-
-   Example:
-    #+begin_example
-Powers.get Coordinate.Y (Powers.of_int_tuple (2,3,1));;
-- : int = 3
-
-Powers.incr Coordinate.Y (Powers.of_int_tuple (2,3,1));;
-- : Powers.t = x^2 + y^4 + z^1
-
-Powers.decr Coordinate.Y (Powers.of_int_tuple (2,3,1));;
-- : Powers.t = x^2 + y^2 + z^1
-    #+end_example
-
-
-    #+begin_src ocaml :tangle (eval ml) :exports none
-let get coord t =
-  match coord with
-  | Coordinate.X -> t.x
-  | Coordinate.Y -> t.y
-  | Coordinate.Z -> t.z
-
-let incr coord t =
-  match coord with
-  | Coordinate.X -> let r = t.x+1 in { t with x = r ; tot = t.tot+1 }
-  | Coordinate.Y -> let r = t.y+1 in { t with y = r ; tot = t.tot+1 }
-  | Coordinate.Z -> let r = t.z+1 in { t with z = r ; tot = t.tot+1 }
-
-let decr coord t =
-  match coord with
-  | Coordinate.X -> let r = t.x-1 in { t with x = r ; tot = t.tot-1 }
-  | Coordinate.Y -> let r = t.y-1 in { t with y = r ; tot = t.tot-1 }
-  | Coordinate.Z -> let r = t.z-1 in { t with z = r ; tot = t.tot-1 }
-    #+end_src
-
-
-** Printers
-
-   #+begin_src ocaml :tangle (eval mli)
-val pp : Format.formatter -> t -> unit
-   #+end_src
-
-   #+begin_src ocaml :tangle (eval ml) :exports none
-let pp ppf t =
-  Format.fprintf ppf "@[x^%d + y^%d + z^%d@]" t.x t.y t.z
-   #+end_src
-
diff --git a/common/range.org b/common/range.org
deleted file mode 100644
index 06de80f..0000000
--- a/common/range.org
+++ /dev/null
@@ -1,97 +0,0 @@
-#+begin_src elisp tangle: no :results none :exports none
-(setq pwd (file-name-directory buffer-file-name))
-(setq name (file-name-nondirectory (substring buffer-file-name 0 -4)))
-(setq lib (concat pwd "lib/"))
-(setq testdir (concat pwd "test/"))
-(setq mli (concat lib name ".mli"))
-(setq ml  (concat lib name ".ml"))
-(setq test-ml  (concat testdir name ".ml"))
-(org-babel-tangle)
-#+end_src 
-
-*  Range
-  :PROPERTIES:
-  :header-args: :noweb yes :comments both
-  :END:
-
-  A range is a sorted list of integers in an interval.
-  
-  - ~"[a-b]"~ : range between a and b (included)
-  - ~"[a]"~   : the list with only one integer a
-  - ~"a"~     : equivalent to "[a]"
-  - ~"[36-53,72-107,126-131]"~ represents the list of integers
-    [ 37 ; 37 ; 38 ; ... ; 52 ; 53 ; 72 ; 73 ; ... ; 106 ; 107 ; 126 ; 127 ; ... ; 130 ; 131 ].
-
-** Type
-
-   <<<~Range.t~>>>
-   #+begin_src ocaml :tangle (eval mli)
-type t
-   #+end_src
-
-   #+begin_src ocaml :tangle (eval ml) :exports none
-type t = int list
-   #+end_src
-
-** Conversion
-
-   #+begin_src ocaml :tangle (eval mli)
-val of_string   : string -> t
-val to_string   : t -> string
-val to_int_list : t -> int list
-   #+end_src
-
-   #+begin_src ocaml :tangle (eval ml) :exports none
-let to_int_list r = r
-
-let expand_range r =
-  match String.split_on_char '-' r with
-  | s :: f :: [] ->
-      begin
-        let start = int_of_string s
-        and finish =  int_of_string f
-        in
-        assert (start <= finish) ;
-        let rec do_work = function
-          | i when i=finish -> [ i ]
-          | i     -> i::(do_work (i+1))
-        in do_work start
-      end
-  | r :: [] -> [int_of_string r]
-  | [] -> []
-  | _ -> invalid_arg "Only one range expected"
-
-
-let of_string s =
-  match s.[0] with
-  | '0' .. '9' -> [ int_of_string s ]
-  | _ ->
-      assert (s.[0] = '[') ;
-      assert (s.[(String.length s)-1] = ']') ;
-      let s = String.sub s 1 ((String.length s) - 2) in
-      let l = String.split_on_char ',' s in
-      let l = List.map expand_range l in
-      List.concat l
-      |> List.sort_uniq compare
-
-
-let to_string l =
-  "[" ^
-  (List.map string_of_int l
-   |> String.concat ",") ^
-  "]"
-
-   #+end_src
-
-
-** Printers
-
-   #+begin_src ocaml :tangle (eval mli)
-val pp : Format.formatter -> t -> unit
-   #+end_src
-
-   #+begin_src ocaml :tangle (eval ml) :exports none
-let pp ppf t =
-  Format.fprintf ppf "@[%s@]" (to_string t)
-   #+end_src
-
diff --git a/common/spin.org b/common/spin.org
deleted file mode 100644
index 9d501c8..0000000
--- a/common/spin.org
+++ /dev/null
@@ -1,64 +0,0 @@
-#+begin_src elisp tangle: no :results none :exports none
-(setq pwd (file-name-directory buffer-file-name))
-(setq name (file-name-nondirectory (substring buffer-file-name 0 -4)))
-(setq lib (concat pwd "lib/"))
-(setq testdir (concat pwd "test/"))
-(setq mli (concat lib name ".mli"))
-(setq ml  (concat lib name ".ml"))
-(setq test-ml  (concat testdir name ".ml"))
-(org-babel-tangle)
-#+end_src 
-
-* Spin
-  :PROPERTIES:
-  :header-args: :noweb yes :comments both
-  :END:
-
-  Electron spin
-  
-** Type
-
-   <<<~Spin.t~>>>
-   #+begin_src ocaml :tangle (eval mli)
-type t = Alfa | Beta
-   #+end_src
-
-   Note :
-   ~Alfa~ if written with an 'f' instead of 'ph' because it has the same number of
-   letters as ~Beta~, so the alignment of the code is nicer.
-
-   #+begin_src ocaml :tangle (eval ml) :exports none
-type t =  (* m_s *)
-  | Alfa (* {% $m_s = +1/2$ %} *)
-  | Beta (* {% $m_s = -1/2$ %} *)
-   #+end_src
-
-** Functions
-
-   #+begin_src ocaml :tangle (eval mli)
-val other : t -> t
-   #+end_src
-
-   Returns the opposite spin
-   
-   #+begin_src ocaml :tangle (eval ml) :exports none
-let other = function
-  | Alfa -> Beta
-  | Beta -> Alfa
-
-let to_string = function
-  | Alfa -> "Alpha"
-  | Beta -> "Beta "
-   #+end_src
-
-** Printers
-
-   #+begin_src ocaml :tangle (eval mli)
-val pp : Format.formatter -> t -> unit
-   #+end_src
-
-   #+begin_src ocaml :tangle (eval ml) :exports none
-let pp ppf t =
-  Format.fprintf ppf "@[%s@]" (to_string t)
-   #+end_src
-
diff --git a/common/zkey.org b/common/zkey.org
deleted file mode 100644
index 5a7bd04..0000000
--- a/common/zkey.org
+++ /dev/null
@@ -1,348 +0,0 @@
-#+begin_src elisp tangle: no :results none :exports none
-(setq pwd (file-name-directory buffer-file-name))
-(setq name (file-name-nondirectory (substring buffer-file-name 0 -4)))
-(setq lib (concat pwd "lib/"))
-(setq testdir (concat pwd "test/"))
-(setq mli (concat lib name ".mli"))
-(setq ml  (concat lib name ".ml"))
-(setq test-ml  (concat testdir name ".ml"))
-(org-babel-tangle)
-#+end_src 
-
-* Zkey
-  :PROPERTIES:
-  :header-args: :noweb yes :comments both
-  :END:
-
-  Encodes the powers of x, y, z in a compact form, suitable for being
-  used as keys in a hash table.
-
-  Internally, the ~Zkey.t~ is made of two integers, ~left~ and ~right~.
-  The small integers x, y and z are stored compactly in this 126-bits
-  space:
-
-   Example:
-  #+begin_example
-                                Left                                                                Right
- 3 [--------------------------------------------------------------]       [------------------|---------------|---------------|---------------]
-                                                                                                     x               y               z        
-
- 6 [--------------------------------------------------------------]       [---|----------|----------|----------|----------|----------|---------]
-                                                                                   x1         y1         z1         x2         y2         z2        
-
- 9 [---------------------------------|----------|----------|---------]    [---|----------|----------|----------|----------|----------|---------]
-                                          x1         y1         z1                 x2         y2         z2         x3         y3         z3        
-
-12 [---|----------|----------|----------|----------|----------|---------] [---|----------|----------|----------|----------|----------|---------]
-            x1         y1         z1         x2         y2         z2              x3         y3         z3         x4         y4         z4
-  #+end_example
-
-  The values of x,y,z should be positive and should not exceed 32767 for
-  ~kind=3~. For all other kinds kinds the values should not exceed 1023.
-
-** Types
-
-   <<<~Zkey.t~>>>
-   #+begin_src ocaml :tangle (eval mli)
-type t 
-
-type kind =
-  | Three  of  Powers.t
-  | Four   of (int * int * int * int)
-  | Six    of (Powers.t * Powers.t)
-  | Nine   of (Powers.t * Powers.t * Powers.t)
-  | Twelve of (Powers.t * Powers.t * Powers.t * Powers.t)
-   #+end_src
-
-   #+begin_src ocaml :tangle (eval ml) :exports none
-type t = 
-  {
-    mutable left   : int;
-    mutable right  : int;
-    kind   : int ;
-  }
-
-open Powers
-
-type kind = 
-  | Three  of  Powers.t
-  | Four   of (int * int * int * int)
-  | Six    of (Powers.t * Powers.t)
-  | Nine   of (Powers.t * Powers.t * Powers.t)
-  | Twelve of (Powers.t * Powers.t * Powers.t * Powers.t)
-   #+end_src
-
-** Conversions
-
-   #+begin_src ocaml :tangle (eval mli)
-val of_powers_three  : Powers.t -> t
-val of_powers_six    : Powers.t -> Powers.t -> t
-val of_powers_nine   : Powers.t -> Powers.t -> Powers.t -> t
-val of_powers_twelve : Powers.t -> Powers.t -> Powers.t -> Powers.t -> t
-val of_powers        : kind -> t
-val of_int_array     : int array -> t
-val of_int_four      : int -> int -> int -> int -> t
-val to_int_array     : t -> int array
-val to_powers        : t -> kind
-val to_string        : t -> string
-   #+end_src
-
-   | ~of_powers_three~ | Create from a ~Powers.t~       |
-   | ~of_powers_six~   | Create from two ~Powers.t~     |
-   | ~of_powers_nine~  | Create from three ~Powers.t~   |
-   | ~of_powers_twelve~ | Create from four ~Powers.t~    |
-   | ~of_powers~       | Create using the ~kind~ type   |
-   | ~of_int_array~    | Convert from an ~int~ array    |
-   | ~of_int_four~     | Create from four ~ints~        |
-   | ~to_int_array~    | Convert to an ~int~ array      |
-   | ~to_powers~       | Convert to an ~Powers.t~ array |
-   | ~to_string~       | Pretty printing                |
-
-   #+begin_src ocaml :tangle (eval ml) :exports none
-(** Creates a Zkey. *)
-let make ~kind right =
-  { left = 0 ; right ; kind }
-
-(** Move [right] to [left] and set [right = x] *)
-let (<|) z x = 
-  z.left  <- z.right;
-  z.right <- x;
-  z
-
-(** Shift left [right] by 10 bits, and add [x]. *)
-let (<<) z x =  
-  z.right <- (z.right lsl 10) lor x ;
-  z
-
-(** Shift left [right] by 10 bits, and add [x]. *)
-let (<+) z x =  
-  z.right <- (z.right lsl 15) lor x ;
-  z
-
-
-let of_powers_three { x=a ; y=b ; z=c ; _ } =
-  assert (
-    let alpha = a lor b lor c in
-    alpha >= 0 && alpha < (1 lsl 15)
-  );
-  make ~kind:3 a <+ b <+ c
-
-
-let of_int_four i j k l =
-  assert (
-    let alpha = i lor j lor k lor l in
-    alpha >= 0 && alpha < (1 lsl 15)
-  );
-  make ~kind:4 i <+ j <+ k <+ l
-
-
-let of_powers_six   { x=a ; y=b ; z=c ; _ } { x=d ; y=e ; z=f ; _ } =
-  assert (
-    let alpha = a lor b lor c lor d lor e lor f in
-    alpha >= 0 && alpha < (1 lsl 10) 
-  );
-  make ~kind:6 a << b << c << d << e << f 
-
-
-let of_powers_nine { x=a ; y=b ; z=c ; _ } { x=d ; y=e ; z=f ; _ }
-    { x=g ; y=h ; z=i ; _ } = 
-  assert (
-    let alpha = a lor b lor c lor d lor e lor f lor g lor h lor i in
-    alpha >= 0 && alpha < (1 lsl 10) 
-  );
-  make ~kind:9 a << b << c << d << e << f
-  <| g << h << i 
-
-
-let of_powers_twelve { x=a ; y=b ; z=c ; _ } { x=d ; y=e ; z=f ; _ }
-    { x=g ; y=h ; z=i ; _ } { x=j ; y=k ; z=l ; _ }  = 
-  assert (
-    let alpha = a lor b lor c lor d lor e lor f
-                lor g lor h lor i lor j lor k lor l
-    in
-    alpha >= 0 && alpha < (1 lsl 10) 
-  );
-  make ~kind:12  a << b << c << d << e << f
-  <| g << h << i << j << k << l
-
-
-let of_powers a = 
-  match a with
-  | Three   a        -> of_powers_three  a
-  | Six    (a,b)     -> of_powers_six    a b
-  | Twelve (a,b,c,d) -> of_powers_twelve a b c d
-  | Nine   (a,b,c)   -> of_powers_nine   a b c
-  | _                -> invalid_arg "of_powers"
-
-
-let mask10 = 0x3ff
-and mask15 = 0x7fff
-
-
-let of_int_array = function
-  | [| a ; b ; c ; d |] -> of_int_four a b c d
-  | _ -> invalid_arg "of_int_array"
-
-
-(** Transform the Zkey into an int array *)
-let to_int_array { left ; right ; kind }  = 
-  match kind with
-  | 3  -> [|
-      mask15 land (right lsr 30) ;
-      mask15 land (right lsr 15) ;
-      mask15 land  right
-    |]
-
-  | 4  -> [|
-      mask15 land (right lsr 45) ;
-      mask15 land (right lsr 30) ;
-      mask15 land (right lsr 15) ;
-      mask15 land  right
-    |]
-
-  | 6  -> [| 
-      mask10 land (right lsr 50) ;
-      mask10 land (right lsr 40) ;
-      mask10 land (right lsr 30) ;
-      mask10 land (right lsr 20) ;
-      mask10 land (right lsr 10) ;
-      mask10 land right
-    |]
-
-  | 12 -> [|
-      mask10 land (left  lsr 50) ;
-      mask10 land (left  lsr 40) ;
-      mask10 land (left  lsr 30) ;
-      mask10 land (left  lsr 20) ;
-      mask10 land (left  lsr 10) ;
-      mask10 land  left ;
-      mask10 land (right lsr 50) ;
-      mask10 land (right lsr 40) ;
-      mask10 land (right lsr 30) ;
-      mask10 land (right lsr 20) ;
-      mask10 land (right lsr 10) ;
-      mask10 land  right
-    |]
-
-  | 9  -> [|
-      mask10 land (left  lsr 20) ;
-      mask10 land (left  lsr 10) ;
-      mask10 land  left ;
-      mask10 land (right lsr 50) ;
-      mask10 land (right lsr 40) ;
-      mask10 land (right lsr 30) ;
-      mask10 land (right lsr 20) ;
-      mask10 land (right lsr 10) ;
-      mask10 land  right
-    |]
-  | _ -> invalid_arg (__FILE__^": to_int_array")
-
-
-
-(** Transform the Zkey into an int tuple *)
-let to_powers { left ; right ; kind } = 
-  match kind with
-  | 3  -> Three (Powers.of_int_tuple (
-    mask15 land (right lsr 30) ,
-    mask15 land (right lsr 15) ,
-    mask15 land  right
-  ))
-
-  | 6  -> Six (Powers.of_int_tuple 
-                 ( mask10 land (right lsr 50) ,
-                   mask10 land (right lsr 40) ,
-                   mask10 land (right lsr 30)),
-               Powers.of_int_tuple
-                 ( mask10 land (right lsr 20) ,
-                   mask10 land (right lsr 10) ,
-                   mask10 land right )
-              )
-
-  | 12 -> Twelve (Powers.of_int_tuple 
-                    ( mask10 land (left  lsr 50) ,
-                      mask10 land (left  lsr 40) ,
-                      mask10 land (left  lsr 30)),
-                  Powers.of_int_tuple
-                    ( mask10 land (left  lsr 20) ,
-                      mask10 land (left  lsr 10) ,
-                      mask10 land  left ) ,
-                  Powers.of_int_tuple
-                    ( mask10 land (right lsr 50) ,
-                      mask10 land (right lsr 40) ,
-                      mask10 land (right lsr 30)),
-                  Powers.of_int_tuple
-                    ( mask10 land (right lsr 20) ,
-                      mask10 land (right lsr 10) ,
-                      mask10 land  right )
-                 )
-
-  | 9  -> Nine (Powers.of_int_tuple 
-                  ( mask10 land (left  lsr 20) ,
-                    mask10 land (left  lsr 10) ,
-                    mask10 land  left ) ,
-                Powers.of_int_tuple
-                  ( mask10 land (right lsr 50) ,
-                    mask10 land (right lsr 40) ,
-                    mask10 land (right lsr 30)),
-                Powers.of_int_tuple
-                  ( mask10 land (right lsr 20) ,
-                    mask10 land (right lsr 10) ,
-                    mask10 land  right )
-               )
-
-  | _ -> invalid_arg (__FILE__^": to_powers")
-
-
-   #+end_src
-
-** Functions for hash tables
-
-   #+begin_src ocaml :tangle (eval mli)
-val hash    : t -> int
-val equal   : t -> t -> bool
-val compare : t -> t -> int
-   #+end_src
-
-   | ~hash~    | Associates a nonnegative integer to any Zkey    |
-   | ~equal~   | The equal function. True if two Zkeys are equal |
-   | ~compare~ | Comparison function, used for sorting           |
-
-   #+begin_src ocaml :tangle (eval ml) :exports none
-let hash = Hashtbl.hash 
-
-let equal
-    { right = r1 ; left = l1 ; kind = k1 }
-    { right = r2 ; left = l2 ; kind = k2 } =
-  r1 = r2 && l1 = l2 && k1 = k2
-
-
-let compare
-    { right = r1 ; left = l1 ; kind = k1 }
-    { right = r2 ; left = l2 ; kind = k2 } =
-  if k1 <> k2 then invalid_arg (__FILE__^": cmp");
-  if r1 < r2 then -1
-  else if r1 > r2 then 1
-  else if l1 < l2 then -1
-  else if l1 > l2 then 1
-  else 0
-
-
-let to_string { left ; right ; kind } =
-  "< " ^  string_of_int left  ^ string_of_int right ^ " | " ^ (
-    to_int_array { left ; right ; kind }
-    |> Array.map string_of_int
-    |> Array.to_list
-    |> String.concat ", "
-  ) ^ " >"
-   #+end_src
-
-** Printers
-
-   #+begin_src ocaml :tangle (eval mli)
-val pp : Format.formatter -> t -> unit
-   #+end_src
-
-   #+begin_src ocaml :tangle (eval ml) :exports none
-let pp ppf t =
-  Format.fprintf ppf "@[%s@]" (to_string t)
-   #+end_src
diff --git a/common/zmap.org b/common/zmap.org
deleted file mode 100644
index c4b01de..0000000
--- a/common/zmap.org
+++ /dev/null
@@ -1,30 +0,0 @@
-#+begin_src elisp tangle: no :results none :exports none
-(setq pwd (file-name-directory buffer-file-name))
-(setq name (file-name-nondirectory (substring buffer-file-name 0 -4)))
-(setq lib (concat pwd "lib/"))
-(setq testdir (concat pwd "test/"))
-(setq mli (concat lib name ".mli"))
-(setq ml  (concat lib name ".ml"))
-(setq test-ml  (concat testdir name ".ml"))
-(org-babel-tangle)
-#+end_src 
-
-* Zmap
-  :PROPERTIES:
-  :header-args: :noweb yes :comments both
-  :END:
-
-  A hash table where the keys are ~Zkey~
-  
-** Type
-
-   <<<~Zmap.t~>>>
-   #+begin_src ocaml :tangle (eval mli)
-include module type of Hashtbl.Make(Zkey)
-   #+end_src
-
-   #+begin_src ocaml :tangle (eval ml) :exports none
-module Zmap = Hashtbl.Make(Zkey)
-include Zmap
-   #+end_src
-
diff --git a/top/lib/install_printers.ml b/top/lib/install_printers.ml
index bf38de5..4ac491a 100644
--- a/top/lib/install_printers.ml
+++ b/top/lib/install_printers.ml
@@ -1,8 +1,6 @@
 (* [[file:~/QCaml/top/install_printers.org::*Intall printers][Intall printers:3]] *)
 let printers =
   [
-    "Common.Charge.pp" ;
-    "Common.Coordinate.pp" ;
     "Common.Powers.pp" ;
     "Common.Range.pp" ;
     "Common.Spin.pp" ;