(***********************************************************************)
(*                                                                     *)
(*                                                                     *)
(***********************************************************************)
open Bsml
(** Fonctions usuelles  *)
let replicate a =mkpar (fun _ -> a)
let parfun f v = apply (replicate f) v
let procs = 
  let rec aux i l = 
    if i<=0 then 
      0::l else 
      aux (i-1) (i::l) 
  in aux (bsp_p -1) []

let id x  =x 
let this = (* à compléter *)

(** Parallel implementation of parallel arrays *)

(** {2 Parallel array type }  *)

type 'a parallel_array =               
(* à compléter *)
(** Type of parallel arrays  *)


(* offset and length *)
let ofs_len n pid =
  let ofs  = (* à compéter *)
  and length  = (* à compéter *)
  in (ofs , length)


(** {2 Parallel array constructors} *)

let  make : int -> 'a -> 'a parallel_array =
  fun n v -> 
    (* à compéter *)

let test = (make 10 1)
let test = (make 0 1)

let init : int -> (int -> 'a) -> 'a parallel_array =
  fun n f -> 
   (* à compléter  *)
let test = (init 10 id)
let test = (init 0 id)


let copy : 'a parallel_array -> 'a parallel_array =
  fun ap -> (* à completer  *)

let of_array : 'a array -> 'a parallel_array =
  fun a -> (* à completer  *)

let test = of_array (Array.init 10 id)
let test = of_array (Array.init 1 id)


let to_array : 'a parallel_array -> 'a array =
  fun ap ->
    let sub_array = proj ap.data 
    in
    Array.concat (List.map sub_array procs)
(** [to_array a] returns a fresh array containing the elements
   of [a]. 
*)
let test = to_array (init 10 id)



(** {2 Basic operations on parallel arrays.} *)

let length : 'a parallel_array -> int =
  fun ap -> (* à completer  *)
let test = Array.length (to_array (init 10 "a"))

let proc_offs_of_position ap x = 
(* Suggestion de fonction intermédiare
   retourne le numéro de processeur et la position local du x ème l'élément du tableau parallèle
*)

let get : 'a parallel_array -> int -> 'a =
  fun ap pos -> (* à completer  *)
let test =  Array.init 10 (get (init 10 id)) 

let set : 'a parallel_array -> int -> 'a -> unit =
  fun ap pos d ->                       
(* à compléter *)
let test =  Array.init 10 (set (init 10 id)  0 100)



let fill : 'a parallel_array -> int -> int -> 'a -> unit =
  fun ap ofs len x ->
(**
   à compléter
   indictation : vous aurez certainement besoin de la fonction 
   [ignore : 'a -> unit] qui renvoie unit quelque soit la valeur sur laquelle elle est appliquée.
*)

(** {2 map/reduce sur les tableaux parallèles.} *)

let map : ('a -> 'b) -> 'a parallel_array -> 'b parallel_array 
= 
  fun f ap ->                           
(* à compléter *)


let mapi : (int -> 'a -> 'b) -> 'a parallel_array -> 'b parallel_array
=
  fun f ap ->                           
(* à compléter *)
  
let reduce : ('b -> 'b -> 'b) -> 'b -> 'b parallel_array -> 'b
  =
  fun f x ap ->
(*  à compléter *)

let fold_left : ('a -> 'a -> 'a) -> 'a -> 'a parallel_array -> 'a
=
  fun f x ap ->
(*  à compléter 
    indication : pensez au type ['a option]
*)

(** {2 Tri} *)

let sort : ('a -> 'a -> int) -> 'a parallel_array -> 'a parallel_array
  = fun cmp ap ->
(* à compléter  
*)



(** {2 Functions avec schéma de communication non-trivial}  *)

let balance : 'a parallel_array -> 'a parallel_array 
  = fun ap ->
(* à compléter  
*)

let sub : 'a parallel_array -> int -> int -> 'a parallel_array
  = fun ap offs len ->
(* à compléter  *)

val blit : 'a parallel_array -> int -> 'a parallel_array -> int -> int -> unit
  = fun ap1 offs1 ap2 offs2 len ->
(* à compléter  *)