9.3. Heaps and Priority Queues (WORK IN PROGRESS)¶
9.3.1. Heaps and Priority Queues¶
There are many situations, both in real life and in computing applications, where we wish to choose the next “most important” from a collection of people, tasks, or objects. For example, doctors in a hospital emergency room often choose to see next the “most critical” patient rather than the one who arrived first. When scheduling programs for execution in a multitasking operating system, at any given moment there might be several programs (usually called jobs) ready to run. The next job selected is the one with the highest priority. Priority is indicated by a particular value associated with the job (and might change while the job remains in the wait list).
When a collection of objects is organized by importance or priority, we call this a priority queue. A normal queue data structure will not implement a priority queue efficiently because search for the element with highest priority will take \(\Theta(n)\) time. A list, whether sorted or not, will also require \(\Theta(n)\) time for either insertion or removal. A BST that organizes records by priority could be used, with the total of \(n\) inserts and \(n\) remove operations requiring \(\Theta(n \log n)\) time in the average case. However, there is always the possibility that the BST will become unbalanced, leading to bad performance. Instead, we would like to find a data structure that is guaranteed to have good performance for this special application.
This section presents the heap 1 data structure. A heap is defined by two properties.  Second, the values stored in a heap are partially ordered. This means that there is a relationship between the value stored at any node and the values of its children. There are two variants of the heap, depending on the definition of this relationship.
- 1
Note that the term “heap” is also sometimes used to refer to free store.
A max heap has the property that every node stores a value that is greater than or equal to the value of either of its children. Because the root has a value greater than or equal to its children, which in turn have values greater than or equal to their children, the root stores the maximum of all values in the tree.
A min heap has the property that every node stores a value that is less than or equal to that of its children. Because the root has a value less than or equal to its children, which in turn have values less than or equal to their children, the root stores the minimum of all values in the tree.
Note that there is no necessary relationship between the value of a node and that of its sibling in either the min heap or the max heap. For example, it is possible that the values for all nodes in the left subtree of the root are greater than the values for every node of the right subtree. We can contrast BSTs and heaps by the strength of their ordering relationships. A BST defines a total order on its nodes in that, given the positions for any two nodes in the tree, the one to the “left” (equivalently, the one appearing earlier in an inorder traversal) has a smaller key value than the one to the “right”. In contrast, a heap implements a partial order. Given their positions, we can determine the relative order for the key values of two nodes in the heap only if one is a descendant of the other.
Min heaps and max heaps both have their uses. For example, the Heapsort uses the max heap, while the Replacement Selection algorithm used for external sorting uses a min heap. The examples in the rest of this section will use a max heap.
Be sure not to confuse the logical representation of a heap with its physical implementation by means of the array-based complete binary tree. The two are not synonymous because the logical view of the heap is actually a tree structure, while the typical physical implementation uses an array.
Here is an implementation for max heaps. The class uses records that support the Comparable interface to provide flexibility.
// Max-heap implementation
class MaxHeap {
private Comparable[] Heap; // Pointer to the heap array
private int size; // Maximum size of the heap
private int n; // Number of things now in heap
// Constructor supporting preloading of heap contents
MaxHeap(Comparable[] h, int num, int max)
{ Heap = h; n = num; size = max; buildheap(); }
// Return current size of the heap
int heapsize() { return n; }
// Return true if pos a leaf position, false otherwise
boolean isLeaf(int pos)
{ return (pos >= n/2) && (pos < n); }
// Return position for left child of pos
int leftchild(int pos) {
if (pos >= n/2) { return -1; }
return 2*pos + 1;
}
// Return position for right child of pos
int rightchild(int pos) {
if (pos >= (n-1)/2) { return -1; }
return 2*pos + 2;
}
// Return position for parent
int parent(int pos) {
if (pos <= 0) { return -1; }
return (pos-1)/2;
}
// Insert val into heap
void insert(int key) {
if (n >= size) {
System.out.println("Heap is full");
return;
}
int curr = n++;
Heap[curr] = key; // Start at end of heap
// Now sift up until curr's parent's key > curr's key
while ((curr != 0) && (Heap[curr].compareTo(Heap[parent(curr)]) > 0)) {
Swap.swap(Heap, curr, parent(curr));
curr = parent(curr);
}
}
// Heapify contents of Heap
void buildheap()
{ for (int i=n/2-1; i>=0; i--) { siftdown(i); } }
// Put element in its correct place
void siftdown(int pos) {
if ((pos < 0) || (pos >= n)) { return; } // Illegal position
while (!isLeaf(pos)) {
int j = leftchild(pos);
if ((j<(n-1)) && (Heap[j].compareTo(Heap[j+1]) < 0)) {
j++; // j is now index of child with greater value
}
if (Heap[pos].compareTo(Heap[j]) >= 0) { return; }
Swap.swap(Heap, pos, j);
pos = j; // Move down
}
}
// Remove and return maximum value
Comparable removemax() {
if (n == 0) { return -1; } // Removing from empty heap
Swap.swap(Heap, 0, --n); // Swap maximum with last value
siftdown(0); // Put new heap root val in correct place
return Heap[n];
}
// Remove and return element at specified position
Comparable remove(int pos) {
if ((pos < 0) || (pos >= n)) { return -1; } // Illegal heap position
if (pos == (n-1)) { n--; } // Last element, no work to be done
else {
Swap.swap(Heap, pos, --n); // Swap with last value
update(pos);
}
return Heap[n];
}
// Modify the value at the given position
void modify(int pos, Comparable newVal) {
if ((pos < 0) || (pos >= n)) { return; } // Illegal heap position
Heap[pos] = newVal;
update(pos);
}
// The value at pos has been changed, restore the heap property
void update(int pos) {
// If it is a big value, push it up
while ((pos > 0) && (Heap[pos].compareTo(Heap[parent(pos)]) > 0)) {
Swap.swap(Heap, pos, parent(pos));
pos = parent(pos);
}
siftdown(pos); // If it is little, push down
}
}
# Max-heap implementation
class MaxHeap:
def __init__(self, h, num, max):
self.heap = h # Pointer to the heap array
self.n = num # Number of things now in heap
self.size = max # Maximum size of the heap
self.buildheap()
def heapsize(self):
return self.n
def isLeaf(self, pos):
return self.n//2 <= pos < self.n
def leftchild(self, pos):
if pos >= n//2:
return -1
else:
return 2*pos + 1
def rightchild(self, pos):
if pos >= (self.n-1)//2:
return -1
else:
return 2*pos + 2
def parent(self, pos):
if pos <= 0:
return -1
else:
return (pos-1)//2
def insert(self, key):
if self.n >= size:
raise IndexError("Heap is full")
curr = self.n
self.n += 1
self.heap[curr] = key # Start at end of heap
# Now sift up until curr's parent's key > curr's key
while curr != 0 and self.heap[curr] > self.heap[self.parent(curr)]:
swap(self.heap, curr, self.parent(curr))
self.curr = self.parent(curr)
def buildheap(self):
for i in range(self.n//2-1, -1, -1):
self.siftdown(i)
def siftdown(self, pos):
if pos < 0 or pos >= n:
raise IndexError("Illegal position")
while not self.isLeaf(pos):
j = self.leftchild(pos)
if j<(n-1) and self.heap[j] < self.heap[j+1]:
j += 1 # j is now index of child with greater value
if self.heap[pos] >= self.heap[j]:
return
swap(self.heap, pos, j)
pos = j # Move down
def removemax(self):
if self.n == 0:
raise IndexError("Removing from empty heap")
self.n -= 1
swap(self.heap, 0, self.n) # Swap maximum with last value
self.siftdown(0) # Put new heap root val in correct place
return self.heap[n]
def remove(self, pos):
if pos < 0 or pos >= self.n:
raise IndexError("Illegal heap position")
self.n -= 1
if pos != self.n:
swap(self.heap, pos, self.n) # Swap with last value
self.update(pos)
return self.heap[n]
def modify(self, pos, newVal):
if pos < 0 or pos >= self.n:
raise IndexError("Illegal heap position")
self.heap[pos] = newVal
self.update(pos)
def update(self, pos):
# If it is a big value, push it up
while pos > 0 and self.heap[pos] > self.heap[self.parent(pos)]:
swap(self.heap, pos, self.parent(pos))
pos = self.parent(pos)
self.siftdown(pos) # If it is little, push down
This class definition makes two concessions to the fact that an array-based implementation is used. First, heap nodes are indicated by their logical position within the heap rather than by a pointer to the node. In practice, the logical heap position corresponds to the identically numbered physical position in the array. Second, the constructor takes as input a pointer to the array to be used. This approach provides the greatest flexibility for using the heap because all data values can be loaded into the array directly by the client. The advantage of this comes during the heap construction phase, as explained below. The constructor also takes an integer parameter indicating the initial size of the heap (based on the number of elements initially loaded into the array) and a second integer parameter indicating the maximum size allowed for the heap (the size of the array).
Method heapsize
returns the current size of the heap.
H.isLeaf(pos)
returns TRUE if position
pos
is a leaf in heap H
, and FALSE otherwise.
Members leftchild
, rightchild
,
and parent
return the position (actually, the array index)
for the left child, right child, and parent of the position passed,
respectively.
One way to build a heap is to insert the elements one at a time.
Method insert
will insert a new element \(V\) into
the heap.
You might expect the heap insertion process to be similar to the
insert function for a BST, starting at the root and working down
through the heap.
However, this approach is not likely to work because the heap must
maintain the shape of a complete binary tree.
Equivalently, if the heap takes up the first
\(n\) positions of its array prior to the call to
insert
,
it must take up the first \(n+1\) positions after.
To accomplish this, insert
first places \(V\) at
position \(n\) of the array.
Of course, \(V\) is unlikely to be in the correct position.
To move \(V\) to the right place, it is compared to its
parent’s value.
If the value of \(V\) is less than or equal to the value of its
parent, then it is in the correct place and the insert routine is
finished.
If the value of \(V\) is greater than that of its parent, then
the two elements swap positions.
From here, the process of comparing \(V\) to its (current)
parent continues until \(V\) reaches its correct position.
 In particular, a heap containing \(n\) nodes will have a height of \(\Theta(\log n)\). Intuitively, we can see that this must be true because each level that we add will slightly more than double the number of nodes in the tree (the \(i\) th level has \(2^i\) nodes, and the sum of the first \(i\) levels is \(2^{i+1}-1\)). Starting at 1, we can double only \(\log n\) times to reach a value of \(n\). To be precise, the height of a heap with \(n\) nodes is \(\lceil \log n + 1 \rceil\).
Each call to insert
takes \(\Theta(\log n)\) time in the
worst case, because the value being inserted can move at most the
distance from the bottom of the tree to the top of the tree.
Thus, to insert \(n\) values into the heap, if we insert them
one at a time, will take \(\Theta(n \log n)\) time in the
worst case.
9.3.2. Building a Heap¶
If all \(n\) values are available at the beginning of the building process, we can build the heap faster than just inserting the values into the heap one by one. Consider this example, with two possible ways to heapify an initial set of values in an array.
From this example, it is clear that the heap for any given set of numbers is not unique, and we see that some rearrangements of the input values require fewer exchanges than others to build the heap. So, how do we pick the best rearrangement?
One good algorithm stems from induction. Suppose that the left and right subtrees of the root are already heaps, and \(R\) is the name of the element at the root. This situation is illustrated by this figure:
In this case there are two possibilities.
\(R\) has a value greater than or equal to its two children. In this case, construction is complete.
\(R\) has a value less than one or both of its children.
\(R\) should be exchanged with the child that has
greater value.
The result will be a heap, except that \(R\)
might still be less than one or both of its (new) children.
In this case, we simply continue the process of “pushing down”
\(R\) until it reaches a level where it is greater than its
children, or is a leaf node.
This process is implemented by the private method
siftdown
.
This approach assumes that the subtrees are already heaps, suggesting that a complete algorithm can be obtained by visiting the nodes in some order such that the children of a node are visited before the node itself. One simple way to do this is simply to work from the high index of the array to the low index. Actually, the build process need not visit the leaf nodes (they can never move down because they are already at the bottom), so the building algorithm can start in the middle of the array, with the first internal node.
Here is a visualization of the heap build process.
Method buildHeap
implements the building algorithm.
What is the cost of buildHeap
?
Clearly it is the sum of the costs for the calls to siftdown
.
Each siftdown
operation can cost at most the number of
levels it takes for the node being sifted to reach the bottom of the
tree.
In any complete tree, approximately half of the nodes are leaves
and so cannot be moved downward at all.
One quarter of the nodes are one level above the leaves, and so their
elements can move down at most one level.
At each step up the tree we get half the number of nodes as were at
the previous level, and an additional height of one.
The maximum sum of total distances that elements can go is
therefore
The summation on the right is known to have a closed-form solution of approximately 2, so this algorithm takes \(\Theta(n)\) time in the worst case. This is far better than building the heap one element at a time, which would cost \(\Theta(n \log n)\) in the worst case. It is also faster than the \(\Theta(n \log n)\) average-case time and \(\Theta(n^2)\) worst-case time required to build the BST.
9.3.3. Removing from the heap or updating an object’s priority¶
Because the heap is \(\log n\) levels deep, the cost of deleting the maximum element is \(\Theta(\log n)\) in the average and worst cases.
For some applications, objects might get their priority modified.
One solution in this case is to remove the object and reinsert it.
To do this, the application needs to know the position of the object
in the heap.
Another option is to change the priority value of the object, and then
update its position in the heap.
Note that a remove operation implicitly has to do this anyway, since
when the last element in the heap is swapped with the one being
removed, that value might be either too small or too big for its new
position.
So we use a utility method called update
in both the remove
and modify
methods to handle this process.
9.3.4. Priority Queues¶
The heap is a natural implementation for the priority queue discussed
at the beginning of this section.
Jobs can be added to the heap (using their priority value as the
ordering key) when needed.
Method removemax
can be called whenever a new job is to be
executed.
Some applications of priority queues require the ability to change the
priority of an object already stored in the queue.
This might require that the object’s position in the heap representation
be updated.
Unfortunately, a max heap is not efficient when searching for an
arbitrary value; it is only good for finding the maximum value.
However, if we already know the index for an object within the heap,
it is a simple matter to update its priority (including changing its
position to maintain the heap property) or remove it.
The remove
method takes as input the position of the
node to be removed from the heap.
A typical implementation for priority queues requiring updating of
priorities will need to use an auxiliary data structure that supports
efficient search for objects (such as a BST).
Records in the auxiliary data structure will store
the object’s heap index, so that the object’s priority can be updated.
Priority queues can be helpful for solving graph problems such as
single-source shortest paths
and
minimal-cost spanning tree.
For a story about Priority Queues and dragons, see Computational Fairy Tales: Stacks, Queues, Priority Queues, and the Prince's Complaint Line.


Calendar works fine on any device: desktop, tablet or mobile.
Many options to customize behavior. Use of sass variables to easily customize design.
Pure JavaScript to manage user interaction.
There are several ways to get started with Bulma-extensions. You can either:
Use npm to install and stay up to date in the future
Use the GitHub repository to get the latest development version
This method requires git installed on your computer.
The component comes with various files:
Depending on your need your can use either pre-compiled files from dist
directory or sources from src
directory.
The best way to start with calendar is to use a simple HTML5 date input:
You are only at 3 simple steps to work with bulmaCalendar.
The first step is to include the stylesheet into your project. You can use either the minified CSS version or the Sass source to integrate it into a more global project.
Second step is to include the JavaScript part of the component.
Now all that remains is to intiate the component to all elements you want to transform into a Calendar / DatePicker
| Name | Description | Type | Default value |
|---|---|---|---|
| Name | Description | Type | Default value |
type
|
Component type: date|time|datetime |
String
|
datetime
|
color
|
Picker dominant color |
String
|
primary
|
isRange
|
Range capability (start and end date/time selection |
Boolean
|
false
|
allowSameDayRange
|
Possibility to select same date as start and end date in range mode |
Boolean
|
true
|
lang
|
Display lang (from language supported by date-fns 2.x) |
String
|
navigator.language || "en-US"
|
dateFormat
|
Date format pattern |
String
|
MM/dd/yyyy
|
timeFormat
|
Time format pattern |
String
|
HH:mm
|
displayMode
|
Display mode: default|dialog|inline |
String
|
default
|
position
|
String
|
auto
|
|
showHeader
|
Show/Hide header block (with current selection) |
Boolean
|
true
|
headerPosition
|
Header block position: top|bottom |
Boolean
|
top
|
showFooter
|
Show/Hide footer block |
Boolean
|
true
|
showButtons
|
Show/Hide buttons |
Boolean
|
true
|
showTodayButton
|
Show/Hide Today Button |
Boolean
|
true
|
showClearButton
|
Show/Hide Clear Button |
Boolean
|
true
|
cancelLabel
|
Cancel button label |
String
|
Cancel
|
clearLabel
|
Clear button label |
String
|
Clear
|
todayLabel
|
Today button label |
String
|
Today
|
nowLabel
|
Now button label |
String
|
Now
|
validateLabel
|
Validate button label |
String
|
Validate
|
enableMonthSwitch
|
Enable/disable month switch |
Boolean
|
true
|
enableYearSwitch
|
Enable/disable year switch |
Boolean
|
true
|
startDate
|
Pre-selected start date |
Date | String
|
undefined
|
endDate
|
Pre-selected end date |
Date | String
|
undefined
|
minDate
|
Minimum date allowed |
Date | String
|
null
|
maxDate
|
Maximum date allowed |
Date | String
|
null
|
disabledDates
|
List of disabled dates |
Date[] | String[] | Function(this, day)
|
|
disabledWeekDays
|
List of disabled week days |
Number[] | String '1,2,3,...'
|
undefined
|
highlightedDates
|
List of highlighted dates |
Date[] | String[] | Function(this, day)
|
|
weekStart
|
Default weekstart day number (sunday by default) |
Integer
|
0
|
startTime
|
Pre-selected start time |
Date | String
|
undefined
|
endTime
|
Pre-selected end time |
Date | String
|
undefined
|
minuteSteps
|
Steps for minutes selector |
Integer
|
5
|
labelFrom
|
From label |
String
|
|
labelTo
|
To label |
String
|
|
closeOnOverlayClick
|
Close picker on overlay click (only for dialog display style) |
Boolean
|
true
|
closeOnSelect
|
Automatically close the datePicker when date selected (or range date selected) - not available for inline display style. If set to False then a validate button will be displayed into the footer section. |
Boolean
|
true
|
toggleOnInputClick
|
Automatically open datepicker when click into input element |
Boolean
|
true
|
onReady
|
Callback to trigger once picker initiated |
Function
|
|
onValidate
|
Callback for manual validation before save() |
Function
|
|
formats.header
|
Header format pattern month / year |
String
|
LLLL yyyy
|
formats.navigationMonth
|
Month format pattern for the navigation bar |
String
|
LLLL
|
formats.navigationYear
|
Year format pattern for the navigation bar |
String
|
yyyy
|
formats.selectMonth
|
Format pattern for the month selection |
String
|
LLL
|
formats.selectYear
|
Format pattern for the year selection |
String
|
yyyy
|
formats.weekday
|
Format pattern for the weekdays |
String
|
ccc
|
icons.previous
|
Previous button icon |
String
|
Svg content
|
icons.next
|
Next button icon |
String
|
Svg content
|
icons.time
|
Time icon |
String
|
Svg content
|
icons.date
|
Date icon |
String
|
Svg content
|
Calendar component provides some public methods to manually work with it.
| show() | ||
|---|---|---|
| Open date picker (not available with "inline" display style) | ||
| Parameters | ||
none
|
||
| Return values | ||
none
|
| hide() | ||
|---|---|---|
| Close date picker (not available with "inline" display style) | ||
| Parameters | ||
none
|
||
| Return values | ||
none
|
| isOpen() | ||
|---|---|---|
| Check if date picker is open or not | ||
| Parameters | ||
none
|
||
| Return values | ||
boolean
|
True if date picker is open else False |
| isRange() | ||
|---|---|---|
| Check if current instance is a range date picker | ||
| Parameters | ||
none
|
||
| Return values | ||
boolean
|
True if the instance is a range date picker |
| isValid() | ||
|---|---|---|
| Check if current datetime is valid | ||
| Parameters | ||
none
|
||
| Return values | ||
boolean
|
True if start and end datetime is valid |
| value() | ||
|---|---|---|
| Get the date picker value as formatted string if no parameter else set the passed value | ||
| Parameters | ||
value
|
String|null | Formatted date value if no parameter passed else null |
| Return values | ||
Object{startDate, endDate}
|
Date picker selected date (if not range calendar then endDate is undefined) |
| refresh() | ||
|---|---|---|
| Force calendar refresh | ||
| Parameters | ||
none
|
||
| Return values | ||
none
|
| save() | ||
|---|---|---|
| Force to set calendar data into UI inputs | ||
| Parameters | ||
none
|
||
| Return values | ||
none
|
| clear() | ||
|---|---|---|
| Clear date selection (startDate and endDate are set to undefined) | ||
| Parameters | ||
none
|
||
| Return values | ||
none
|
Calendar component provides some public Getters to manually access properties.
| Name | Description |
|---|---|
| Name | Description |
id
|
Get component instance ID |
lang
|
Get active lang |
date
|
Get selected date |
startDate
|
Get selected start date |
endDate
|
Get selected end date |
minDate
|
Get min possible date |
maxDate
|
Get max possible date |
dateFormat
|
Get date format pattern |
time
|
Get selected time |
startTime
|
Get selected start time |
endTime
|
Get selected end time |
timeFormat
|
Get time format pattern |
Calendar component provides some public Setters to manually set properties.
| Name | Description |
|---|---|
| Name | Description |
lang
|
Set component lang |
date
|
Set date |
startDate
|
Se start date |
endDate
|
Set end date |
minDate
|
Set min possible date |
maxDate
|
Set max possible date |
dateFormat
|
Set date format pattern |
time
|
Set time |
startTime
|
Set start time |
endTime
|
Set end time |
timeFormat
|
Set time format pattern |
Calendar component comes with Events Management API so you can easily react to its behavior.
| Name | Description | Values |
|---|---|---|
| Name | Description | Values |
ready
|
Triggered when calendar is intialized (DO NOT USE IT but pass callback into the onReady option) |
bulmaCalendar instance
|
show
|
Triggered when calendar is opened |
bulmaCalendar instance
|
hide
|
Triggered when calendar is closed |
bulmaCalendar instance
|
save
|
Triggered when a date/time is selected and validated (calendar is closed) |
bulmaCalendar instance
|
select
|
Triggered when a date/time is selected (for range = when both start and end dates/times have been selected) |
bulmaCalendar instance
|
select:start
|
Triggered when the start date is selected |
bulmaCalendar instance
|


Welcome to Knockoff
Knockoff is a Markdown parser with a twist. Most Markdown systems just convert Markdown source to HTML. Knockoff converts from Markdown source to an object model ... then, to an XHMTL fragment, generated easily with Scala's excellent XML integration. I've found it an easy way to manipulate Markdown content.
For example, I've built a literate programming environment by basically stringing together specially tagged code blocks of the markdown content. With the meta-data extension, you can pretty easily use markdown files as the "storage" format for something like a website.
Converting Markdown to HTML
The Discounter
is what grabs the "knockoff" of a markdown string. For simple usage,
you can use the DefaultDiscounter
object.
import com.tristanhunt.knockoff.DefaultDiscounter._
toXML( knockoff( markdownString ) )
See the Recipes page for more.
Recent Updates
0.6.1-8
Dec 6, 2009
- Changed the output from
GroupSeq
toBlockSeq
ofWholesaler
. - Created the
MetaData
extension, which allows for extra document-related info. - Added
Wholesaler
class tocom.tristanhunt.knockoff.extra
namespace, which is the container for Markdown extensions.
0.6.0-5
Nov 28, 2009
- Small alteration to the
CodeBlock
that doesn't force a newline at the end of every code block. I have no idea what I was thinking here.
0.6.0-4
Nov 28, 2009
- Set package name as
com.tristanhunt.knockoff
. [Let's try being standard!] - Fixed whitespace problem that caused crash, and trying to report failures better.
- Added
Nothin But Code
test to suite, which triggered a crash during parsing. - Upgraded project to literable
0.5.0-3
, which involves movingsrc/main/markdown
toliterate
.


Annotates data from liquid chromatography coupled to mass spectrometry (LC/MS) metabolomics experiments. Based on a network algorithm (O.Senan, A. Aguilar- Mogas, M. Navarro, O. Yanes, R.Guimerà and M. Sales-Pardo, Metabolomics Conference (2016), Dublin), 'CliqueMS' builds a weighted similarity network where nodes are features and edges are weighted according to the similarity of this features. Then it searches for the most plausible division of the similarity network into cliques (fully connected components). Finally it annotates metabolites within each clique, obtaining for each annotated metabolite the neutral mass and their features, corresponding to isotopes, ionization adducts and fragmentation adducts of that metabolite.
| Version: | 0.2.3 |
| Depends: | R (≥ 3.4.0) |
| Imports: | Rcpp (≥ 0.12.15), xcms, igraph, qlcMatrix, Matrix, CAMERA, methods |
| LinkingTo: | Rcpp, BH, RcppArmadillo |
| Suggests: | knitr, rmarkdown, testthat |
| Published: | 2018-11-15 |
| Author: | Oriol Senan Campos [aut, cre], Antoni Aguilar-Mogas [aut], Jordi Capellades [aut], Miriam Navarro [aut], Oscar Yanes [aut], Roger Guimerà [aut], Marta Sales-Pardo [aut] |
| Maintainer: | Oriol Senan Campos <oriol.senan at urv.cat> |
| BugReports: | https://github.com/osenan/cliqueMS/issues |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| URL: | https://github.com/osenan/cliqueMS |
| NeedsCompilation: | yes |
| SystemRequirements: | C++11 |
| Citation: | cliqueMS citation info |
| Materials: | README NEWS |
| CRAN checks: | cliqueMS results |
| Reference manual: | cliqueMS.pdf |
| Vignettes: |
Annotating LC/MS data with cliqueMS |
| Package source: | cliqueMS_0.2.3.tar.gz |
| Windows binaries: | r-devel: cliqueMS_0.2.3.zip, r-release: cliqueMS_0.2.3.zip, r-oldrel: cliqueMS_0.2.3.zip |
| OS X binaries: | r-release: not available, r-oldrel: not available |
| Old sources: | cliqueMS archive |
Please use the canonical form https://CRAN.R-project.org/package=cliqueMS to link to this page.


--- layout: post status: publish published: true title: Clip from 4/07/12 Live Broadcast author: display_name: Corey Fineran login: Corey email<EMAIL_ADDRESS>url: '' author_login: Corey author_email<EMAIL_ADDRESS>wordpress_id: 7044 wordpress_url: http://ivyenvy.com/?p=7044 date: '2012-04-09 17:58:38 +0000' date_gmt: '2012-04-09 22:58:38 +0000' categories: - Podcast - Live Broadcast Clip tags: - Ivy Envy - Ivy Envy Podcast - iTunes - Youtube - Ivy Envy Live Broadcast - Stitcher - Pocketcasts - Over/Under Predictions - '2012' comments: [] ---
After months of preparation, we did our first weekly live broadcast of the podcast recording on Saturday. These broadcasts will be available to view on our website every Saturday morning at 10am Central. Just click on the "Live Broadcast" graphic. The broadcast is also available via the Ustream iOS and Android phone app.
I will probably pull a segment from each broadcast and put it on YouTube as a sample. So if you missed this week's broadcast, you can listen to the audio podcast version here on IvyEnvy.com, or in iTunes, Stitcher, Pocketcasts, TuneIn and many other podcasting apps.
Here's the segment from this week's broadcast. We are going over some of our over/under predictions for the 2012 season.
http://youtu.be/ArpKZzJ7V_k


Is ther any Module where level 40 can be reached? I haven't found any, most stop around levlel 30.
On or offline?
Besides the ones where you can tests builds?
I suppose you already looked but try http://nwvault.ign.com/
To me it's seems almost impossible to make a balanced module for single player at very high epic levels.
The Endless Nights series of modules lets you reach lvl 40. I've only played the latest one, Endless Nights IV. The module is based around random quests and encounters.