knights_tour 0.0.2 · OCaml Package

include sig ... end

type elt = Knights_tour.Point.t

type t = Stdlib__Set.Make(Knights_tour.Point).t

val empty : t

val add : elt -> t -> t

val singleton : elt -> t

val remove : elt -> t -> t

val union : t -> t -> t

val inter : t -> t -> t

val disjoint : t -> t -> bool

val diff : t -> t -> t

val cardinal : t -> int

val elements : t -> elt list

val min_elt : t -> elt

val min_elt_opt : t -> elt option

val max_elt : t -> elt

val max_elt_opt : t -> elt option

val choose : t -> elt

val choose_opt : t -> elt option

val find : elt -> t -> elt

val find_opt : elt -> t -> elt option

val find_first : (elt -> bool) -> t -> elt

val find_first_opt : (elt -> bool) -> t -> elt option

val find_last : (elt -> bool) -> t -> elt

val find_last_opt : (elt -> bool) -> t -> elt option

val iter : (elt -> unit) -> t -> unit

val fold : (elt -> 'acc -> 'acc) -> t -> 'acc -> 'acc

val map : (elt -> elt) -> t -> t

val filter : (elt -> bool) -> t -> t

val filter_map : (elt -> elt option) -> t -> t

val partition : (elt -> bool) -> t -> t * t

val split : elt -> t -> t * bool * t

val is_empty : t -> bool

val mem : elt -> t -> bool

val equal : t -> t -> bool

val compare : t -> t -> int

val subset : t -> t -> bool

val for_all : (elt -> bool) -> t -> bool

val exists : (elt -> bool) -> t -> bool

val to_list : t -> elt list

val of_list : elt list -> t

val to_seq_from : elt -> t -> elt Stdlib.Seq.t

val to_seq : t -> elt Stdlib.Seq.t

val to_rev_seq : t -> elt Stdlib.Seq.t

val add_seq : elt Stdlib.Seq.t -> t -> t

val of_seq : elt Stdlib.Seq.t -> t

val is_coherent : t -> bool

Checks whether a set of points is 'coherent'. What this means is that every points in the set can be reached from every other point in the set via its neighbours. If we consider a pointset to represent a polyomino, then it means the pointset represents a single puzzle piece (rather two or more disconnected 'islands' of points).

val min_x : t -> int

Find the smallest x coordinate in a pointset.

val max_x : t -> int

Find the largest x coordinate in a pointset.

val min_y : t -> int

Find the smallest y coordinate in a pointset.

val max_y : t -> int

Find the largest y coordinate in a pointset.

val of_string : string -> t

Takes a 'string image' of a pointset and parses it. A string image is just a multiline string where each character indicates whether or not the square/point at the corresponding location is part of the set.

Leading and trailing whitespace on each line are ignored. The remaining characters are interpreted as follows:

. means the corresponding square is b not in the set
any other character means that it is.

val to_string : t -> string

val adjacent : t -> t

Gets the set of adjacent points. A point is adjacent if it satisfies both:

it is a 'neighbour of any one of the point in the input; and
it is not a point in the input itself

val normalize_translation : t -> t

Translates the pointset so that all points x and y coordinates are greater or equal to 0; and have the smallest possible values given these conditions (i.e there is at least one point with x = 0, and one point (possibly a different one) with y = 0))

val variants : t -> t list

Gets all 'variants' of a given PointSet. A variant is similar shape obtained by applying rotation and mirroring transformations; and then applying normalize_translation.

val normalize : t -> t

Gets a canonical representation of a pointset that can be used to represent all variants.

val translate : Knights_tour.Point.t -> t -> t

Move all points an equal distance in both x and y coordinates

package knights_tour