open Definitions
open Chessrules
open Unix

(*donnees de base, liste de cases pour les positions du roi*)
let lcase =  [(0,0);(0,1);(0,2);(0,3);(0,4);(0,5);(0,6);(0,7);
             (1,0);(2,0);(3,0);(4,0);(5,0);(6,0);(7,0);
             (7,1);(7,2);(7,3);(7,4);(7,5);(7,6);(7,7);
             (6,7);(5,7);(4,7);(3,7);(2,7);(1,7);(2,2);(5,5);(5,2);(2,5);
             (1,2);(2,1);(5,1);(6,2);(1,5);(2,6);(5,6);(6,5)] ;;
 (*+ 4 cases*)

(*intro du type coordonnées*)          (* a placer dans le module definition mais ici, fichier autonome*)
type coord = int*int;;

(*fonction linearisation*)
let lin (case:coord) = (fst case) + 8*(snd case) ;;  (*notation des complexes*)

(*echiquier lineaire (case):liste singleton*)
let cvect64 (case:coord) = let temp = Array.create 64 0.0 in
  temp.(lin case) <- 1.0 ; temp;;

 (*liste de cases list_case*)
 (*
  * let lvect64 lcase = let temp=Array.create (List.length lcase) [] in
  * for k=0 to (List.length lcase) do
  *  temp.(lin (List.nth lcase k)) <- 1
  * done; temp ;;*)


(*liste des voisinages des positions du roi d'un echiquier 2D*)
let fcase (case:coord) = Ensemble.elements (voisK (fst case) (snd case)) ;; (*fcase renvoie une liste*)
(*formatage echiquier tableau du diagramme de deplacement correspondant*leroi*)
let dcaseK (case:coord) =
  let res = Array.create 64 0.0 in
 let lc = fcase case in
  for k=0 to (List.length lc)-1 do
   res.(lin (List.nth lc k)) <- 1.0
  done; res ;;

(*variante avec tableau lineaire d'entiers*)
let dcaseKInt (case:coord) =
   let res = Array.create 64 0 in
 let lc = fcase case in
  for k=0 to (List.length lc)-1 do
   res.(lin (List.nth lc k)) <- 1
  done; res ;;
dcaseKInt (0,2);; 

(* utiliser int64 ? ou float ? *)
(*puissances de 2*)
let rec pw2 (m:float) = 
 if m = 0.0 then 1.0 else 2.0*.(pw2 (m-.1.0));;

(*fct binarisation vect entree*) 
let rec bin tab (n:float) = 
 if n = 0.0 then tab.(0) else tab.(int_of_float n)*.(pw2 n)+.(bin tab (n-.1.0)) ;;   



(****************exemple:le roi****************************************************)



   

(***vecteur d'entree, exemple k *******)



let vectE k = bin (cvect64 (List.nth lcase k)) 63.0 ;;

   

(*********vecteur de sortie, exemple k**)



(*diagramme de deplacement*)

(*let vectS k = bin (dcaseK (List.nth lcase k)) 63.0 ;;*)
(*vectS 1;;*)



(******************************************)


(*normaliser les entrees sorties ?*)
let maxE = bin (cvect64 (7,7)) 63.0;;

let maxS = pw2 64.0;;

let vectEn k = (vectE k)/.maxE ;;
(*let vectSn k = (vectS k)/.maxS ;;*)

(*preparation du fichier pour JOONE*)

let formatE k = string_of_int (lin (List.nth lcase k));;
let formatS k = string_of_IntArray (dcaseKInt (List.nth lcase k)) 63 ;; 
formatS 2;;

(*insertion des "*)
let res = "";;
let rec formatSJ res i k =
 if i=0 then res else formatSJ (";"^(string_of_char (formatS k).[i])^res) (i-1) k;;   
let formatSJn k = formatSJ res 63 k;;
formatSJn 2;;

let formatES k = (formatE k)^(formatSJn k)^"\n" ;;
formatES 2;;



(*ecriture dans le fichier*)
 
 let mode = [Unix.O_WRONLY;Unix.O_CREAT;Unix.O_TRUNC;Unix.O_APPEND] ;;
  let file = Unix.openfile "data.txt" mode  0o777 ;;

let write k =
  let ch=formatES k in
  let n = Unix.write file ch 0 (String.length ch) in
if n=0 then print_endline "no output error" ;;

let copyinfile lcase=  
  for k=0 to (List.length lcase)-1 do
    write k
  done;
  Unix.close file;;

copyinfile lcase;;