package grenier

You can search for identifiers within the package.

in-package search v0.2.0

package grenier

grenier.baltree
- Bt1
- Bt2
- Mbt
  - MEASURE
  - Make
    
    M
grenier.binpacking
- Maxrects
grenier.doubledouble
- Doubledouble
  - Infix
grenier.hll
- Hll
- Hll_consts
grenier.jmphash
- Jmphash
grenier.orderme
grenier.pcg
- Pcg
grenier.physh
- Physh
  - Map
  - Set
grenier.trope
- Trope
grenier.valmari
- Finite
  - Element
  - Map
    
    Domain
  - Map_of_array
    
    A
    
    Domain
  - Set
    
    X
- Partition
- Valmari
  - DFA
    
    Final
    
    Domain
    
    Label
    
    States
    
    Transitions
  - Minimize
    
    DFA
    
    Final
    
    Domain
    
    Label
    
    States
    
    Transitions
    
    Final
    
    Domain
    
    States
    
    Transitions

Legend:
Library
Module
Module type
Parameter
Class
Class type

type 'bin t

val empty : 'bin t

val add_bin : 'bin -> int -> int -> 'bin t -> 'bin t

make ~width ~height return a packer ready to place stuff in a width * height area

type 'tag box = {

tag : 'tag;
width : int;
height : int;
allow_rotation : bool;
(*
can the box be rotated to optimize packing
*)

}

Input to packing is a box

val box : ?allow_rotation:bool -> 'tag -> int -> int -> 'tag box

type ('bin, 'tag) rect = {

x : int;
y : int;
w : int;
h : int;
rotated : bool;
(*
True iff the input box was rotated. If true, w = box.height && h = box.width Otherwise, w = box.width && h = box.height
*)
bin : 'bin;
box : 'tag box;

}

Output of packing is an optional rectangle

type heuristic = [

| `Short_side_fit
| `Long_side_fit
| `Area_fit
| `Bottom_left

]

val insert : 
  'bin t ->
  ?heuristic:heuristic ->
  'tag box ->
  'bin t * ('bin, 'tag) rect option

Online insertion of one item. Efficient but the packing is not very good.

Worst-case: O(n^3) (n is total number of items inserted).

val insert_batch : 
  'bin t ->
  ?heuristic:heuristic ->
  'tag box list ->
  'bin t * ('bin, 'tag) rect option list

Online insertion of a batch of items. Runtime is roughly the cost of inserting each item independently, but order of insertion is chosen to give a better packing.

Worst-case: O(n^4) (n is total number of items inserted).

val insert_global : 
  'bin t ->
  ?heuristic:heuristic ->
  'tag box list ->
  'bin t * ('bin, 'tag) rect option list

Offline insertion. Better packing but way too slow for real-time usage.

Worst-case: O(n^5) (n is total number of items inserted).