☰
container
container
Constructors
abstract type for 'Linked_List'
a type for mutable singly linked lists
On call to `Mutable_Linked_List LM T data` creates a minimal list consisting
of only one single element. To create larger rings, you can either call
`append` to add single cells, or `concat` to concatenate two lists.
ps_set -- a partially sorted set based on ps_map
ps_set is a persistent set of ordered values. This set is generally
well-behaved with respect to cumulative and average performance.
WARNING: Due to the high worst-case time for addition, this structure should
not be used in situations when adding a single element repeatedly to the same
instance of ps_set is performance critical. If the resulting set's size n is a
power of 2, this will trigger the worst-case addition time resulting in
O(m*n log² n) for adding an element m times.
Set -- an abstract set of values
sorted_array -- sorted one-dimensional immutable array
This takes an unsorted array and a compare function as an arguments and
returns a sorted one.
Non-mutating heap sort is used internally. This gives guaranteed performance in
O(n log n) comparisons and assignments for an array of size n.
This is a little wasteful on allocated memory, which is also O(n log n) since
partially sorted arrays are thrown away. This might be improved to use an
in-place heap sort to bring allocated memory down to O(n).Functions
set_of_hashable -- routine to initialize a set from a Sequence of hashable elements
This feature creates an instance of a Set.
Constructors
abstract type for 'Linked_List'
a type for mutable singly linked lists
On call to `Mutable_Linked_List LM T data` creates a minimal list consisting
of only one single element. To create larger rings, you can either call
`append` to add single cells, or `concat` to concatenate two lists.
ps_set -- a partially sorted set based on ps_map
ps_set is a persistent set of ordered values. This set is generally
well-behaved with respect to cumulative and average performance.
WARNING: Due to the high worst-case time for addition, this structure should
not be used in situations when adding a single element repeatedly to the same
instance of ps_set is performance critical. If the resulting set's size n is a
power of 2, this will trigger the worst-case addition time resulting in
O(m*n log² n) for adding an element m times.
Set -- an abstract set of values
sorted_array -- sorted one-dimensional immutable array
This takes an unsorted array and a compare function as an arguments and
returns a sorted one.
Non-mutating heap sort is used internally. This gives guaranteed performance in
O(n log n) comparisons and assignments for an array of size n.
This is a little wasteful on allocated memory, which is also O(n log n) since
partially sorted arrays are thrown away. This might be improved to use an
in-place heap sort to bring allocated memory down to O(n).Functions
set_of_hashable -- routine to initialize a set from a Sequence of hashable elements
This feature creates an instance of a Set.
abstract type for 'Linked_List'
a type for mutable singly linked lists
On call to `Mutable_Linked_List LM T data` creates a minimal list consisting
of only one single element. To create larger rings, you can either call
`append` to add single cells, or `concat` to concatenate two lists.
ps_set -- a partially sorted set based on ps_map
ps_set is a persistent set of ordered values. This set is generally
well-behaved with respect to cumulative and average performance.
WARNING: Due to the high worst-case time for addition, this structure should
not be used in situations when adding a single element repeatedly to the same
instance of ps_set is performance critical. If the resulting set's size n is a
power of 2, this will trigger the worst-case addition time resulting in
O(m*n log² n) for adding an element m times.
Set -- an abstract set of values
sorted_array -- sorted one-dimensional immutable array
This takes an unsorted array and a compare function as an arguments and
returns a sorted one.
Non-mutating heap sort is used internally. This gives guaranteed performance in
O(n log n) comparisons and assignments for an array of size n.
This is a little wasteful on allocated memory, which is also O(n log n) since
partially sorted arrays are thrown away. This might be improved to use an
in-place heap sort to bring allocated memory down to O(n).Functions
set_of_hashable -- routine to initialize a set from a Sequence of hashable elements
This feature creates an instance of a Set.
a type for mutable singly linked lists
On call to `Mutable_Linked_List LM T data` creates a minimal list consisting
of only one single element. To create larger rings, you can either call
`append` to add single cells, or `concat` to concatenate two lists.
On call to `Mutable_Linked_List LM T data` creates a minimal list consisting
of only one single element. To create larger rings, you can either call
`append` to add single cells, or `concat` to concatenate two lists.
ps_set -- a partially sorted set based on ps_map
ps_set is a persistent set of ordered values. This set is generally
well-behaved with respect to cumulative and average performance.
WARNING: Due to the high worst-case time for addition, this structure should
not be used in situations when adding a single element repeatedly to the same
instance of ps_set is performance critical. If the resulting set's size n is a
power of 2, this will trigger the worst-case addition time resulting in
O(m*n log² n) for adding an element m times.
Set -- an abstract set of values
sorted_array -- sorted one-dimensional immutable array
This takes an unsorted array and a compare function as an arguments and
returns a sorted one.
Non-mutating heap sort is used internally. This gives guaranteed performance in
O(n log n) comparisons and assignments for an array of size n.
This is a little wasteful on allocated memory, which is also O(n log n) since
partially sorted arrays are thrown away. This might be improved to use an
in-place heap sort to bring allocated memory down to O(n).Functions
set_of_hashable -- routine to initialize a set from a Sequence of hashable elements
This feature creates an instance of a Set.
ps_set -- a partially sorted set based on ps_map
ps_set is a persistent set of ordered values. This set is generally
well-behaved with respect to cumulative and average performance.
WARNING: Due to the high worst-case time for addition, this structure should
not be used in situations when adding a single element repeatedly to the same
instance of ps_set is performance critical. If the resulting set's size n is a
power of 2, this will trigger the worst-case addition time resulting in
O(m*n log² n) for adding an element m times.
ps_set is a persistent set of ordered values. This set is generally
well-behaved with respect to cumulative and average performance.
WARNING: Due to the high worst-case time for addition, this structure should
not be used in situations when adding a single element repeatedly to the same
instance of ps_set is performance critical. If the resulting set's size n is a
power of 2, this will trigger the worst-case addition time resulting in
O(m*n log² n) for adding an element m times.
Set -- an abstract set of values
sorted_array -- sorted one-dimensional immutable array
This takes an unsorted array and a compare function as an arguments and
returns a sorted one.
Non-mutating heap sort is used internally. This gives guaranteed performance in
O(n log n) comparisons and assignments for an array of size n.
This is a little wasteful on allocated memory, which is also O(n log n) since
partially sorted arrays are thrown away. This might be improved to use an
in-place heap sort to bring allocated memory down to O(n).Functions
set_of_hashable -- routine to initialize a set from a Sequence of hashable elements
This feature creates an instance of a Set.
Set -- an abstract set of values
sorted_array -- sorted one-dimensional immutable array
This takes an unsorted array and a compare function as an arguments and
returns a sorted one.
Non-mutating heap sort is used internally. This gives guaranteed performance in
O(n log n) comparisons and assignments for an array of size n.
This is a little wasteful on allocated memory, which is also O(n log n) since
partially sorted arrays are thrown away. This might be improved to use an
in-place heap sort to bring allocated memory down to O(n).Functions
set_of_hashable -- routine to initialize a set from a Sequence of hashable elements
This feature creates an instance of a Set.
sorted_array -- sorted one-dimensional immutable array
This takes an unsorted array and a compare function as an arguments and
returns a sorted one.
Non-mutating heap sort is used internally. This gives guaranteed performance in
O(n log n) comparisons and assignments for an array of size n.
This is a little wasteful on allocated memory, which is also O(n log n) since
partially sorted arrays are thrown away. This might be improved to use an
in-place heap sort to bring allocated memory down to O(n).
This takes an unsorted array and a compare function as an arguments and
returns a sorted one.
Non-mutating heap sort is used internally. This gives guaranteed performance in
O(n log n) comparisons and assignments for an array of size n.
This is a little wasteful on allocated memory, which is also O(n log n) since
partially sorted arrays are thrown away. This might be improved to use an
in-place heap sort to bring allocated memory down to O(n).
Functions
set_of_hashable -- routine to initialize a set from a Sequence of hashable elements
This feature creates an instance of a Set.
set_of_hashable -- routine to initialize a set from a Sequence of hashable elements
This feature creates an instance of a Set.
This feature creates an instance of a Set.
data structure to store and retrieve values