| Modifier and Type | Method and Description |
|---|---|
WellDouble |
PlateReaderDouble.nextJSONWell()
Parses the next well in the well list to a well object and returns the
result.
|
WellDouble |
PlateReaderDouble.nextXMLWell()
Parses the next well in the well list to a well object and returns the
result.
|
WellDouble |
PlateReaderDouble.previousJSONWell()
Parses the previous well in the well list to a well object and returns the
result.
|
WellDouble |
PlateReaderDouble.previousXMLWell()
Parses the previous well in the well list to a well object and returns the
result.
|
WellDouble |
WellXMLDouble.toWellObject()
Returns a WellDouble object.
|
WellDouble |
ResultWellXMLDouble.toWellObject()
Returns a WellDouble object.
|
WellDouble |
SimpleWellPOJODouble.toWellObject()
Returns a WellDouble object.
|
WellDouble |
SimpleWellXMLDouble.toWellObject()
Returns a WellDouble object.
|
WellDouble |
WellPOJODouble.toWellObject()
Returns a WellDouble object.
|
| Modifier and Type | Method and Description |
|---|---|
java.util.List<WellDouble> |
PlateReaderDouble.allJSONWells()
Returns a list containing all the JSON wells in the list.
|
java.util.List<WellDouble> |
PlateReaderDouble.allXMLWells()
Returns a list containing all the XML wells in the list.
|
java.util.List<WellDouble> |
PlateReaderDouble.remainingJSONWells()
Returns a list containing the well objects with an index greater than the
current index.
|
java.util.List<WellDouble> |
PlateReaderDouble.remainingXMLWells()
Returns a list containing the well objects with an index greater than the
current index.
|
java.util.List<WellDouble> |
PlateReaderDouble.spentJSONWells()
Returns a list containing the well objects with an index less than the
current index.
|
java.util.List<WellDouble> |
PlateReaderDouble.spentXMLWells()
Returns a list containing the well objects with an index less than the
current index.
|
| Modifier and Type | Method and Description |
|---|---|
void |
PlateWriterDouble.wellToJSON(WellDouble well)
Prints the well values in a JSON format.
|
void |
PlateWriterDouble.wellToJSON(WellDouble[] array)
Prints the wells values in the array in a JSON format.
|
java.lang.String |
PlateWriterDouble.wellToJSONAsString(WellDouble well)
Returns a string containing the well values in a JSON format.
|
java.lang.String |
PlateWriterDouble.wellToJSONAsString(WellDouble[] array)
Returns a string containing the well values in the array in a JSON format.
|
void |
PlateWriterDouble.wellToXML(WellDouble well)
Prints the well values in an XML format.
|
void |
PlateWriterDouble.wellToXML(WellDouble[] array)
Prints the well values in the array in an XML format.
|
java.lang.String |
PlateWriterDouble.wellToXMLAsString(WellDouble well)
Returns a string containing the well values in an XML format.
|
java.lang.String |
PlateWriterDouble.wellToXMLAsString(WellDouble[] array)
Prints the well values in the array in an XML format.
|
| Modifier and Type | Method and Description |
|---|---|
void |
PlateWriterDouble.printMapResult(java.util.Map<WellDouble,java.lang.Double> data,
int rows,
int columns,
java.lang.String label)
Prints the plate map.
|
java.lang.String |
PlateWriterDouble.printMapResultAsString(java.util.Map<WellDouble,java.lang.Double> data,
int rows,
int columns,
java.lang.String label)
Returns a string containing the plate map.
|
void |
PlateWriterDouble.printTableResult(java.util.Map<WellDouble,java.lang.Double> data,
java.lang.String label)
Prints the well value pairs as a delimiter separated table.
|
java.lang.String |
PlateWriterDouble.printTableResultAsString(java.util.Map<WellDouble,java.lang.Double> data,
java.lang.String label)
Resturns a string holding the well value pairs as a delimiter separated table.
|
void |
PlateWriterDouble.resultToJSON(java.util.List<java.util.Map<WellDouble,java.lang.Double>> data)
Prints the well value pairs in a JSON format for each data set.
|
void |
PlateWriterDouble.resultToJSON(java.util.List<java.util.Map<WellDouble,java.lang.Double>> data,
java.util.List<java.lang.String> labels)
Prints the well value pairs in a JSON format for each data set using the
specified labels.
|
void |
PlateWriterDouble.resultToJSON(java.util.Map<WellDouble,java.lang.Double> data)
Prints the well value pairs in a JSON format.
|
void |
PlateWriterDouble.resultToJSON(java.util.Map<WellDouble,java.lang.Double> data,
java.lang.String label)
Prints the well value pairs in a JSON format using the label.
|
java.lang.String |
PlateWriterDouble.resultToJSONAsString(java.util.List<java.util.Map<WellDouble,java.lang.Double>> data)
Returns a string containing the well value pairs in a JSON format for each data set.
|
java.lang.String |
PlateWriterDouble.resultToJSONAsString(java.util.List<java.util.Map<WellDouble,java.lang.Double>> data,
java.util.List<java.lang.String> labels)
Returns a string containing the well value pairs in a JSON format for each data set using the
specified labels.
|
java.lang.String |
PlateWriterDouble.resultToJSONAsString(java.util.Map<WellDouble,java.lang.Double> data)
Returns a string containing the well value pairs in a JSON format.
|
java.lang.String |
PlateWriterDouble.resultToJSONAsString(java.util.Map<WellDouble,java.lang.Double> data,
java.lang.String label)
Returns a string containing the well value pairs in a JSON format using the label.
|
void |
PlateWriterDouble.resultToPlateMap(java.util.List<java.util.Map<WellDouble,java.lang.Double>> data,
int type)
Prints the plate map for each data set in the list.
|
void |
PlateWriterDouble.resultToPlateMap(java.util.List<java.util.Map<WellDouble,java.lang.Double>> data,
int rows,
int columns)
Prints the plate map for each data set in the list.
|
void |
PlateWriterDouble.resultToPlateMap(java.util.List<java.util.Map<WellDouble,java.lang.Double>> data,
int rows,
int columns,
java.util.List<java.lang.String> labels)
Prints the plate map for each data set in the list.
|
void |
PlateWriterDouble.resultToPlateMap(java.util.List<java.util.Map<WellDouble,java.lang.Double>> data,
int type,
java.util.List<java.lang.String> labels)
Prints the plate map for each data set in the list.
|
void |
PlateWriterDouble.resultToPlateMap(java.util.Map<WellDouble,java.lang.Double> data,
int type)
Prints the plate map.
|
void |
PlateWriterDouble.resultToPlateMap(java.util.Map<WellDouble,java.lang.Double> data,
int rows,
int columns)
Prints the plate map.
|
void |
PlateWriterDouble.resultToPlateMap(java.util.Map<WellDouble,java.lang.Double> data,
int rows,
int columns,
java.lang.String label)
Prints the plate map.
|
void |
PlateWriterDouble.resultToPlateMap(java.util.Map<WellDouble,java.lang.Double> data,
int type,
java.lang.String label)
Prints the plate map.
|
java.lang.String |
PlateWriterDouble.resultToPlateMapAsString(java.util.List<java.util.Map<WellDouble,java.lang.Double>> data,
int type)
Returns a string holding the plate map for each data set in the list.
|
java.lang.String |
PlateWriterDouble.resultToPlateMapAsString(java.util.List<java.util.Map<WellDouble,java.lang.Double>> data,
int rows,
int columns)
Returns a string holding the plate map for each data set in the list.
|
java.lang.String |
PlateWriterDouble.resultToPlateMapAsString(java.util.List<java.util.Map<WellDouble,java.lang.Double>> data,
int rows,
int columns,
java.util.List<java.lang.String> labels)
Returns a string containing the plate map for each data set in the list.
|
java.lang.String |
PlateWriterDouble.resultToPlateMapAsString(java.util.List<java.util.Map<WellDouble,java.lang.Double>> data,
int type,
java.util.List<java.lang.String> labels)
Returns a string containing the plate map for each data set in the list.
|
java.lang.String |
PlateWriterDouble.resultToPlateMapAsString(java.util.Map<WellDouble,java.lang.Double> data,
int type)
Returns a string containing the plate map.
|
java.lang.String |
PlateWriterDouble.resultToPlateMapAsString(java.util.Map<WellDouble,java.lang.Double> data,
int rows,
int columns)
Returns a string holding the plate map.
|
java.lang.String |
PlateWriterDouble.resultToPlateMapAsString(java.util.Map<WellDouble,java.lang.Double> data,
int rows,
int columns,
java.lang.String label)
Returns a string containing the plate map.
|
java.lang.String |
PlateWriterDouble.resultToPlateMapAsString(java.util.Map<WellDouble,java.lang.Double> data,
int type,
java.lang.String label)
Returns a string holding the plate map.
|
void |
PlateWriterDouble.resultToTable(java.util.List<java.util.Map<WellDouble,java.lang.Double>> data)
Prints each set of well value pairs as a delimiter separated table.
|
void |
PlateWriterDouble.resultToTable(java.util.List<java.util.Map<WellDouble,java.lang.Double>> data,
java.util.List<java.lang.String> labels)
Prints the well value pairs as a delimiter separated table.
|
void |
PlateWriterDouble.resultToTable(java.util.Map<WellDouble,java.lang.Double> data)
Prints the well value pairs as a delimiter separated table.
|
void |
PlateWriterDouble.resultToTable(java.util.Map<WellDouble,java.lang.Double> data,
java.lang.String label)
Prints the well value pairs as a delimiter separated table.
|
java.lang.String |
PlateWriterDouble.resultToTableAsString(java.util.List<java.util.Map<WellDouble,java.lang.Double>> data)
Returns a string containing each set of well value pairs as a delimiter
separated table.
|
java.lang.String |
PlateWriterDouble.resultToTableAsString(java.util.List<java.util.Map<WellDouble,java.lang.Double>> data,
java.util.List<java.lang.String> labels)
Returns a string containing the well value pairs as a delimiter separated
table.
|
java.lang.String |
PlateWriterDouble.resultToTableAsString(java.util.Map<WellDouble,java.lang.Double> data)
Returns a string containing the well value pairs as a delimiter separated
table.
|
java.lang.String |
PlateWriterDouble.resultToTableAsString(java.util.Map<WellDouble,java.lang.Double> data,
java.lang.String label)
Returns a string containing the well value pairs as a delimiter separated
table.
|
void |
PlateWriterDouble.resultToXML(java.util.Collection<java.util.Map<WellDouble,java.lang.Double>> collection)
Prints the collection of result values in an XML format.
|
void |
PlateWriterDouble.resultToXML(java.util.Collection<java.util.Map<WellDouble,java.lang.Double>> collection,
java.util.List<java.lang.String> labels)
Prints the collection of result values in an XML format.
|
void |
PlateWriterDouble.resultToXML(java.util.Map<WellDouble,java.lang.Double> map)
Prints the well result values in an XML format.
|
void |
PlateWriterDouble.resultToXML(java.util.Map<WellDouble,java.lang.Double> map,
java.lang.String label)
Prints the well result values in an XML format.
|
java.lang.String |
PlateWriterDouble.resultToXMLAsString(java.util.Collection<java.util.Map<WellDouble,java.lang.Double>> collection)
Returns a string containing the collection of result values in an XML format.
|
java.lang.String |
PlateWriterDouble.resultToXMLAsString(java.util.Collection<java.util.Map<WellDouble,java.lang.Double>> collection,
java.util.List<java.lang.String> labels)
Returns a string containing the collection of result values in an XML format.
|
java.lang.String |
PlateWriterDouble.resultToXMLAsString(java.util.Map<WellDouble,java.lang.Double> map)
Returns a string containing the result values in an XML format.
|
java.lang.String |
PlateWriterDouble.resultToXMLAsString(java.util.Map<WellDouble,java.lang.Double> map,
java.lang.String label)
Returns a string containing the result values in an XML format.
|
void |
PlateWriterDouble.wellToJSON(java.util.Collection<WellDouble> collection)
Prints the collection of wells in a JSON format.
|
java.lang.String |
PlateWriterDouble.wellToJSONAsString(java.util.Collection<WellDouble> collection)
Returns a string containing the collection of wells in a JSON format.
|
void |
PlateWriterDouble.wellToXML(java.util.Collection<WellDouble> collection)
Prints the collection of well values in an XML format.
|
java.lang.String |
PlateWriterDouble.wellToXMLAsString(java.util.Collection<WellDouble> collection)
Returns a string containing the collection of well values in an XML format.
|
| Constructor and Description |
|---|
SimpleWellPOJODouble(WellDouble well)
Creates a simple well POJO from a well object.
|
SimpleWellXMLDouble(WellDouble well)
Creates a simple XML well from a well object.
|
WellListPOJODouble(WellDouble well)
Creates a well list POJO from a well object.
|
WellListPOJODouble(WellDouble[] array)
Creates a well list POJO from an array of well objects.
|
WellListXMLDouble(WellDouble well)
Creates an XML well list from a well object.
|
WellListXMLDouble(WellDouble[] array)
Creates an XML well list from an array of well objects.
|
WellPOJODouble(WellDouble well)
Creates a well POJO from the well object.
|
WellXMLDouble(WellDouble well)
Creates a well XML object from a well Double object.
|
| Constructor and Description |
|---|
ResultListPOJODouble(java.util.Collection<java.util.Map<WellDouble,java.lang.Double>> collection)
Creates a result list POJO from a collection of well objects.
|
ResultListPOJODouble(java.util.Collection<java.util.Map<WellDouble,java.lang.Double>> collection,
java.util.List<java.lang.String> labels)
Creates a result list POJO from a collection of well objects.
|
ResultListPOJODouble(java.util.Map<WellDouble,java.lang.Double> results)
Creates a result list POJO from a well object.
|
ResultListPOJODouble(java.util.Map<WellDouble,java.lang.Double> results,
java.lang.String label)
Creates a result list POJO from a well object.
|
ResultListXMLDouble(java.util.Collection<java.util.Map<WellDouble,java.lang.Double>> collection)
Creates an XML result list from a collection of maps.
|
ResultListXMLDouble(java.util.Collection<java.util.Map<WellDouble,java.lang.Double>> collection,
java.util.List<java.lang.String> labels)
Creates an XML result list from a collection of maps and a list of labels.
|
ResultListXMLDouble(java.util.Map<WellDouble,java.lang.Double> map)
Creates an XML result list from a map.
|
ResultListXMLDouble(java.util.Map<WellDouble,java.lang.Double> map,
java.lang.String label)
Creates an XML result list from a map and label.
|
ResultPOJODouble(java.util.Map<WellDouble,java.lang.Double> results,
java.lang.String label)
Creates a result POJO.
|
ResultXMLDouble(java.util.Map<WellDouble,java.lang.Double> map,
java.lang.String label)
Creates a result XML object from a map.
|
WellListPOJODouble(java.util.Collection<WellDouble> collection)
Creates a well list POJO from a collection of well objects.
|
WellListXMLDouble(java.util.Collection<WellDouble> collection)
Creates an XML well list from a collection of well objects.
|
| Modifier and Type | Method and Description |
|---|---|
java.util.List<java.lang.Double> |
MathOperationDoubleUnary.wells(WellDouble well)
Returns the result of the mathematical operation.
|
java.util.List<java.lang.Double> |
MathOperationDoubleBinary.wells(WellDouble well,
java.util.Collection<java.lang.Double> collection)
Returns the result of the mathematical operation.
|
java.util.List<java.lang.Double> |
MathOperationDoubleBinary.wells(WellDouble well,
java.util.Collection<java.lang.Double> collection,
int begin,
int length)
Returns the result of the mathematical operation.
|
java.util.List<java.lang.Double> |
MathOperationDoubleBinary.wells(WellDouble well,
double constant)
Returns the result of the mathematical operation.
|
java.util.List<java.lang.Double> |
MathOperationDoubleBinary.wells(WellDouble well,
double[] array)
Returns the result of the mathematical operation.
|
java.util.List<java.lang.Double> |
MathOperationDoubleBinary.wells(WellDouble well,
double[] array,
int begin,
int length)
Returns the result of the mathematical operation.
|
java.util.List<java.lang.Double> |
MathOperationDoubleUnary.wells(WellDouble well,
int begin,
int length)
Returns the result of the mathematical operation.
|
java.util.List<java.lang.Double> |
MathOperationDoubleBinary.wells(WellDouble well1,
WellDouble well2)
Returns the result of the mathematical operation.
|
java.util.List<java.lang.Double> |
MathOperationDoubleBinary.wells(WellDouble well1,
WellDouble well2,
int begin,
int length)
Returns the result of the mathematical operation using the data between
the indices.
|
java.util.List<java.lang.Double> |
MathOperationDoubleBinary.wellsStrict(WellDouble well,
java.util.Collection<java.lang.Double> collection)
Returns the result of the mathematical operation.
|
java.util.List<java.lang.Double> |
MathOperationDoubleBinary.wellsStrict(WellDouble well,
java.util.Collection<java.lang.Double> collection,
int begin,
int length)
Returns the result of the mathematical operation.
|
java.util.List<java.lang.Double> |
MathOperationDoubleBinary.wellsStrict(WellDouble well,
double[] array)
Returns the result of the mathematical operation.
|
java.util.List<java.lang.Double> |
MathOperationDoubleBinary.wellsStrict(WellDouble well,
double[] array,
int begin,
int length)
Returns the result of the mathematical operation.
|
java.util.List<java.lang.Double> |
MathOperationDoubleBinary.wellsStrict(WellDouble well1,
WellDouble well2)
Returns the result of the mathematical operation.
|
java.util.List<java.lang.Double> |
MathOperationDoubleBinary.wellsStrict(WellDouble well1,
WellDouble well2,
int begin,
int length)
Returns the result of the mathematical operation using the data between
the indices.
|
| Modifier and Type | Method and Description |
|---|---|
WellDouble |
PlateDouble.ceiling(WellDouble well)
Returns the least well in this set greater than or equal to the given
well, or null if there is no such well.
|
WellDouble |
WellSetDouble.ceiling(WellDouble well)
Returns the least well in this set greater than or equal to the given
well, or null if there is no such well.
|
WellDouble |
PlateDouble.first()
Returns the first well in the set.
|
WellDouble |
WellSetDouble.first()
Returns the first well in the set.
|
WellDouble |
PlateDouble.floor(WellDouble well)
Returns the greatest well in this set less than or equal to the given
well, or null if there is no such well.
|
WellDouble |
WellSetDouble.floor(WellDouble well)
Returns the greatest well in this set less than or equal to the given
well, or null if there is no such well.
|
WellDouble |
PlateDouble.getWells(java.lang.String well)
Returns the well with the input indices.
|
WellDouble |
WellSetDouble.getWells(java.lang.String well)
Returns the well with the input indices.
|
WellDouble |
PlateDouble.getWells(WellDouble well)
Returns the well or null if no such well exists.
|
WellDouble |
WellSetDouble.getWells(WellDouble input)
Returns the well or null if no such well exists.
|
WellDouble |
PlateDouble.getWells(WellIndex index)
Returns the well with the input index.
|
WellDouble |
WellSetDouble.getWells(WellIndex index)
Returns the well or null if the well does not exist.
|
WellDouble |
PlateDouble.higher(WellDouble well)
Returns the least well in this set strictly greater than the given
well, or null if there is no such well.
|
WellDouble |
WellSetDouble.higher(WellDouble well)
Returns the least well in this set strictly greater than the given
well, or null if there is no such well.
|
WellDouble |
PlateDouble.last()
Returns the last well in the set.
|
WellDouble |
WellSetDouble.last()
Returns the last well in the set.
|
WellDouble |
PlateDouble.lower(WellDouble well)
Returns the greatest well in this set strictly less than the given well,
or null if there is no such well.
|
WellDouble |
WellSetDouble.lower(WellDouble well)
Returns the greatest well in this set strictly less than the given well,
or null if there is no such well.
|
WellDouble |
PlateDouble.pollFirst()
Retrieves and removes the first (lowest) well, or returns null if this
set is empty.
|
WellDouble |
WellSetDouble.pollFirst()
Retrieves and removes the first (lowest) well, or returns null if this
set is empty.
|
WellDouble |
PlateDouble.pollLast()
Retrieves and removes the last (highest) well, or returns null if this
set is empty.
|
WellDouble |
WellSetDouble.pollLast()
Retrieves and removes the last (highest) well, or returns null if this
set is empty.
|
WellDouble |
WellDouble.subList(int begin,
int length)
Returns a new well containing the values within the indices.
|
WellDouble[] |
PlateDouble.toArray()
Returns the plate wells in an array.
|
WellDouble[] |
WellSetDouble.toWellArray()
Returns the well set as an array of wells.
|
| Modifier and Type | Method and Description |
|---|---|
java.util.Set<WellDouble> |
WellSetDouble.allWells()
Returns the well set.
|
java.util.Iterator<WellDouble> |
PlateDouble.descendingIterator()
Returns an iterator over the wells in this set in descending order.
|
java.util.Iterator<WellDouble> |
WellSetDouble.descendingIterator()
Returns an iterator over the wells in this set in descending order.
|
java.util.Set<WellDouble> |
PlateDouble.descendingSet()
Returns a reverse order view of the wells contained in this set.
|
java.util.Set<WellDouble> |
WellSetDouble.descendingSet()
Returns a reverse order view of the wells contained in this set.
|
java.util.Set<WellDouble> |
WellSetDouble.headSet(int index)
Returns a view of the portion of this set whose wells are less than
or equal to the index.
|
java.util.Set<WellDouble> |
WellSetDouble.headSet(int index,
boolean inclusive)
Returns a view of the portion of this set whose wells are less than
(or equal to, if inclusive is true) the index.
|
java.util.Set<WellDouble> |
PlateDouble.headSet(WellDouble well)
Returns a view of the portion of this set whose wells are strictly
less than the input well.
|
java.util.Set<WellDouble> |
WellSetDouble.headSet(WellDouble well)
Returns a view of the portion of this set whose wells are strictly
less than the input well.
|
java.util.Set<WellDouble> |
PlateDouble.headSet(WellDouble well,
boolean inclusive)
Returns a view of the portion of this set whose wells are less than
(or equal to, if inclusive is true) to the input well.
|
java.util.Set<WellDouble> |
WellSetDouble.headSet(WellDouble well,
boolean inclusive)
Returns a view of the portion of this set whose wells are less than
(or equal to, if inclusive is true) to the input well.
|
java.util.Iterator<WellDouble> |
PlateDouble.iterator()
Returns an iterator that iterates over the well in the plate.
|
java.util.Iterator<WellDouble> |
WellSetDouble.iterator()
Returns an iterator over the wells in this set in ascending order.
|
java.util.Set<WellDouble> |
WellSetDouble.subSet(int index1,
boolean inclusive1,
int index2,
boolean inclusive2)
Returns a view of the portion of this set between the indices.
|
java.util.Set<WellDouble> |
WellSetDouble.subSet(int index1,
int index2)
Returns a view of the portion of this set between the indices.
|
java.util.Set<WellDouble> |
PlateDouble.subSet(WellDouble well1,
boolean inclusive1,
WellDouble well2,
boolean inclusive2)
Returns a view of the portion of this set whose wells range from
the first input well to the second input well.
|
java.util.Set<WellDouble> |
WellSetDouble.subSet(WellDouble well1,
boolean inclusive1,
WellDouble well2,
boolean inclusive2)
Returns a view of the portion of this set whose wells range from
the first input well to the second input well.
|
java.util.Set<WellDouble> |
PlateDouble.subSet(WellDouble well1,
WellDouble well2)
Returns a view of the portion of this set whose wells range from
the first input well inclusive to the second input well inclusive.
|
java.util.Set<WellDouble> |
WellSetDouble.subSet(WellDouble well1,
WellDouble well2)
Returns a view of the portion of this set whose wells range from
the first input well inclusive to the second input well inclusive.
|
java.util.Set<WellDouble> |
WellSetDouble.tailSet(int index)
Returns a view of the portion of this set whose wells are greater than
or equal to the index.
|
java.util.Set<WellDouble> |
WellSetDouble.tailSet(int index,
boolean inclusive)
Returns a view of the portion of this set whose wells are greater than
(or equal to, if inclusive is true) the index.
|
java.util.Set<WellDouble> |
PlateDouble.tailSet(WellDouble well)
Returns a view of the portion of this set whose wells are greater than
or equal to the input well.
|
java.util.Set<WellDouble> |
WellSetDouble.tailSet(WellDouble well)
Returns a view of the portion of this set whose wells are greater than
or equal to the input well.
|
java.util.Set<WellDouble> |
PlateDouble.tailSet(WellDouble well,
boolean inclusive)
Returns a view of the portion of this set whose wells are greater than
(or equal to, if inclusive is true) the input well.
|
java.util.Set<WellDouble> |
WellSetDouble.tailSet(WellDouble well,
boolean inclusive)
Returns a view of the portion of this set whose wells are greater than
(or equal to, if inclusive is true) the input well.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
WellSetDouble.add(WellDouble well)
Adds a well to the well set.
|
void |
WellDouble.add(WellDouble well)
Adds the data from another well.
|
boolean |
WellSetDouble.add(WellDouble[] array)
Adds an array of wells to the well set.
|
boolean |
PlateDouble.addWells(WellDouble well)
Adds a well to the data set.
|
boolean |
PlateDouble.addWells(WellDouble[] array)
Adds an array of wells to the data set omitting wells that are already
members of the set.
|
WellDouble |
PlateDouble.ceiling(WellDouble well)
Returns the least well in this set greater than or equal to the given
well, or null if there is no such well.
|
WellDouble |
WellSetDouble.ceiling(WellDouble well)
Returns the least well in this set greater than or equal to the given
well, or null if there is no such well.
|
boolean |
PlateDouble.contains(WellDouble well)
Returns true if the well is part of the well set.
|
boolean |
WellSetDouble.contains(WellDouble well)
Returns true if the well is part of the well set.
|
boolean |
PlateDouble.contains(WellDouble[] array)
Returns true if all the input wells are found within the plate.
|
boolean |
WellSetDouble.contains(WellDouble[] array)
Returns true if all the input wells are found within the well array.
|
WellDouble |
PlateDouble.floor(WellDouble well)
Returns the greatest well in this set less than or equal to the given
well, or null if there is no such well.
|
WellDouble |
WellSetDouble.floor(WellDouble well)
Returns the greatest well in this set less than or equal to the given
well, or null if there is no such well.
|
WellDouble |
PlateDouble.getWells(WellDouble well)
Returns the well or null if no such well exists.
|
WellDouble |
WellSetDouble.getWells(WellDouble input)
Returns the well or null if no such well exists.
|
WellSetDouble |
PlateDouble.getWells(WellDouble[] array)
Returns the well or null if no such well exists.
|
WellSetDouble |
WellSetDouble.getWells(WellDouble[] array)
Returns a well set holding all wells that match the indices or null
if there are no matches.
|
java.util.Set<WellDouble> |
PlateDouble.headSet(WellDouble well)
Returns a view of the portion of this set whose wells are strictly
less than the input well.
|
java.util.Set<WellDouble> |
WellSetDouble.headSet(WellDouble well)
Returns a view of the portion of this set whose wells are strictly
less than the input well.
|
java.util.Set<WellDouble> |
PlateDouble.headSet(WellDouble well,
boolean inclusive)
Returns a view of the portion of this set whose wells are less than
(or equal to, if inclusive is true) to the input well.
|
java.util.Set<WellDouble> |
WellSetDouble.headSet(WellDouble well,
boolean inclusive)
Returns a view of the portion of this set whose wells are less than
(or equal to, if inclusive is true) to the input well.
|
WellDouble |
PlateDouble.higher(WellDouble well)
Returns the least well in this set strictly greater than the given
well, or null if there is no such well.
|
WellDouble |
WellSetDouble.higher(WellDouble well)
Returns the least well in this set strictly greater than the given
well, or null if there is no such well.
|
WellDouble |
PlateDouble.lower(WellDouble well)
Returns the greatest well in this set strictly less than the given well,
or null if there is no such well.
|
WellDouble |
WellSetDouble.lower(WellDouble well)
Returns the greatest well in this set strictly less than the given well,
or null if there is no such well.
|
<T extends java.lang.Number> |
PlateDouble.printData(WellDouble well)
Returns a string holding the well data.
|
boolean |
WellSetDouble.remove(WellDouble well)
Removes a well from the well set.
|
boolean |
WellSetDouble.remove(WellDouble[] array)
Removes an array of wells from the well set.
|
void |
WellDouble.removeWell(WellDouble well)
Removes all the well values from the data set.
|
boolean |
PlateDouble.removeWells(WellDouble well)
Removes the well from the data set.
|
boolean |
PlateDouble.removeWells(WellDouble[] wells)
Removes an array of wells.
|
boolean |
WellSetDouble.replace(WellDouble well)
Replaces the set well with the input well.
|
boolean |
WellSetDouble.replace(WellDouble[] array)
Replaces the set wells with the wells from the array.
|
void |
WellDouble.replaceData(WellDouble well)
Clears the data set and adds the well data set.
|
boolean |
PlateDouble.replaceWells(WellDouble well)
Replaces the plate well with the input well.
|
boolean |
PlateDouble.replaceWells(WellDouble[] array)
Replaces the plate wells with the wells from the array.
|
boolean |
WellSetDouble.retain(WellDouble well)
Retains the input well if it exists.
|
boolean |
WellSetDouble.retain(WellDouble[] array)
Retains the wells in the array if they exist.
|
void |
WellDouble.retainWell(WellDouble well)
Retains all the values in the well.
|
boolean |
PlateDouble.retainWells(WellDouble well)
Retains the input well if it exists.
|
boolean |
PlateDouble.retainWells(WellDouble[] array)
Retains the wells in the array if they exist.
|
java.util.Set<WellDouble> |
PlateDouble.subSet(WellDouble well1,
boolean inclusive1,
WellDouble well2,
boolean inclusive2)
Returns a view of the portion of this set whose wells range from
the first input well to the second input well.
|
java.util.Set<WellDouble> |
WellSetDouble.subSet(WellDouble well1,
boolean inclusive1,
WellDouble well2,
boolean inclusive2)
Returns a view of the portion of this set whose wells range from
the first input well to the second input well.
|
java.util.Set<WellDouble> |
PlateDouble.subSet(WellDouble well1,
WellDouble well2)
Returns a view of the portion of this set whose wells range from
the first input well inclusive to the second input well inclusive.
|
java.util.Set<WellDouble> |
WellSetDouble.subSet(WellDouble well1,
WellDouble well2)
Returns a view of the portion of this set whose wells range from
the first input well inclusive to the second input well inclusive.
|
java.util.Set<WellDouble> |
PlateDouble.tailSet(WellDouble well)
Returns a view of the portion of this set whose wells are greater than
or equal to the input well.
|
java.util.Set<WellDouble> |
WellSetDouble.tailSet(WellDouble well)
Returns a view of the portion of this set whose wells are greater than
or equal to the input well.
|
java.util.Set<WellDouble> |
PlateDouble.tailSet(WellDouble well,
boolean inclusive)
Returns a view of the portion of this set whose wells are greater than
(or equal to, if inclusive is true) the input well.
|
java.util.Set<WellDouble> |
WellSetDouble.tailSet(WellDouble well,
boolean inclusive)
Returns a view of the portion of this set whose wells are greater than
(or equal to, if inclusive is true) the input well.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
WellSetDouble.add(java.util.Collection<WellDouble> collection)
Adds a collection of wells to the well set.
|
boolean |
PlateDouble.addWells(java.util.Collection<WellDouble> collection)
Adds a collection of wells to the data set omitting wells that are already
members of the set.
|
boolean |
PlateDouble.contains(java.util.Collection<WellDouble> collection)
Returns true if all the input wells are found within the well set.
|
boolean |
WellSetDouble.contains(java.util.Collection<WellDouble> collection)
Returns true if all the input wells are found within the well set.
|
WellSetDouble |
PlateDouble.getWells(java.util.Collection<WellDouble> collection)
Returns the well or null if no such well exists.
|
WellSetDouble |
WellSetDouble.getWells(java.util.Collection<WellDouble> collection)
Returns a well set holding all plate wells that match the indices or null
if there are no matches.
|
boolean |
WellSetDouble.remove(java.util.Collection<WellDouble> collection)
Removes a collection of wells from the well set.
|
boolean |
PlateDouble.removeWells(java.util.Collection<WellDouble> collection)
Removes a collection of wells.
|
boolean |
WellSetDouble.replace(java.util.Collection<WellDouble> collection)
Replaces the set wells with the wells from the collection.
|
boolean |
PlateDouble.replaceWells(java.util.Collection<WellDouble> collection)
Replaces the plate wells with the wells from the collection.
|
boolean |
WellSetDouble.retain(java.util.Collection<WellDouble> collection)
Retains the wells in the collection if they exist.
|
boolean |
PlateDouble.retainWells(java.util.Collection<WellDouble> collection)
Retains the wells in the collection if they exist.
|
| Constructor and Description |
|---|
WellDouble(WellDouble well)
Clones a double well without invoking clone.
|
WellSetDouble(WellDouble[] wells)
Creates a new well set from an array of wells.
|
WellSetDouble(WellDouble[] wells,
java.lang.String label)
Creates a new well set from an array of wells and a label.
|
| Constructor and Description |
|---|
WellSetDouble(java.util.Collection<WellDouble> collection)
Creates a new well set from a collection of wells.
|
WellSetDouble(java.util.Collection<WellDouble> collection,
java.lang.String label)
Creates a new well set from a collection of wells and a label.
|
| Modifier and Type | Method and Description |
|---|---|
java.util.Map<WellDouble,java.lang.Double> |
DescriptiveStatisticDouble.plate(PlateDouble plate)
Returns the statistic for each plate well.
|
java.util.Map<WellDouble,java.util.List<java.lang.Double>> |
DescriptiveStatisticListDouble.plate(PlateDouble plate)
Returns the statistic for each plate well.
|
java.util.Map<WellDouble,java.lang.Integer> |
NDouble.plate(PlateDouble plate)
Returns the number of data points for each plate well.
|
java.util.Map<WellDouble,java.lang.Double> |
QuantileStatisticDoubles.plate(PlateDouble plate,
double p)
Returns the statistic for each plate well.
|
java.util.Map<WellDouble,java.lang.Double> |
DescriptiveStatisticDoubleWeights.plate(PlateDouble plate,
double[] weights)
Returns the weighted statistic for each plate well.
|
java.util.Map<WellDouble,java.util.List<java.lang.Double>> |
DescriptiveStatisticListDoubleWeights.plate(PlateDouble plate,
double[] weights)
Returns the weighted statistic for each plate well.
|
java.util.Map<WellDouble,java.lang.Double> |
DescriptiveStatisticDoubleWeights.plate(PlateDouble plate,
double[] weights,
int begin,
int length)
Returns the weighted statistic for each plate well using the values between the
beginning and ending indices.
|
java.util.Map<WellDouble,java.util.List<java.lang.Double>> |
DescriptiveStatisticListDoubleWeights.plate(PlateDouble plate,
double[] weights,
int begin,
int length)
Returns the weighted statistic for each plate well using the values between the
beginning and ending indices.
|
java.util.Map<WellDouble,java.lang.Double> |
QuantileStatisticDouble.plate(PlateDouble plate,
int p)
Returns the statistic for each plate well.
|
java.util.Map<WellDouble,java.util.List<java.util.List<java.lang.Double>>> |
QuantileStatisticListDouble.plate(PlateDouble plate,
int p)
Returns the statistic for each plate well.
|
java.util.Map<WellDouble,java.lang.Double> |
DescriptiveStatisticDouble.plate(PlateDouble plate,
int begin,
int length)
Returns the statistic for each plate well using the values between the beginning
and ending indices.
|
java.util.Map<WellDouble,java.util.List<java.lang.Double>> |
DescriptiveStatisticListDouble.plate(PlateDouble plate,
int begin,
int length)
Returns the statistic for each plate well using the values between the beginning
and ending indices.
|
java.util.Map<WellDouble,java.lang.Double> |
QuantileStatisticDoubles.plate(PlateDouble plate,
int begin,
int length,
double p)
Returns the statistic for each plate well using the values between the
beginning and ending indices.
|
java.util.Map<WellDouble,java.lang.Double> |
QuantileStatisticDouble.plate(PlateDouble plate,
int begin,
int length,
int p)
Returns the statistic for each plate well using the values between the
beginning and ending indices.
|
java.util.Map<WellDouble,java.util.List<java.util.List<java.lang.Double>>> |
QuantileStatisticListDouble.plate(PlateDouble plate,
int begin,
int length,
int p)
Returns the statistic for each plate well using the values between the
beginning and ending indices.
|
java.util.Map<WellDouble,java.util.List<java.util.List<java.lang.Double>>> |
QuantileStatisticListsDouble.plate(PlateDouble plate,
int begin,
int length,
java.util.List<java.lang.Double> list)
Returns the statistic for each plate well using the values between the
beginning and ending indices.
|
java.util.Map<WellDouble,java.util.List<java.util.List<java.lang.Double>>> |
QuantileStatisticListsDouble.plate(PlateDouble plate,
java.util.List<java.lang.Double> list)
Returns the statistic for each plate well.
|
java.util.Map<WellDouble,java.lang.Double> |
DescriptiveStatisticDouble.set(WellSetDouble set)
Returns the statistic of each well in the well set.
|
java.util.Map<WellDouble,java.util.List<java.lang.Double>> |
DescriptiveStatisticListDouble.set(WellSetDouble set)
Returns the statistic of each well in the well set.
|
java.util.Map<WellDouble,java.lang.Integer> |
NDouble.set(WellSetDouble set)
Returns the number of data points for each well in the well set.
|
java.util.Map<WellDouble,java.lang.Double> |
QuantileStatisticDoubles.set(WellSetDouble set,
double p)
Returns the statistic of each well in the well set.
|
java.util.Map<WellDouble,java.lang.Double> |
DescriptiveStatisticDoubleWeights.set(WellSetDouble set,
double[] weights)
Returns the weighted statistic of each well in the well set.
|
java.util.Map<WellDouble,java.util.List<java.lang.Double>> |
DescriptiveStatisticListDoubleWeights.set(WellSetDouble set,
double[] weights)
Returns the weighted statistic of each well in the well set.
|
java.util.Map<WellDouble,java.lang.Double> |
DescriptiveStatisticDoubleWeights.set(WellSetDouble set,
double[] weights,
int begin,
int length)
Returns the weighted statistic of each well in the well set using the values
between the beginning and ending indices.
|
java.util.Map<WellDouble,java.util.List<java.lang.Double>> |
DescriptiveStatisticListDoubleWeights.set(WellSetDouble set,
double[] weights,
int begin,
int length)
Returns the weighted statistic of each well in the well set using the values
between the beginning and ending indices.
|
java.util.Map<WellDouble,java.lang.Double> |
QuantileStatisticDouble.set(WellSetDouble set,
int p)
Returns the statistic of each well in the well set.
|
java.util.Map<WellDouble,java.util.List<java.util.List<java.lang.Double>>> |
QuantileStatisticListDouble.set(WellSetDouble set,
int p)
Returns the statistic of each well in the well set.
|
java.util.Map<WellDouble,java.lang.Double> |
DescriptiveStatisticDouble.set(WellSetDouble set,
int begin,
int length)
Returns the statistic of each well in the well set using the values between
the beginning and ending indices.
|
java.util.Map<WellDouble,java.util.List<java.lang.Double>> |
DescriptiveStatisticListDouble.set(WellSetDouble set,
int begin,
int length)
Returns the statistic of each well in the well set using the values between
the beginning and ending indices.
|
java.util.Map<WellDouble,java.lang.Double> |
QuantileStatisticDoubles.set(WellSetDouble set,
int begin,
int length,
double p)
Returns the statistic of each well in the well set using the values between
the beginning and ending indices.
|
java.util.Map<WellDouble,java.lang.Double> |
QuantileStatisticDouble.set(WellSetDouble set,
int begin,
int length,
int p)
Returns the statistic of each well in the well set using the values between
the beginning and ending indices.
|
java.util.Map<WellDouble,java.util.List<java.util.List<java.lang.Double>>> |
QuantileStatisticListDouble.set(WellSetDouble set,
int begin,
int length,
int p)
Returns the statistic of each well in the well set using the values between
the beginning and ending indices.
|
java.util.Map<WellDouble,java.util.List<java.util.List<java.lang.Double>>> |
QuantileStatisticListsDouble.set(WellSetDouble set,
int begin,
int length,
java.util.List<java.lang.Double> list)
Returns the statistic of each well in the well set using the values between
the beginning and ending indices.
|
java.util.Map<WellDouble,java.util.List<java.util.List<java.lang.Double>>> |
QuantileStatisticListsDouble.set(WellSetDouble set,
java.util.List<java.lang.Double> list)
Returns the statistic of each well in the well set.
|
| Modifier and Type | Method and Description |
|---|---|
double |
DescriptiveStatisticDouble.well(WellDouble well)
Returns the well statistic.
|
java.util.List<java.lang.Double> |
DescriptiveStatisticListDouble.well(WellDouble well)
Returns the well statistic.
|
int |
NDouble.well(WellDouble well)
Returns the number of well data points.
|
double |
QuantileStatisticDoubles.well(WellDouble well,
double p)
Returns the well statistic.
|
double |
DescriptiveStatisticDoubleWeights.well(WellDouble well,
double[] weights)
Returns the weighted well statistic.
|
java.util.List<java.lang.Double> |
DescriptiveStatisticListDoubleWeights.well(WellDouble well,
double[] weights)
Returns the weighted well statistic.
|
double |
DescriptiveStatisticDoubleWeights.well(WellDouble well,
double[] weights,
int begin,
int length)
Returns the well weighted statistic for the values between the beginning and
ending indices.
|
java.util.List<java.lang.Double> |
DescriptiveStatisticListDoubleWeights.well(WellDouble well,
double[] weights,
int begin,
int length)
Returns the well weighted statistic for the values between the beginning and
ending indices.
|
double |
QuantileStatisticDouble.well(WellDouble well,
int p)
Returns the well statistic.
|
java.util.List<java.util.List<java.lang.Double>> |
QuantileStatisticListDouble.well(WellDouble well,
int p)
Returns the well statistic.
|
double |
DescriptiveStatisticDouble.well(WellDouble well,
int begin,
int length)
Returns the well statistic for the values between the beginning and ending
indices.
|
java.util.List<java.lang.Double> |
DescriptiveStatisticListDouble.well(WellDouble well,
int begin,
int length)
Returns the well statistic for the values between the beginning and ending
indices.
|
double |
QuantileStatisticDoubles.well(WellDouble well,
int begin,
int length,
double p)
Returns the well statistic for the values between the beginning and ending
indices.
|
double |
QuantileStatisticDouble.well(WellDouble well,
int begin,
int length,
int p)
Returns the well statistic for the values between the beginning and ending
indices.
|
java.util.List<java.util.List<java.lang.Double>> |
QuantileStatisticListDouble.well(WellDouble well,
int begin,
int length,
int p)
Returns the well statistic for the values between the beginning and ending
indices.
|
java.util.List<java.util.List<java.lang.Double>> |
QuantileStatisticListsDouble.well(WellDouble well,
int begin,
int length,
java.util.List<java.lang.Double> list)
Returns the well statistic for the values between the beginning and ending
indices.
|
java.util.List<java.util.List<java.lang.Double>> |
QuantileStatisticListsDouble.well(WellDouble well,
java.util.List<java.lang.Double> list)
Returns the well statistic.
|
| Modifier and Type | Method and Description |
|---|---|
static WellDouble |
RandomUtil.randomWellDouble(double min,
double max,
int rowMin,
int rowMax,
int columnMin,
int columnMax,
int length)
Returns a random well between the indices.
|
static WellDouble |
RandomUtil.randomWellDouble(double min,
double max,
int rowMin,
int rowMax,
int columnMin,
int columnMax,
int minLength,
int maxLength)
Returns a random well index between the indices.
|
| Modifier and Type | Method and Description |
|---|---|
static void |
ValUtil.validateWell(int rows,
int columns,
WellDouble well)
Validates the well by checking for invalid indices.
|


Nicolette Chambers Home Blog About Version Control for Beginners | October 2015 Margins, Borders, and Padding, Which do I use? | November 9, 2015 Breaking Down Data Structures | November 15, 2015 The Map Method: The Inside Scoop | November 23, 2015 Dissecting Ruby Classes | November 25, 2015 Classes vs Constructor Functions | December 7, 2015 A Short Guide to Regular Expressions | December 7, 2015 Parsing and Saving Data From a CSV | March 28, 2016 Recap: Write/Speak/Code Conference | June 23, 2016


{{ template "header.html" . }}
Extensive description about the offer. You can use BB codes
Optional offer image. You can omit this field if the offer does not have an image. All images will be resized to a 64x64 size.


News story
The Skills Funding Agency (SFA) has launched a new tool to help employers across England find apprenticeship training.
The find apprenticeship training tool is now available, and gives employers quick access to information about apprenticeships on offer at approved training organisations.
The easy-to-use tool includes information on over 16,000 apprenticeships, as well as details about the training providers that can deliver the qualifications.
The SFA has been working with training providers to help develop the tool, make it easy to upload information, and give them the opportunity to demonstrate the range and quality of their training. As part of the design process, around 400 employers and 200 training providers have already tested the system, playing an integral part in shaping its design.
Find apprenticeship training is a major part of the new digital apprenticeship service. The SFA will continue to support providers and update the information in preparation for the launch of the digital apprenticeship service in 2017.
Published: 27 October 2016
From: Skills Funding Agency
Part of: Apprenticeships


|
| OpenAFP.Types.Chunk | | Portability | non-portable (GHC-only) | | Stability | experimental | | Maintainer |<EMAIL_ADDRESS>|
|
|
|
|
|
| Description |
| This module handles pre-parsed chunks in AFP files.
|
|
| Synopsis |
|
| type NStr = Buffer0 | | | type AStr = NStr | | | type ChunkWriter c = WriterT (ChunkQueue c) | | | type WriterStateIO v a = (ChunkBuf c n b, MonadReader v m, MonadPlus m, MonadIO m, MonadError e m, Show e, Typeable e) => ChunkWriter c m a | | | _NStr :: NStr | | | fromAStr :: AStr -> IOm String | | | toAStr :: String -> IOm AStr | | | fromNStr :: NStr -> IOm [N1] | | | toNStr :: [N1] -> IOm NStr | | | newtype ChunkType = MkChunkType String | | | chunkTypeOf :: Typeable a => a -> ChunkType | | | class (Show c, Typeable c, Buf b, Num n, Enum n) => ChunkBuf c n b | c -> n, c -> b where | | | | class (Rec r, ChunkBuf c n b) => RecChunk r c n b | r -> c where | | | | class (Rec a, Rec b) => RecData a b | a -> b, b -> a where | | | | (~~) :: (ChunkBuf c n b, Typeable t) => c -> t -> Bool | | | (<~~) :: (ChunkBuf c n b, Typeable t, Rec r) => t -> [c] -> IOm r | | | (~~>) :: (ChunkBuf c n b, Typeable t, Rec r) => [c] -> t -> IOm r | | | (==>) :: (ChunkBuf c n b, MonadIO m) => [c] -> [(ChunkType, c -> m [c])] -> m [c] | | | (<==) :: (ChunkBuf c n b, MonadIO m) => [(ChunkType, c -> m [c])] -> [c] -> m [c] | | | (..>) :: (ChunkBuf c n b, MonadIO m) => [c] -> [(ChunkType, c -> m [c])] -> m () | | | (<..) :: (ChunkBuf c n b, MonadIO m) => [(ChunkType, c -> m [c])] -> [c] -> m () | | | processChunk :: (MonadIO m, Rec r, ChunkBuf c n b) => r -> (r -> ChunkWriter c m a) -> c -> m [c] | | | inspectChunk :: (MonadIO m, Rec a, ChunkBuf c n b) => a -> (a -> m t) -> c -> m [c] | | | push :: (ChunkBuf c n b, MonadIO m, Rec a) => a -> ChunkWriter c m () | | | filterChunks :: (MonadIO m, RecChunk r c n b, ChunkBuf c' n' b') => r -> [(ChunkType, c -> ChunkWriter c' m [c])] -> ChunkWriter c' m () | | |
|
|
| Documentation |
|
| type NStr = Buffer0 |
|
| type AStr = NStr |
|
| type ChunkWriter c = WriterT (ChunkQueue c) |
|
| type WriterStateIO v a = (ChunkBuf c n b, MonadReader v m, MonadPlus m, MonadIO m, MonadError e m, Show e, Typeable e) => ChunkWriter c m a |
|
| _NStr :: NStr |
|
| fromAStr :: AStr -> IOm String |
|
| toAStr :: String -> IOm AStr |
|
| fromNStr :: NStr -> IOm [N1] |
|
| toNStr :: [N1] -> IOm NStr |
|
| newtype ChunkType |
|
|
| chunkTypeOf :: Typeable a => a -> ChunkType |
|
| class (Show c, Typeable c, Buf b, Num n, Enum n) => ChunkBuf c n b | c -> n, c -> b where |
| The ChunkBuf class represents non-parsed chunks, constructed from a
(ChunkType, Buffer) tuple. | | | Methods | | chunkApply :: MonadIO m => n -> c -> (forall a . Rec a => a -> m x) -> m x | | | chunkCon :: (n, b) -> c | | | chunkDecon :: c -> (n, b) | | | chunkType :: c -> ChunkType | | | chunkTypeLookup :: c -> n -> ChunkType | | | chunkToPStrLen :: c -> PStringLen | | | chunkMapFiltersM_ :: MonadIO m => c -> [(ChunkType, c -> m [c])] -> m () | | | chunkMapFiltersM :: MonadIO m => c -> [(ChunkType, c -> m [c])] -> m [c] | | | chunksMapFiltersM :: MonadIO m => [c] -> [(ChunkType, c -> m [c])] -> m [c] | | | chunksMapFiltersM_ :: MonadIO m => [c] -> [(ChunkType, c -> m [c])] -> m () | | | chunkToRecord :: Binary (Record r) => c -> IO (Record r) | | | chunkFromRecord :: (Binary r, Storable r, Rec r) => r -> IO c |
| | | Instances | |
|
|
| class (Rec r, ChunkBuf c n b) => RecChunk r c n b | r -> c where |
| The RecChunk class unifies a Rec (parent) with its contained
chunk types (children). | | | Methods | | readChunks :: r -> [c] | | | writeChunks :: MonadIO m => r -> m [c] -> m r |
| | | Instances | |
|
|
| class (Rec a, Rec b) => RecData a b | a -> b, b -> a where |
| The RecData class unifies a Rec (parent) with its contained
Rec data type (children). | | | Methods | | readData :: a -> [Record b] | | | writeData :: a -> [Record b] -> a |
| | | Instances | |
|
|
| (~~) :: (ChunkBuf c n b, Typeable t) => c -> t -> Bool |
|
| (<~~) :: (ChunkBuf c n b, Typeable t, Rec r) => t -> [c] -> IOm r |
|
| (~~>) :: (ChunkBuf c n b, Typeable t, Rec r) => [c] -> t -> IOm r |
|
| (==>) :: (ChunkBuf c n b, MonadIO m) => [c] -> [(ChunkType, c -> m [c])] -> m [c] |
|
| (<==) :: (ChunkBuf c n b, MonadIO m) => [(ChunkType, c -> m [c])] -> [c] -> m [c] |
|
| (..>) :: (ChunkBuf c n b, MonadIO m) => [c] -> [(ChunkType, c -> m [c])] -> m () |
|
| (<..) :: (ChunkBuf c n b, MonadIO m) => [(ChunkType, c -> m [c])] -> [c] -> m () |
|
| processChunk :: (MonadIO m, Rec r, ChunkBuf c n b) => r -> (r -> ChunkWriter c m a) -> c -> m [c] |
|
| inspectChunk :: (MonadIO m, Rec a, ChunkBuf c n b) => a -> (a -> m t) -> c -> m [c] |
|
| push :: (ChunkBuf c n b, MonadIO m, Rec a) => a -> ChunkWriter c m () |
|
| filterChunks :: (MonadIO m, RecChunk r c n b, ChunkBuf c' n' b') => r -> [(ChunkType, c -> ChunkWriter c' m [c])] -> ChunkWriter c' m () |
|
| data ChunkQueue a |
| Constructors | | ChunkQueue [a] | | | ChunkItem a | |
| | Instances | |
|
|
| Produced by Haddock version ADDOCK_VERSION |


Home
About
Games
Accounts
Contact us
Blog
F
G
L
Math I/O
Home
Account
About
Contact us
Search games
Blog
Legal summary
Legal summary
Privacy Policy
Terms of Use
Resources
Privacy Policy summary
TODO
Terms of Use summary
TODO


BS-Sense
Ever wondered how much BS there is around you?
Of course you have.
Search Query: {{ search_query }}
{% endif %}
My BS-sense is tingling... Analyzed with machine learning, calculated through complex statistical models, and ultimately presented to you in a single rating Due to lack of time this feature will be implemented shortly, stay tuned :) Correlation of Subjectivity to Emotional Response
Sample Data
So Optimistic
{% if tweets_plus %}
{% for tweet in tweets_plus %}
So Pessimistic
{% if tweets_minus %}
{% for tweet in tweets_minus %}
Straight Facts
{% if tweets_fact %}
{% for tweet in tweets_fact %}
Full Of It
{% if tweets_unfact %}
{% for tweet in tweets_unfact %}
BS-Meter


My Workflow using R Markdown Notebooks
I use data science methods to answer challenging pediatric research questions. I've used R Markdown Notebooks in my workflow to answer those questions. R Markdown Notebooks allow me to analyze and collaborate with other data scientists. This blog post will provide a summary of the steps I take to complete tasks using R Markdown.
Setup
When setting up, I update the title to be more specific and add libraries I need in the first chunk. I also add sections defining the chunks. Additionally, I can add information such as text or images that will enhance the notebook.
library(dplyr) # select, group_by, ...
library(dbi) # sql
library(kableExtra) # kable_styling
Import Data
My next step is importing data. For my analysis, I use a de-identified EHR database installed in a SQL cloud environment. I can use the DBI package to execute SQL queries and assign those results to a data frame.
{sql, connection=EMR,output.var="example_output"}
SELECT DISTINCT
PATIENT_NUM AS PatientNum,
ADMITTEDTM AS AdmittedTime,
DISCHARGEDTM AS DischargeTime,
ACCOUNT_ID AS AccountID,
AGEYEARS AS AgeYears,
PATIENTSEX AS Gender,
PATIENTRACE AS Race,
DIAGNOSISTYPE AS DiagnosisType,
DIAGNOSISCODE AS DiagnosisCode,
DIAGNOSISDESC AS DiagnosisDescription,
INSURANCE AS Insurance
FROM
DIAGNOSIS AS Diagnosis_Table
.
.
.
.
.
.
WHERE
AGEYEARS <= 18
AND
(
(DIAGNOSISTYPE = 'ICD10-CM' AND
DIAGNOSISCODE IN ('G03.9', 'G03.8')
)
OR
(DIAGNOSISTYPE = 'ICD9' AND
DIAGNOSISCODE IN ('322.9', '03.6')
)
)
Tidy Data
I tidy any data into a data frame so that I can explore it.
stats <- example_output %>%
filter(AgeYears > 3) %>%
arrange(PatientNum)
Explore Data
I can summarize my data with descriptive statistics to identify interesting data points. To assess this, I use kable. I can also visualize my data using ggplot.
stats %>%
group_by(Gender) %>%
summarize(Encounters = n(),
AgeYearsMean = mean(AgeYears, na.rm=TRUE),
AgeYearsSD = sd(AgeYears, na.rm=TRUE),
AgeDaysMean = mean(AgeDays, na.rm=TRUE),
AgeDaysSD = sd(AgeDays, na.rm=TRUE)) %>%
ungroup() %>%
arrange(AgeYearsMean) %>%
kable("html", format.args=list(big.mark=","),
caption ="Age Descriptive Statistics by Gender") %>%
kable_styling(bootstrap_options=c("striped", "bordered", "condensed"),
full_width=TRUE,
position="left",
font_size=11) %>%
column_spec(1, bold=TRUE)
This is a brief summary of how I use R Markdown Notebooks to answer research questions.


SIRENS A film review by Mark R. Leeper Copyright 1994 Mark R. Leeper
Capsule review: This is a delicious Australian comedy based on around real incident from the 1930s. An English vicar visits the estate of an Australian famous for painting female nudes to convince the artist not to exhibit a painting deemed blasphemous. Instead the vicar's wife is seduced by the sensuous atmosphere surrounding the artist. Rating: +2 (-4 to +4)
It was the 1930s and the Australian art world was shocked by the so- called immoral paintings of Norman Lindsey. There were some people who were irritated as he has painted picture after picture with sensuous female nudes. But for some, particularly for the local religious authorities, this time he had gone too far. A local exhibition included a crucified female nude. Around this minor controversial episode of art history John Duigan has written and directed the most enchanting comedy film since last year's MUCH ADO ABOUT NOTHING.
Anthony Campion (played by Hugh Grant) is an English vicar visiting Australia. His travel plans will take him near Lindsay's studio/home. He is given the mission of visiting Lindsay (played by Sam Neill) and convincing him to pull the offending painting from exhibition. Campion is deemed an ideal choice since he cannot possibly appear to represent outdated ideas to Lindsay. After all Campion was actually was a bit of a progressive himself at Oxford. And Campion even goes so far as to smoke Turkish cigarettes and call his pretty wife "Piglet." Lindsay can't help but be impressed by a free thinker like that, can he? Instead there will be a clash of worldviews and Estella (a.k.a. Piglet) will discover there is an entire sensuous world she never knew.
This is a story about conflicting worldviews. In spite of considering himself very liberal, Anthony lives in a world of strict, church-dictated limits. Lindsay, his wife, and his three models live in a world of frequent nudity, open discussion of sex, promiscuity, and omni-present paintings and statues of female nudes that unnerves even the neighbors. But it is clear that the Campions are not prepared to survive in this hostile Australian world. There is a running gag about hostile animal attacks going on all around and the Campion's fear, though they themselves never meet anything more savage than the odd wallaroo. They seem to be followed by a snake, but his presence seems more metaphorical than real. Nature really seems toward them to be its most benevolent and beautiful, as if on its best behavior for guests.
Hugh Grant, does a terrific job of trying to seem free-thinking and yet being horribly inhibited. In the presence of nude models his worldly exterior gives way to flustered stuttering. Tara Fitzgerald of HEAR MY SONG initially matches here husbands disapproval of the sensuous lifestyle but slowly defrosts with time. There is a marvelous duality in her performance as she tries to appear straight-laced to her husband while exploring a side of herself that she has hidden from herself and others. Unfortunately Sam Neill has little to do in his performance but appeal worldly and in a way almost fatherly to the models he paints nude. He is almost the opposite of his character in THE PIANO.
SIRENS is often very funny and at the same time serves as a sort of down-under Monroe Doctrine saying "The is Australia--no Pat Robertsons are welcome." I give it a +2 on the -4 to +4 scale.
Mark R. Leeper att!mtgzfs3!leeper<EMAIL_ADDRESS>.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Next week on Tue 17 Nov @ 7pm, Peterborough United Foundation and UCP will be hosting a VIRTUAL OPEN EVENING for students who are interested in studying the BSc (Hons) Sport & Exercise Science as well as to train and represent PUFC.
Peterborough United Foundation and UCP are hosting a Virtual Open Evening on Tue 17 November @ 7pm for students who are interested in studying the BSc (Hons) Sport and Exercise Science as well as to train and represent Peterborough United.
Calling all UCP students and staff. Join us for the UCP CHARITY PUB QUIZ on Thur 8 October from 6.30-8pm. The winner of this online quiz will get £50 to donate to the charity of their choice. It's FREE to enter for teams of up to 5 people. To book visit https://www.ucp.ac.uk/charity-pub-quiz-2020/
To apply for a course just follow the three-step process!


Text
public class Text : Layer
Represents a Text layer in Sketch
-
Whether the text should wrap or stay on a single line
Declaration
Swift
public let wrapText: Bool
-
List of Text segments in left to right order as they appear in the Text container
Declaration
Swift
public let segments: [Segment]
-
Declaration
Swift
public required init?(json: [String : Any])
-
Undocumented
Declaration
Swift
override public func toJson() -> [String : Any]
-
A struct containing styling information about a string
See moreDeclaration
Swift
public struct Style : JSONDictEncodable
-
Container for representing
See moreStyles
that are shared within a documentDeclaration
Swift
public struct SharedStyle : JSONDictEncodable
-
Represents a styled segment of a string
See moreDeclaration
Swift
public struct Segment : JSONDictEncodable


Of versions and changes
March 1, 2015
The concept of version control is a daunting one at best. When we sit down to code everyday, we seek to add changes to our pre-existing code and thereby improve what we've written before or add new functions and features to what we have. This is why it is important for us to keep extremely detailed records of what we did, where in the code we did it, when we did it, and why. Additionally, if keeping track of these changes for one person's daily work is already a tall order, doing so for a group of people or a whole company full of people is much more complicated and exponentially harder. "Version Control" is the practice of trying to streamline this process and make everything more efficient and easier to organize for all of us.
In order to help us keep track of our changes, we have Git. Git is a program that resides inside of our local repositories. So long as they are connected to the original ones on GitHub, Git is constantly watching to see if we make changes to the files in our directories, if we create new directories, and if we create new files in them. Thanks to this, after we've made our multitude of changes, we can easily commit this change to our repository, push the changes to GitHub, and this can (if specified) become a new version. Thus, if in the future we need to backtrack our changes to regain stability or to undo mistakes in the code, the versions of our repositories are nicely kept and organized for us - all thanks to Git!
Finally, we store our code on GitHub. Why do we do this? In the current age of ubiquitous internet and multiple devices per capita, it would be silly if we had to manually copy and update every single change we make to our code on each one of our devices, whether it be the home PC, a work PC, or the laptops, phones, and tablets that go in between. A cloud-based solution for us to access our code anywhere we please is by far and away a much easier way to do so. Storing our code on GitHub is one such way to do this. The added bonus (or perhaps, the main purpose) of GitHub is also that many people can access the online repositories at once. It is also an extremely efficient way for groups of coders, whether they are coworkers or friends working on a hobby project, to synchronize and coordinate their efforts. Git and GitHub both are a godsend for us coders to deal with version control!


"ACHMETHA "(Ezra 6:2), called Ecbatana by classical writers, the capital of northern Media. Here was the palace which was the residence of the old Median monarchs, and of Cyrus and Cambyses. In the time of Ezra, the Persian kings resided usually at Susa of Babylon. But Cyrus held his court at Achmetha; and Ezra, writing a century after, correctly mentions the place where the decree of Cyrus was found.
"ACHMETHA "(Ezra 6:2), called Ecbatana by classical writers, the capital of northern Media. Here was the palace which was the residence of the old Median monarchs, and of Cyrus and Cambyses. In the time of Ezra, the Persian kings resided usually at Susa of Babylon. But Cyrus held his court at Achmetha; and Ezra, writing a century after, correctly mentions the place where the decree of Cyrus was found.


[gecode-users] Pair counting constraint
Сергей Солонец
ssolonets at gmail.com
Sat Jan 28 16:00:35 CET 2017
I have two IntVarArgs variables both of length of n, with domain from 0 to k
I need a constraint expression that counts unique pairs between these 2
arrays
f.e I want constraint count(a, b, {1, 2}, 3) to hold if there are 3 pairs
of values 1, 2 on the same index, what I do now is introducing a new
variable called classes
for (int i = 0; i < n; i++)
{
classes[i] = expr(*this, a[i] * k + b[i]);
}
where classes variable is different for different pairs, and after I apply
counting constraint on it, but I feel like there should be a better solution
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.gecode.org/pipermail/users/attachments/20170128/f5a6e6d7/attachment.html>
More information about the users
mailing list


Channel:
Datarate:
2Mbps
1Mbps
250Kbps
Connect Crazyflie
Press
X
(or
A
) on the gamepad you want to use


Bayelsa Airport will not be submerged – Dickson replies Oshiomhole
by Joseph OlaoluwaEarlier this week, National Chairman, All Progressives Congress (APC), Adams Oshiomhole threw jabs at the Bayelsa State Government, demanding accountability for the construction of the state airport runway project that gulped N100 billion.
The Details: In a conversation with the APC governorship aspirant in Bayelsa, Heineken Lokpobiri and some state governors on Thursday, the APC National Chairman said the airport was flooded.
Governor of Bayelsa State, Seriake Dickson in a swift response to the party stalwart, dismissed those statements, as he stressed that the cargo airport newly completed in the state was not flooded.
To prove his point, he called upon the press and took them on a tour around the airport and explained why operations were yet to commence at the newly constructed airport. He pointed out that the airport project was still being held back by regulatory agencies.
Giving an account of how the money was spent, Dickson explained that acquisition of land, clearing, sand filling and actual construction of the airport gulped N70 billion as opposed to N100 billion mentioned by the party stalwart.
[READ MORE: Okowa targets N100 million annual revenue via Asaba Airport concession]
“It is clear from this visit that former Governor Adams Oshiomole lied when he was quoted as saying that the airport runway is flooded. All the visitors confirmed that 3.5 km. the runway was high above flood level.
“So the question is: why is a fellow South-South person deliberately maligning another governor from the region? Is this the way to play politics, even with the development of the people?
This is the height of the flood in Bayelsa State, but as you can see, there is no flood here; we reclaimed these parcels of land before starting the construction.
“This airport has one of the best runways in this country; so we will not join Oshiomhole in playing politics with the fortune of our people,” Dickson said.
In a recent Nairametrics report, Skyway Aviation Handling Company Plc (SAHCO) signed a Memorandum of Understanding (MOU) with the Bayelsa State Government to be the official ground handling provider in the Bayelsa International Airport.
The Manager, Corporate Communications, SAHCO, Mrs Vanessa Uansohia, said the firm would offer services to both international and domestic airline operators. She stated that with manpower training and investments in state-of-the-art aviation ground handling equipment, among others, the company would exceed customers’ expectations.


There is a problem with your installation of Powerhouse. Please make sure that you are running Apache with the required plugins.
The following plugins are required by Powerhouse.
mod_php7
- PHP Hypertext Processor, >7.3.0mod_rewrite
- Apache Rewrite Module - preinstalled with Apache 2.4Please make sure that they are enabled before proceeding.


Dr. Beverly Crusher, MD
Specialty
Internal Medicine and Pediatrics
Location
Cleveland General Hospital
Insurance Accepted
Blue Cross, Cigna, and Shield
Languages
English and Spanish
Accepting New Patients
Yes
Contact and Locations
Monday, Wednesday, Friday
Cleveland General Hospital
4517 Washington Ave.
Manchester, Kentucky 39495
(455) 888-3884
Tuesday, Thursday
Corner Health Center
4517 Washington Ave.
Manchester, Kentucky 39495
(455) 888-3884


SLCOUNTRULE Counts the votings to make histogram $ Syntax $ - H = slcountvote(m, n, V, w, countrule) $ Arguments $ - m: The number of models to be voted for - n: The number of samples - V: The voting results - w: The weights of the samples - countrule: The rule of counting (summarizing the votings) $ Description $ - H = slcountvote(m, n, V, w, countrule) counts/summarizes the voting results using specified rule to build a histogram. There are m models, and the H would be an m x 1 column vector. The following rules are implemented. Please note that using different ways, the format of V will be different. \* \t Table. The Couting rules in slvote \h name & description 'nm' & (Nearest Model): the simplest way of voting. Each sample contributes 1 to the nearest model. V is an 1 x n row vector indicating the indices of the matched models for all samples. 'nmx' & (Extended Nearest Model): each sample contributes to the nearest model with a value indicating the confidence. V is an 2 x n matrix with the first row indicating the indices of the matched models, while the 2nd row indicates the confidence values. 'mmc' & (Multi-Model Count): each sample contributes to multiple models, the contribution to each model is 1. V is an m x n matrix or sparse matrix. The entry V(k,i) is non-zero when the i-th sample contributes to the k-th model. 'mms' & (Multi-Model Sum): each sample contributes to multiple models with real values. The voting on each model is summarized by summing the contribution values from all samples. V is an m x n matrix. 'mmns' & (Multi-Model Normalized Sum): each sample contributes to multiple models with real values. The voting on each model is summarized by summing the contribution values from all samples. However, in contrary to mms, the total contributions from a sample would be normalized to one. V is an m x n matrix. \* $ History $ - Created by Dahua Lin, on Sep 18, 2006
0001 function H = slcountvote(m, n, V, w, countrule) 0002 %SLCOUNTRULE Counts the votings to make histogram 0003 % 0004 % $ Syntax $ 0005 % - H = slcountvote(m, n, V, w, countrule) 0006 % 0007 % $ Arguments $ 0008 % - m: The number of models to be voted for 0009 % - n: The number of samples 0010 % - V: The voting results 0011 % - w: The weights of the samples 0012 % - countrule: The rule of counting (summarizing the votings) 0013 % 0014 % $ Description $ 0015 % - H = slcountvote(m, n, V, w, countrule) counts/summarizes the 0016 % voting results using specified rule to build a histogram. 0017 % There are m models, and the H would be an m x 1 column vector. 0018 % The following rules are implemented. Please note that using 0019 % different ways, the format of V will be different. 0020 % \* 0021 % \t Table. The Couting rules in slvote 0022 % \h name & description 0023 % 'nm' & (Nearest Model): the simplest way of voting. Each 0024 % sample contributes 1 to the nearest model. 0025 % V is an 1 x n row vector indicating the indices 0026 % of the matched models for all samples. 0027 % 'nmx' & (Extended Nearest Model): each sample contributes 0028 % to the nearest model with a value indicating the 0029 % confidence. 0030 % V is an 2 x n matrix with the first row indicating 0031 % the indices of the matched models, while the 2nd 0032 % row indicates the confidence values. 0033 % 'mmc' & (Multi-Model Count): each sample contributes to 0034 % multiple models, the contribution to each model 0035 % is 1. 0036 % V is an m x n matrix or sparse matrix. The entry 0037 % V(k,i) is non-zero when the i-th sample 0038 % contributes to the k-th model. 0039 % 'mms' & (Multi-Model Sum): each sample contributes to 0040 % multiple models with real values. The voting on 0041 % each model is summarized by summing the 0042 % contribution values from all samples. 0043 % V is an m x n matrix. 0044 % 'mmns' & (Multi-Model Normalized Sum): each sample 0045 % contributes to multiple models with real values. 0046 % The voting on each model is summarized by summing 0047 % the contribution values from all samples. 0048 % However, in contrary to mms, the total 0049 % contributions from a sample would be normalized 0050 % to one. V is an m x n matrix. 0051 % \* 0052 % 0053 % $ History $ 0054 % - Created by Dahua Lin, on Sep 18, 2006 0055 % 0056 0057 %% parse and verify input arguments 0058 0059 if nargin < 5 0060 raise_lackinput('slcountvote', 5); 0061 end 0062 0063 if ~isempty(w) 0064 if ~isequal(size(w), [1 n]) 0065 error('sltoolbox:sizmismatch', ... 0066 'The weights size is not consistent with that of sample number'); 0067 end 0068 end 0069 0070 % count voting and make histogram 0071 0072 switch countrule 0073 case 'nm' 0074 H = countvote_nm(V, w, m, n); 0075 case 'nmx' 0076 H = countvote_nmx(V, w, m, n); 0077 case 'mmc' 0078 H = countvote_mmc(V, w, m, n); 0079 case 'mms' 0080 H = countvote_mms(V, w, m, n); 0081 case 'mmns' 0082 H = countvote_mmns(V, w, m, n); 0083 otherwise 0084 error('sltoolbox:invalidarg', ... 0085 'Invalid counting rule: %s', countrule); 0086 end 0087 0088 0089 %% Vote-Count functions 0090 0091 function H = countvote_nm(V, w, m, n) 0092 0093 check_Vsize('Nearest Model', V, 1, n); 0094 0095 if isempty(w) 0096 H = zeros(m, 1); 0097 [nums, u] = slcount(sort(V)); 0098 H(u) = nums; 0099 else 0100 H = sllabeledsum(w, V, 1:m)'; 0101 end 0102 0103 0104 function H = countvote_nmx(V, w, m, n) 0105 0106 check_Vsize('Extended Nearest Model', V, 2, n); 0107 0108 H = sllabeledsum(V(2,:), V(1,:), 1:m, w); 0109 0110 0111 function H = countvote_mmc(V, w, m, n) 0112 0113 check_Vsize('Multi-Model Count', V, m, n); 0114 0115 if isempty(w) 0116 H = sum(V ~= 0, 2); 0117 else 0118 H = (V ~= 0) * w'; 0119 end 0120 if issparse(H) 0121 H = full(H); 0122 end 0123 0124 0125 function H = countvote_mms(V, w, m, n) 0126 0127 check_Vsize('Multi-Model Sum', V, m, n); 0128 0129 if isempty(w) 0130 H = sum(V, 2); 0131 else 0132 H = V * w'; 0133 end 0134 if issparse(H) 0135 H = full(H); 0136 end 0137 0138 0139 function H = countvote_mmns(V, w, m, n) 0140 0141 check_Vsize('Multi-Model Normalized Sum', V, m, n); 0142 0143 ss = sum(V, 1); 0144 if issparse(ss) 0145 ss = full(ss); 0146 end 0147 ss(ss < eps) = eps; 0148 0149 if isempty(w) 0150 w = 1 ./ ss; 0151 else 0152 w = w ./ ss; 0153 end 0154 0155 H = V * w'; 0156 if issparse(H) 0157 H = full(H); 0158 end 0159 0160 0161 %% Auxiliary functions 0162 0163 function check_Vsize(rulename, V, d1, d2) 0164 0165 if ~isequal(size(V), [d1, d2]) 0166 error('sltoolbox:invalidarg', ... 0167 'V should be an %d x %d matrix for the counting rule %s', ... 0168 d1, d2, rulename); 0169 end 0170


A tab provides the affordance for displaying grouped content. A tab label succinctly describes the tab’s associated grouping of content.
Fixed tabs have equal width, calculated either as the view width divided by the number of tabs, or based on the widest tab label. To navigate between fixed tabs, touch the tab or swipe the content area left or right.
To navigate between scrollable tabs, touch the tab or swipe the content area left or right. To scroll the tabs without navigating, swipe the tabs left or right.


Introduction to Applied Data Analysis and Machine Learning¶
During the last two decades there has been a swift and amazing development of Machine Learning techniques and algorithms that impact many areas in not only Science and Technology but also the Humanities, Social Sciences, Medicine, Law, indeed, almost all possible disciplines. The applications are incredibly many, from self-driving cars to solving high-dimensional differential equations or complicated quantum mechanical many-body problems. Machine Learning is perceived by many as one of the main disruptive techniques nowadays.
Statistics, Data science and Machine Learning form important fields of research in modern science. They describe how to learn and make predictions from data, as well as allowing us to extract important correlations about physical process and the underlying laws of motion in large data sets. The latter, big data sets, appear frequently in essentially all disciplines, from the traditional Science, Technology, Mathematics and Engineering fields to Life Science, Law, education research, the Humanities and the Social Sciences.
It has become more and more common to see research projects on big data in for example the Social Sciences where extracting patterns from complicated survey data is one of many research directions. Having a solid grasp of data analysis and machine learning is thus becoming central to scientific computing in many fields, and competences and skills within the fields of machine learning and scientific computing are nowadays strongly requested by many potential employers. The latter cannot be overstated, familiarity with machine learning has almost become a prerequisite for many of the most exciting employment opportunities, whether they are in bioinformatics, life science, physics or finance, in the private or the public sector. This author has had several students or met students who have been hired recently based on their skills and competences in scientific computing and data science, often with marginal knowledge of machine learning.
Machine learning is a subfield of computer science, and is closely related to computational statistics. It evolved from the study of pattern recognition in artificial intelligence (AI) research, and has made contributions to AI tasks like computer vision, natural language processing and speech recognition. Many of the methods we will study are also strongly rooted in basic mathematics and physics research.
Ideally, machine learning represents the science of giving computers the ability to learn without being explicitly programmed. The idea is that there exist generic algorithms which can be used to find patterns in a broad class of data sets without having to write code specifically for each problem. The algorithm will build its own logic based on the data. You should however always keep in mind that machines and algorithms are to a large extent developed by humans. The insights and knowledge we have about a specific system, play a central role when we develop a specific machine learning algorithm.
Machine learning is an extremely rich field, in spite of its young age. The increases we have seen during the last three decades in computational capabilities have been followed by developments of methods and techniques for analyzing and handling large date sets, relying heavily on statistics, computer science and mathematics. The field is rather new and developing rapidly. Popular software packages written in Python for machine learning like Scikit-learn, Tensorflow, PyTorch and Keras, all freely available at their respective GitHub sites, encompass communities of developers in the thousands or more. And the number of code developers and contributors keeps increasing. Not all the algorithms and methods can be given a rigorous mathematical justification, opening up thereby large rooms for experimenting and trial and error and thereby exciting new developments. However, a solid command of linear algebra, multivariate theory, probability theory, statistical data analysis, understanding errors and Monte Carlo methods are central elements in a proper understanding of many of algorithms and methods we will discuss.
Learning outcomes¶
These sets of lectures aim at giving you an overview of central aspects of statistical data analysis as well as some of the central algorithms used in machine learning. We will introduce a variety of central algorithms and methods essential for studies of data analysis and machine learning.
Hands-on projects and experimenting with data and algorithms plays a central role in these lectures, and our hope is, through the various projects and exercises, to expose you to fundamental research problems in these fields, with the aim to reproduce state of the art scientific results. You will learn to develop and structure codes for studying these systems, get acquainted with computing facilities and learn to handle large scientific projects. A good scientific and ethical conduct is emphasized throughout the course. More specifically, you will
Learn about basic data analysis, Bayesian statistics, Monte Carlo methods, data optimization and machine learning;
Be capable of extending the acquired knowledge to other systems and cases;
Have an understanding of central algorithms used in data analysis and machine learning;
Gain knowledge of central aspects of Monte Carlo methods, Markov chains, Gibbs samplers and their possible applications, from numerical integration to simulation of stock markets;
Understand methods for regression and classification;
Learn about neural network, genetic algorithms and Boltzmann machines;
Work on numerical projects to illustrate the theory. The projects play a central role and you are expected to know modern programming languages like Python or C++, in addition to a basic knowledge of linear algebra (typically taught during the first one or two years of undergraduate studies).
There are several topics we will cover here, spanning from statistical data analysis and its basic concepts such as expectation values, variance, covariance, correlation functions and errors, via well-known probability distribution functions like the uniform distribution, the binomial distribution, the Poisson distribution and simple and multivariate normal distributions to central elements of Bayesian statistics and modeling. We will also remind the reader about central elements from linear algebra and standard methods based on linear algebra used to optimize (minimize) functions (the family of gradient descent methods) and the Singular-value decomposition and least square methods for parameterizing data.
We will also cover Monte Carlo methods, Markov chains, well-known algorithms for sampling stochastic events like the Metropolis-Hastings and Gibbs sampling methods. An important aspect of all our calculations is a proper estimation of errors. Here we will also discuss famous resampling techniques like the blocking, the bootstrapping and the jackknife methods and the infamous bias-variance tradeoff.
The second part of the material covers several algorithms used in machine learning.
Machine Learning, a small (and probably biased) introduction¶
Ideally, machine learning represents the science of giving computers the ability to learn without being explicitly programmed. The idea is that there exist generic algorithms which can be used to find patterns in a broad class of data sets without having to write code specifically for each problem. The algorithm will build its own logic based on the data. You should however always keep in mind that machines and algorithms are to a large extent developed by humans. The insights and knowledge we have about a specific system, play a central role when we develop a specific machine learning algorithm.
Machine learning is an extremely rich field, in spite of its young age. The increases we have seen during the last decades in computational capabilities have been followed by developments of methods and techniques for analyzing and handling large date sets, relying heavily on statistics, computer science and mathematics. The field is rather new and developing rapidly. Popular software libraries written in Python for machine learning like Scikit-learn, Tensorflow, PyTorch and Keras, all freely available at their respective GitHub sites, encompass communities of developers in the thousands or more. And the number of code developers and contributors keeps increasing.
Not all the algorithms and methods can be given a rigorous mathematical justification (for example decision trees and random forests), opening up thereby large rooms for experimenting and trial and error and thereby exciting new developments. However, a solid command of linear algebra, multivariate theory, probability theory, statistical data analysis, understanding errors and Monte Carlo methods are central elements in a proper understanding of many of the algorithms and methods we will discuss.
The approaches to machine learning are many, but are often split into two main categories. In supervised learning we know the answer to a problem, and let the computer deduce the logic behind it. On the other hand, unsupervised learning is a method for finding patterns and relationship in data sets without any prior knowledge of the system. Some authours also operate with a third category, namely reinforcement learning. This is a paradigm of learning inspired by behavioral psychology, where learning is achieved by trial-and-error, solely from rewards and punishment.
Another way to categorize machine learning tasks is to consider the desired output of a system. Some of the most common tasks are:
Classification: Outputs are divided into two or more classes. The goal is to produce a model that assigns inputs into one of these classes. An example is to identify digits based on pictures of hand-written ones. Classification is often supervised learning.
Regression: Finding a functional relationship between an input data set and a reference data set. The goal is to construct a function that maps input data to continuous output values.
Clustering: Data are divided into groups with certain common traits, without knowing the different groups beforehand. It is thus a form of unsupervised learning.
The methods we cover have three main topics in common, irrespective of whether we deal with supervised or unsupervised learning.
The first ingredient is normally our data set (which can be subdivided into training, validation and test data). Many find the most difficult part of using Machine Learning to be the set up of your data in a meaningful way.
The second item is a model which is normally a function of some parameters. The model reflects our knowledge of the system (or lack thereof). As an example, if we know that our data show a behavior similar to what would be predicted by a polynomial, fitting our data to a polynomial of some degree would then determin our model.
The last ingredient is a so-called cost/loss function (or error function) which allows us to present an estimate on how good our model is in reproducing the data it is supposed to train.
At the heart of basically all Machine Learning algorithms we will encounter so-called minimization or optimization algorithms. A large family of such methods are so-called gradient methods.
A Frequentist approach to data analysis¶
When you hear phrases like predictions and estimations and correlations and causations, what do you think of? May be you think of the difference between classifying new data points and generating new data points. Or perhaps you consider that correlations represent some kind of symmetric statements like if \(A\) is correlated with \(B\), then \(B\) is correlated with \(A\). Causation on the other hand is directional, that is if \(A\) causes \(B\), \(B\) does not necessarily cause \(A\).
These concepts are in some sense the difference between machine learning and statistics. In machine learning and prediction based tasks, we are often interested in developing algorithms that are capable of learning patterns from given data in an automated fashion, and then using these learned patterns to make predictions or assessments of newly given data. In many cases, our primary concern is the quality of the predictions or assessments, and we are less concerned about the underlying patterns that were learned in order to make these predictions.
In machine learning we normally use a so-called frequentist approach, where the aim is to make predictions and find correlations. We focus less on for example extracting a probability distribution function (PDF). The PDF can be used in turn to make estimations and find causations such as given \(A\) what is the likelihood of finding \(B\).
What is a good model?¶
In science and engineering we often end up in situations where we want to infer (or learn) a quantitative model \(M\) for a given set of sample points \(\boldsymbol{X} \in [x_1, x_2,\dots x_N]\).
As we will see repeatedely in these lectures, we could try to fit these data points to a model given by a straight line, or if we wish to be more sophisticated to a more complex function.
The reason for inferring such a model is that it serves many useful purposes. On the one hand, the model can reveal information encoded in the data or underlying mechanisms from which the data were generated. For instance, we could discover important corelations that relate interesting physics interpretations.
In addition, it can simplify the representation of the given data set and help us in making predictions about future data samples.
A first important consideration to keep in mind is that inferring the correct model for a given data set is an elusive, if not impossible, task. The fundamental difficulty is that if we are not specific about what we mean by a correct model, there could easily be many different models that fit the given data set equally well.
The central question is this: what leads us to say that a model is correct or optimal for a given data set? To make the model inference problem well posed, i.e., to guarantee that there is a unique optimal model for the given data, we need to impose additional assumptions or restrictions on the class of models considered. To this end, we should not be looking for just any model that can describe the data. Instead, we should look for a model \(M\) that is the best among a restricted class of models. In addition, to make the model inference problem computationally tractable, we need to specify how restricted the class of models needs to be. A common strategy is to start with the simplest possible class of models that is just necessary to describe the data or solve the problem at hand. More precisely, the model class should be rich enough to contain at least one model that can fit the data to a desired accuracy and yet be restricted enough that it is relatively simple to find the best model for the given data.
Thus, the most popular strategy is to start from the simplest class of models and increase the complexity of the models only when the simpler models become inadequate. For instance, if we work with a regression problem to fit a set of sample points, one may first try the simplest class of models, namely linear models, followed obviously by more complex models.
How to evaluate which model fits best the data is something we will come back to over and over again in these set of lectures.
Choice of Programming Language¶
Python plays nowadays a central role in the development of machine learning techniques and tools for data analysis. In particular, seen the wealth of machine learning and data analysis libraries written in Python, easy to use libraries with immediate visualization(and not the least impressive galleries of existing examples), the popularity of the Jupyter notebook framework with the possibility to run R codes or compiled programs written in C++, and much more made our choice of programming language for this series of lectures easy. However, since the focus here is not only on using existing Python libraries such as Scikit-Learn, Tensorflow and Pytorch, but also on developing your own algorithms and codes, we will as far as possible present many of these algorithms either as a Python codes or C++ or Fortran (or other languages) codes.
Data handling, machine learning and ethical aspects¶
In most of the cases we will study, we will either generate the data to analyze ourselves (both for supervised learning and unsupervised learning) or we will recur again and again to data present in say Scikit-Learn or Tensorflow. Many of the examples we end up dealing with are from a privacy and data protection point of view, rather inoccuous and boring results of numerical calculations. However, this does not hinder us from developing a sound ethical attitude to the data we use, how we analyze the data and how we handle the data.
The most immediate and simplest possible ethical aspects deal with our approach to the scientific process. Nowadays, with version control software like Git and various online repositories like Github, Gitlab etc, we can easily make our codes and data sets we have used, freely and easily accessible to a wider community. This helps us almost automagically in making our science reproducible. The large open-source development communities involved in say Scikit-Learn, Tensorflow, PyTorch and Keras, are all excellent examples of this. The codes can be tested and improved upon continuosly, helping thereby our scientific community at large in developing data analysis and machine learning tools. It is much easier today to gain traction and acceptance for making your science reproducible. From a societal stand, this is an important element since many of the developers are employees of large public institutions like universities and research labs. Our fellow taxpayers do deserve to get something back for their bucks.
However, this more mechanical aspect of the ethics of science (in particular the reproducibility of scientific results) is something which is obvious and everybody should do so as part of the dialectics of science. The fact that many scientists are not willing to share their codes or data is detrimental to the scientific discourse.
Before we proceed, we should add a disclaimer. Even though we may dream of computers developing some kind of higher learning capabilities, at the end (even if the artificial intelligence community keeps touting our ears full of fancy futuristic avenues), it is we, yes you reading these lines, who end up constructing and instructing, via various algorithms, the machine learning approaches. Self-driving cars for example, rely on sofisticated programs which take into account all possible situations a car can encounter. In addition, extensive usage of training data from GPS information, maps etc, are typically fed into the software for self-driving cars. Adding to this various sensors and cameras that feed information to the programs, there are zillions of ethical issues which arise from this.
For self-driving cars, where basically many of the standard machine learning algorithms discussed here enter into the codes, at a certain stage we have to make choices. Yes, we , the lads and lasses who wrote a program for a specific brand of a self-driving car. As an example, all carmakers have as their utmost priority the security of the driver and the accompanying passengers. A famous European carmaker, which is one of the leaders in the market of self-driving cars, had if statements of the following type: suppose there are two obstacles in front of you and you cannot avoid to collide with one of them. One of the obstacles is a monstertruck while the other one is a kindergarten class trying to cross the road. The self-driving car algo would then opt for the hitting the small folks instead of the monstertruck, since the likelihood of surving a collision with our future citizens, is much higher.
This leads to serious ethical aspects. Why should we opt for such an option? Who decides and who is entitled to make such choices? Keep in mind that many of the algorithms you will encounter in this series of lectures or hear about later, are indeed based on simple programming instructions. And you are very likely to be one of the people who may end up writing such a code. Thus, developing a sound ethical attitude to what we do, an approach well beyond the simple mechanistic one of making our science available and reproducible, is much needed. The example of the self-driving cars is just one of infinitely many cases where we have to make choices. When you analyze data on economic inequalities, who guarantees that you are not weighting some data in a particular way, perhaps because you dearly want a specific conclusion which may support your political views? Or what about the recent claims that a famous IT company like Apple has a sexist bias on the their recently launched credit card?
We do not have the answers here, nor will we venture into a deeper discussions of these aspects, but we want you think over these topics in a more overarching way. A statistical data analysis with its dry numbers and graphs meant to guide the eye, does not necessarily reflect the truth, whatever that is. As a scientist, and after a university education, you are supposedly a better citizen, with an improved critical view and understanding of the scientific method, and perhaps some deeper understanding of the ethics of science at large. Use these insights. Be a critical citizen. You owe it to our society.