QCaml/Utils/Zkey.ml

open Powers

type t = 
  {
    mutable left   : int ;
    mutable right  : int ;
    kind   : int ;
  }


let of_int kind right =
  { left = 0 ; right ; kind }

let (<|) z x = 
  z.left  <- z.right;
  z.right <- x;
  z

let (<<) z x =  
  z.right <- (z.right lsl 10) lor x ;
  z

let (<+) z x =  
  z.right <- (z.right lsl 15) lor x ;
  z


type kind = 
  | Three  of  Powers.t
  | Six    of (Powers.t * Powers.t)
  | Nine   of (Powers.t * Powers.t * Powers.t)
  | Twelve of (Powers.t * Powers.t * Powers.t * Powers.t)

let of_powers_three { x=a ; y=b ; z=c ; _ } = of_int 3 a <+ b <+ c

let of_powers_six   { x=a ; y=b ; z=c ; _ } { x=d ; y=e ; z=f ; _ } =
      of_int 6 a << b << c << d << e << f 

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 ; _ }  = 
      of_int 12 a << b << c << d << e << f
          <| g << h << i << j << k << l

let of_powers_nine { x=a ; y=b ; z=c ; _ } { x=d ; y=e ; z=f ; _ }
  { x=g ; y=h ; z=i ; _ } = 
      of_int 9 a << b << c << d << e << f
          <| g << h << i 


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


let mask10 = 0x3ff
and mask15 = 0x7fff


(** 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
               |]

  | 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")



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 cmp 
  { 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 ", "
  ) ^ " >"

(*
let debug () = 
  and k3  = of_int_array Kind_3  [| 1 ; 2 ; 3 |]
  and k6  = of_int_array Kind_6  [| 1 ; 2 ; 3; 4 ; 5; 6|]
  and k12 = of_int_array Kind_12 [| 1 ; 2 ; 3; 4 ; 5; 6 ; 7 ; 8 ; 9 ; 10 ; 11; 12|]
  in
  print_endline @@ to_string Kind_3 k3 ;
  print_endline @@ to_string Kind_6 k6 ;
  print_endline @@ to_string Kind_12 k12
  
  (*
< 65538 | 1, 2 >
< 1050627 | 1, 2, 3 >
< 281483566841860 | 1, 2, 3, 4 >
< 1128102155523078 | 1, 2, 3, 4, 5, 6 >
< 20809811751934310026571282435288076 | 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 >
*)  

let () = debug ()
*)