package lbvs_consent

You can search for identifiers within the package.

in-package search v0.2.0

lbvs_consent
- Lbvs_consent
  - Atom
  - Bond
  - Consensus
    
    StringSet
    
    Exceptionless
    
    Labels
  - Consent
    
    BEDROC
    
    SL
    
    StringSet
    
    Exceptionless
    
    Labels
    
    Vpt
    
    Vpt_point
  - Fingerprint
  - Flags
  - Mini_mol
  - Mol2
  - Molecule
  - Mop2d_env
  - MyIntSet
  - MyList
    
    Internal
  - MyUtils
  - Node
  - Pair
  - Policy
  - ROC
  - Score
  - Score_label
  - Sdf
  - Smi
  - Top_keeper
    
    FMap
    
    Exceptionless
    
    Infix
    
    Labels

Legend:
Library
Module
Module type
Parameter
Class
Class type

include module type of struct include BatList end

type !'a t = 'a list =

| []
| :: of 'a * 'a list

type !'a enumerable = 'a t

type !'a mappable = 'a t

val is_empty : 'a list -> bool

val cons : 'a -> 'a list -> 'a list

val hd : 'a list -> 'a

val first : 'a list -> 'a

val tl : 'a list -> 'a list

val last : 'a list -> 'a

val length : 'a list -> int

val compare_lengths : 'a list -> 'b list -> int

val compare_length_with : 'a list -> int -> int

val at : 'a list -> int -> 'a

val at_opt : 'a list -> int -> 'a option

val rev : 'a list -> 'a list

val shuffle : ?state:Stdlib.Random.State.t -> 'a list -> 'a list

val append : 'a list -> 'a list -> 'a list

val rev_append : 'a list -> 'a list -> 'a list

val concat : 'a list list -> 'a list

val flatten : 'a list list -> 'a list

val make : int -> 'a -> 'a list

val range : int -> [< `Downto | `To ] -> int -> int list

val frange : float -> [< `Downto | `To ] -> float -> int -> float list

val init : int -> (int -> 'a) -> 'a list

val unfold : 'b -> ('b -> ('a * 'b) option) -> 'a list

val unfold_exn : (unit -> 'a) -> 'a list * exn

val unfold_exc : (unit -> 'a) -> 'a list * exn

val equal : ('a -> 'a -> bool) -> 'a list -> 'a list -> bool

val iter : ('a -> unit) -> 'a list -> unit

val iteri : (int -> 'a -> unit) -> 'a list -> unit

val map : ('a -> 'b) -> 'a list -> 'b list

val rev_map : ('a -> 'b) -> 'a list -> 'b list

val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list

val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a

val fold : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a

val fold_lefti : ('a -> int -> 'b -> 'a) -> 'a -> 'b list -> 'a

val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b

val fold_righti : (int -> 'b -> 'a -> 'a) -> 'b list -> 'a -> 'a

val reduce : ('a -> 'a -> 'a) -> 'a list -> 'a

val fold_left_map : ('a -> 'b -> 'a * 'c) -> 'a -> 'b list -> 'a * 'c list

val max : ?cmp:('a -> 'a -> int) -> 'a list -> 'a

val min : ?cmp:('a -> 'a -> int) -> 'a list -> 'a

val sum : int list -> int

val fsum : float list -> float

val favg : float list -> float

val kahan_sum : float list -> float

val min_max : ?cmp:('a -> 'a -> int) -> 'a list -> 'a * 'a

val to_seq : 'a list -> 'a Stdlib.Seq.t

val of_seq : 'a Stdlib.Seq.t -> 'a list

val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit

val iter2i : (int -> 'a -> 'b -> unit) -> 'a list -> 'b list -> unit

val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list

val map2i : (int -> 'a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list

val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list

val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a

val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c

val mem : 'a -> 'a list -> bool

val mem_cmp : ('a -> 'a -> int) -> 'a -> 'a list -> bool

val memq : 'a -> 'a list -> bool

val for_all : ('a -> bool) -> 'a list -> bool

val exists : ('a -> bool) -> 'a list -> bool

val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool

val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool

val subset : ('a -> 'b -> int) -> 'a list -> 'b list -> bool

val find : ('a -> bool) -> 'a list -> 'a

val find_opt : ('a -> bool) -> 'a list -> 'a option

val find_map_opt : ('a -> 'b option) -> 'a list -> 'b option

val find_exn : ('a -> bool) -> exn -> 'a list -> 'a

val findi : (int -> 'a -> bool) -> 'a list -> int * 'a

val find_map : ('a -> 'b option) -> 'a list -> 'b

val concat_map : ('a -> 'b list) -> 'a list -> 'b list

val rfind : ('a -> bool) -> 'a list -> 'a

val filter : ('a -> bool) -> 'a list -> 'a list

val count_matching : ('a -> bool) -> 'a list -> int

val filteri : (int -> 'a -> bool) -> 'a list -> 'a list

val filter_map : ('a -> 'b option) -> 'a list -> 'b list

val filteri_map : (int -> 'a -> 'b option) -> 'a list -> 'b list

val find_all : ('a -> bool) -> 'a list -> 'a list

val partition : ('a -> bool) -> 'a list -> 'a list * 'a list

val partition_map : 
  ('a -> ('b, 'c) BatEither.t) ->
  'a list ->
  'b list * 'c list

val index_of : 'a -> 'a list -> int option

val index_ofq : 'a -> 'a list -> int option

val rindex_of : 'a -> 'a list -> int option

val rindex_ofq : 'a -> 'a list -> int option

val unique : ?eq:('a -> 'a -> bool) -> 'a list -> 'a list

val unique_cmp : ?cmp:('a -> 'a -> int) -> 'a list -> 'a list

val unique_hash : 
  ?hash:('a -> int) ->
  ?eq:('a -> 'a -> bool) ->
  'a list ->
  'a list

val assoc : 'a -> ('a * 'b) list -> 'b

val assoc_opt : 'a -> ('a * 'b) list -> 'b option

val assoc_inv : 'b -> ('a * 'b) list -> 'a

val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list

val mem_assoc : 'a -> ('a * 'b) list -> bool

val assq : 'a -> ('a * 'b) list -> 'b

val assq_opt : 'a -> ('a * 'b) list -> 'b option

val assq_inv : 'b -> ('a * 'b) list -> 'a

val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list

val mem_assq : 'a -> ('a * 'b) list -> bool

val modify : 'a -> ('b -> 'b) -> ('a * 'b) list -> ('a * 'b) list

val modify_def : 'b -> 'a -> ('b -> 'b) -> ('a * 'b) list -> ('a * 'b) list

val modify_opt : 
  'a ->
  ('b option -> 'b option) ->
  ('a * 'b) list ->
  ('a * 'b) list

val modify_at : int -> ('a -> 'a) -> 'a list -> 'a list

val modify_opt_at : int -> ('a -> 'a option) -> 'a list -> 'a list

val split_at : int -> 'a list -> 'a list * 'a list

val split_nth : int -> 'a list -> 'a list * 'a list

val remove : 'a list -> 'a -> 'a list

val remove_if : ('a -> bool) -> 'a list -> 'a list

val remove_at : int -> 'a list -> 'a list

val remove_all : 'a list -> 'a -> 'a list

val take : int -> 'a list -> 'a list

val ntake : int -> 'a list -> 'a list list

val drop : int -> 'a list -> 'a list

val takedrop : int -> 'a list -> 'a list * 'a list

val take_while : ('a -> bool) -> 'a list -> 'a list

val drop_while : ('a -> bool) -> 'a list -> 'a list

val span : ('a -> bool) -> 'a list -> 'a list * 'a list

val fold_while : 
  ('acc -> 'a -> bool) ->
  ('acc -> 'a -> 'acc) ->
  'acc ->
  'a list ->
  'acc * 'a list

val nsplit : ('a -> bool) -> 'a list -> 'a list list

val group_consecutive : ('a -> 'a -> bool) -> 'a list -> 'a list list

val interleave : ?first:'a -> ?last:'a -> 'a -> 'a list -> 'a list

val enum : 'a list -> 'a BatEnum.t

val of_enum : 'a BatEnum.t -> 'a list

val backwards : 'a list -> 'a BatEnum.t

val of_backwards : 'a BatEnum.t -> 'a list

val split : ('a * 'b) list -> 'a list * 'b list

val combine : 'a list -> 'b list -> ('a * 'b) list

val sort : ('a -> 'a -> int) -> 'a list -> 'a list

val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list

val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list

val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list

val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list

val sort_unique : ('a -> 'a -> int) -> 'a list -> 'a list

val group : ('a -> 'a -> int) -> 'a list -> 'a list list

val cartesian_product : 'a list -> 'b list -> ('a * 'b) list

val n_cartesian_product : 'a list list -> 'a list list

val transpose : 'a list list -> 'a list list

val print : 
  ?first:string ->
  ?last:string ->
  ?sep:string ->
  ('a BatInnerIO.output -> 'b -> unit) ->
  'a BatInnerIO.output ->
  'b list ->
  unit

val eq : 'a BatOrd.eq -> 'a list BatOrd.eq

val ord : 'a BatOrd.ord -> 'a list BatOrd.ord

val compare : 'a BatOrd.comp -> 'a list BatOrd.comp

module Eq = BatList.Eq

module Ord = BatList.Ord

module Comp = BatList.Comp

val nth : 'a list -> int -> 'a

val nth_opt : 'a list -> int -> 'a option

val takewhile : ('a -> bool) -> 'a list -> 'a list

val dropwhile : ('a -> bool) -> 'a list -> 'a list

module Exceptionless = BatList.Exceptionless

module Infix = BatList.Infix

module Labels = BatList.Labels

val (@) : 'a list -> 'a list -> 'a list

module Ht = BatHashtbl

val avg : int list -> float

val naverage : int list list -> float list

val nfaverage : float list list -> float list

val singleton : 'a -> 'a t

val medianf : float list -> float

val median : int list -> float

val nmedian : int list list -> float list

exception Empty

val hd_tl : 'a t -> 'a * 'a list

val nfmedian : float list list -> float list

module Internal : sig ... end

val robust_nfmedian : float list list -> float list

val robust_nmedian : int list list -> float list

val variance : float list -> float

val sigma : float list -> float

val stddev : float list -> float

val mad : float list -> float * float

val to_string : ('a -> string) -> 'a list -> string

val of_string : (string -> 'a) -> string -> 'a list

val real_shuffle : 'a list -> 'a list

val pad : 'a list -> int -> 'a -> 'a list