Module BC_Search

module BC_Search: sig  end

Search strategies

val search_neighbors : ('a -> unit) ->
       initscore:'b ->
       initparam:'c ->
       initsol:'d ->
       neighbor_gen:('c -> 'a list) ->
       solver:('e -> 'f -> ('b -> 'b -> int) -> ('d -> 'd -> int) -> 'a -> 'b * 'd) ->
       evaluator:'f ->
       compscore:('b -> 'b -> int) ->
       compsol:('d -> 'd -> int) -> data:'e -> ('a * ('b * 'd)) option

search neighborhood of a solution, and return the best neighbor (depending on comp and evaluator) return option type of Some (param, (score, solution) or None if there are no good neighbors

  'a: type of score (evaluation)
  'b: type of search space parameter
  'c: type of solution
  'd: type of neighborhood search parameters (should be equal to 'b to be of any use)
  'e: type of data
  'f: evaluator (parameter passed to solver: should influence score)
  solver: data -> evaluator -> score compare -> solution compare -> searchspace parameter -> (score * solution)
  evaluator: 'f (evaluator (any parameter) passed to solver to (perhaps) influence score)
  compscore : compare function for evaluation (scores)
  compsol  : compare function for solutions (e.g. smaller solutions are better)

val local_search : ?maxiter:int ->
       ?forneighbor:('a -> unit) ->
       ?forbestneighbor:('a * 'b * 'c -> unit) ->
       initparam:'a ->
       neighbor_gen:('a -> 'a list) ->
       solver:('d -> 'e -> ('b -> 'b -> int) -> ('c -> 'c -> int) -> 'a -> 'b * 'c) ->
       evaluator:'e ->
       compscore:('b -> 'b -> int) -> compsol:('c -> 'c -> int) -> 'd -> 'b * 'c

run local seaerch starting at initparam.

  'a: type of search space parameter
  'b: type of data
  'c: type of evaluator (parameter passed to solver to (perhaps) influence score)
  'd: type of score
  'e: type of solution
  ?maxiter:int ->                 maximum number of iterations (0 or less means infinite)
  neighbor_gen: 'a -> 'a list :   generate neighborhood of search space
  solver: data -> evaluator -> score compare -> solution compare -> searchspace parameter -> (score * solution)
  evaluator: 'c (evaluator (any parameter) passed to solver to define perhaps influence score)
  compscore: comparison function for scores
  compsol:   comparison function for solutions (e.g. smaller solutions are better)