(**
 	Module: Beam	
	Description: beam definition and operations
	@author WANG Haisheng	
	Created: 21/07/2013	Modified: 21/07/2013
*)

exception Beam_matching of string;;

open Types;;
open Basic;;
open Value;;
open Signal;;

class beam : signal_type array -> beam_type = 
  fun (signals_init : signal_type array) ->
    object (self)
      val signals = signals_init

      method get = signals
      method width = Array.length signals

      method sub : int -> int -> beam_type = 
	fun start ->
	  fun len ->
	    new beam (Array.sub self#get start len)

      method cut : int -> beam_type * beam_type =
	fun (cut_width : int)->
	  ((self#sub 0 cut_width),(self#sub cut_width (self#width - cut_width))) 

      method append : beam_type -> beam_type =
	fun (b : beam_type) -> 
	  new beam (Array.append self#get b#get)

      method private add_memory : int -> unit =
	fun (window : int) ->
	  let signal_add_memory : int -> signal_type -> unit = 
	    fun (l : int) ->
	      fun (s : signal) ->
		s#add_memory l in
	  let _ = Array.map (signal_add_memory window) self#get in ()
	  
      method matching : int -> beam_type = 
	  fun size ->
	    if size = self#width then new beam self#get

	    else if (size > self#width) && (size mod self#width = 0) then
	      let () = self#add_memory 1 in
	      let split_signals = 
		Array.concat (Array.to_list 
		     (Array.make (size/self#width) self#get)) in
	      new beam split_signals

	    else if (size < self#width) && (self#width mod size = 0) then
	      let rec merge_rec  = 
		fun (sa : signal_type array) ->
		  fun (l : int) ->
		    fun (i : int) ->
		      if i + l < Array.length sa then
			(sa.(i))#add (merge_rec sa l (i + l))
		      else sa.(i) in
	      let merge_signals = Array.init size (merge_rec self#get size) in	
	      new beam merge_signals

	    else raise (Beam_matching "matching size error")

      method at : time -> value_type array = 
	fun t ->
	  let signal_at = fun (t : time) -> fun (s : signal_type) -> s#at t in
	  Array.map (signal_at t) self#get

      method output : int -> value_type array array = 
	  fun (length_max : int) ->
	    let transpose : 'a array array -> 'a array array = 
	      fun matrix ->
		let get_element = fun i -> fun array -> array.(i) in
		let get_column = fun m -> fun i -> Array.map (get_element i) m in
		Array.init self#width (get_column matrix) in
            let value_init = new value Error in
	    let container = Array.make length_max 
		(Array.make self#width value_init) in
	    let index = ref 0 in

	    try
	      while !index < length_max do
		container.(!index) <- self#at !index;
		incr index;
	      done;
	      transpose container
	    with x ->

	      let error_message = 
		match x with
		| Convert_Error s -> "Convert_Error: " ^ s
		| Basic_operation s -> "Basic_operation: " ^ s
		| Signal_operation s -> "Signal_operation: " ^ s
		| Beam_matching s -> "Beam_Matching_Error: " ^ s
		| _ -> "Compute finished."
	      in
	      let () = print_string error_message in
	      transpose (Array.sub container 0 !index)

      method frequency : int array = 
	let each_rate : signal -> int = 
	  fun (s : signal) -> s#frequency in
	Array.map each_rate self#get 

    end