Mantissa includes a way to report simple string data to external processes roughly in real time. This system is used internally to expose certain statistics which may be relevant for performance and optimization investigations. Applications can contribute similar statistics to be reported in the same way. Custom observers for this information can also be written.
This document will explain how to report such information. It will also explain how to write a client which can be connected to a Mantissa server to receive this information.
Readers should familiarize themselves with the following concepts in order to understand all sections of this document:
twisted.python.log.msg
is used to report events which
Mantissa will publish to clients. The only requirement is that the
"interface"
key have a value of axiom.iaxiom.IStatEvent
. For example, a blogging
application might want to report each new blog post. To do this, in the
blog post handling code, this code would be included:
from twisted.python.log import msg from axiom.iaxiom import IStatEvent msg(interface=IStatEvent, new_blog_post=1)
It is left up to observers how this data is interpreted. Almost any keys
or values are allowed. The primary restriction on keys is that they are
not already used by the logging system itself. For example,
"message"
is reserved for the value of the first positional
argument to twisted.python.log.msg
, so a stat event cannot
use it. Values are restricted to objects which can be represented as
unicode strings.
Observation of reported statistics is done using an AMP client. The
client connects to and authenticates with a Mantissa server. The server
must have an AMP port configured and the user must have the xmantissa.stats.RemoteStatsCollectorFactory
powerup
installed in order to observe stats. The Mantissa administrative
offering (not installed by default) provides this powerup.
A stats route is made accessible via the
u"http://divmod.org/ns/mantissa-stats"
protocol. Once the
route is set up, the server will send StatUpdate
commands to
the client until it disconnects. The StatUpdate
command has
one parameter, data
. The value for the parameter is an
encoded list of AMP boxes. Each box has two keys, key
and
value
, each of which is associated with one part of keyword
argument to the corresponding msg
call. Additionally, there
is an element including a timestamp for the event. For example, the
msg
call in the blog post example above would results in
[{u'key': u'time', u'value': u'1224183617.916481'},
{u'key': u'new_blog_post', u'value': u'1'}]
. The ordering of the
list is arbitrary.


{% extends "base.html" %} {% block site_menu %}{% with section='desktops' %}{% include "partials/site_menu.html" %}{% endwith %}{% endblock %}


Enter a 52-card deal using only these pips:
Clear entries
NS make 7 test deal
Everyone makes 3N test deal
Part-score test deal
Rotate the hands clockwise
♠
♥
♦
♣
♠
♥
♦
♣
♠
♥
♦
♣
♠
♥
♦
♣
Double-dummy it!
♣
♦
♥
♠
NT
N
E
S
W


Get auto-corrected and enhanced track metadata for SomaFM radio stations in real-time.
Note: This service is neither directly or indirectly affiliated with SomaFM or Last.fm. The source code for this service is freely available on GitHub.
Connected clients: <%- connectedClients %>
The service currently provides data for the following stations:
<% var i = 0; _.forEach(stations, function (station) { if (i !== 0) { %>, <% } %><%- station %><% i++; }); %>Load the socket.io client library. You should probably do this somewhere in the <head>
. Load it from CDNJS or from where ever you prefer.
<script src="//cdnjs.cloudflare.com/ajax/libs/socket.io/0.9.16/socket.io.min.js"></script>
A matching client library is also provided by SomaScrobbler. But using a real CDN is the preferred method.
<script src="<%- proxyURL %>/socket.io/socket.io.js"></script>
var socket = io.connect('<%- proxyURL %>');
Track metadata is provided by the track
event.
socket.on('track', function (track) {
console.log(track);
});
Here's what a track object might look like:
{
stationId: 'secretagent',
time:<PHONE_NUMBER>000,
artist: 'James Clarke',
title: 'The Free Life',
album: 'Music For TV Dinners: The \'60s',
autocorrected: true,
trackCorrected: false,
artistCorrected: false,
albumCorrected: true,
trackMBID: null,
artistMBID: null,
albumMBID: null,
duration: '130000',
durationEstimated: false,
original: {
artist: 'James Clarke',
title: 'The Free Life',
album: 'Music For T.V. Dinners-The 60\'s'
}
}
stationId
is the SomaFM station ID. The one used in the URLs, e.g. "secretagent" for "Secret Agent".time
is the UTC unix offset in milliseconds.title
, artist
and album
contain the potentially auto-corrected track title, artist name and album title.autocorrected
will be true if any data has been auto-corrected. trackCorrected
, artistCorrected
and albumCorrected
accordingly.original
contains the uncorrected metadata from SomaFM if the data has been auto-corrected. Otherwise it will be omitted.trackMBID
, artistMBID
and albumMBID
contain the MusicBrainz ID. They often aren't available.duration
is the duration of the track in milliseconds. This is either provided by Last.fm or based on the average duration of all previous tracks. If the duration has been estimated, durationEstimated
will be true.To receive track metadata you need to subscribe to each station using the station ID by emitting a "subscribe" event.
socket.emit('subscribe', 'groovesalad', function (data) {
if (data.subscribed) { console.log('Subscribed!!'); }
});
You will stop receiving updates if you emit an "unsubscribe" event.
socket.emit('unsubscribe', 'groovesalad', function (data) {
if (data.unsubscribed) { console.log('Unsubscribed!!'); }
});
Here's a complete example. Want to see this in action? Scroll down to the demo.
var socket = io.connect('<%- proxyURL %>');
var tbody = document.querySelector('#demo tbody');
socket.on('connect', function () {
[ 'groovesalad', 'secretagent',
'doomed', 'u80s', 'bagel'
].forEach(function (stationId) {
socket.emit('subscribe', stationId);
});
});
socket.on('track', function (track) {
var tr = document.createElement('tr'),
tdStation = document.createElement('td'),
tdTime = document.createElement('td'),
tdArtist = document.createElement('td'),
tdTrack = document.createElement('td'),
d = new Date();
d.setTime(track.time);
tdStation.textContent = track.stationId;
tdTime.textContent = d;
tdArtist.textContent = track.artist;
tdTrack.textContent = track.title;
tr.appendChild(tdStation);
tr.appendChild(tdTime);
tr.appendChild(tdArtist);
tr.appendChild(tdTrack);
tbody.insertBefore(tr, tbody.childNodes[0]);
});
| Station | Time | Artist | Track |
|---|


JavaScript adds interactivity to your Web documents. By means of Interactive maps, side scrolling sideshows, animations and many more methods.
An analogy I can think of is to think of it as a room in your house. Html provides the foundation. The walls, the roof and the floor. CSS makes it look pretty. It’s the paint/wallpaper. It’s the tiling hte carpet and wall art. JavaScript rings in everything that's interactable . the cupboards, the TV, the Couch and anything else you interact with in the room.
Code is read from top to bottom. Exactly like a recipe. An example of flow control and looping would be baking a cake.
The process would be:
Dom stands for Document Object Model. It is considered the glue that Holds HTML and CSS together. The DOM has 2 main features Objects which are what we can use to manipulate the webpage. Nodes which make up every single thing the document contains. Ranging from Arrays to headers.
Arrays are a collection of things that each have their own indexing number. A function can call upon the entire Array or each different thing within the Array via the associated indexing number. Whereas objects have keys with a property assigned to it. The properties assigned to a key can also be an Array.
A Function is a piece of code that can be used to automate specific tasks. Depending on what conditions and inputs have been set.


# Hash Tables
A hash table is a reasonably simple data structure for implementing associative arrays -
similar to a usual list or array, in that it holds a certain quantity of elements, but in an associative
each element, or key can be assigned to its own value/s. A useful feature of hash tables is that
search efficiency is O(1) - constant time.
If a hash table were to be taken apart, it would be broken into two pieces: the array, and the hash function.
The array is the obvious part - the structure where searchable data is stored - and the hash function is what
enables values to have indexes assigned to them, that correspond with a value in the array of the same index.
Perhaps the best way to illustrate a hash table is through an actual, visual table:
myHashTable |
| Keys (Array) |
Values (Hash Function) |
| 0 |
"good" |
| 1 |
"morning" |
| 2 |
"friend" |
# Accessing Individual Elements
Of course a hash table would be of little use if specific keys and values could not be individually accessed
and manipulated, so all good implementations will support such a routine.
In myHashTable
, we have three keys, three values, three rows - the length of the table is 3.
Bear in mind that most of the time in computer science and programming, counting starts at 0, so the last element
of the table is at index 2, not index 3.
Here's a short example in Python that demonstrates declaration of, and individual
element access in, a hash table:
myHashTable = {
0: "good",
1: "morning",
2: "friend",
}
print myHashTable[1] # ==> "morning"
myHashTable[2] = "enemy"
print myHashTable[2] # ==> "enemy"
(As a side note, hash tables in Python are referred to as 'dictionaries'
- they work just like a dictionary book, with words (keys) and definitions (values))
Returning to the fact that hash tables search in constant time, here's an analogy to explain how:
Spanner & Co., a leading spanner manufacturer, have a collection of data relating to each different kind of
spanner they produce, and how many of that type they have sold. Being a popular brand, with many kinds of spanners,
it would take forever and a day to browse through the entire collection, to see the sell-count of one particular kind.
So the software engineers at Spanner & Co. built a software using a hash table - enter the name of a spanner, and
out comes the sell-count! Rather than iterating through each kind of spanner until the specified kind is reached, the
program just jumps straight to the one that is asked for:
>>> Spanner Kind: TurboWrench21K
Sell-count: 224
# Non-Integral Hash Table Keys
You've probably realised that with only integers as the keys for a hash table, it works exactly like an array -
rendering it useless. This introduces the feature that sets hash tables apart from arrays - the keys don't have to be
integers. They can be characters, strings (like the name of a spanner), booleans, or anything else, in fact.
Here's a modified version of the myHashTable
table shown previously:
secondTable |
| Keys (Array) |
Values (Hash Function) |
| "name" |
"Jenkins" |
| "age" |
38 |
| "employed" |
True |
Similarly to how values in a table were accessed in myHashTable
, we could access values in
secondTable
like this:
print secondTable["age"] # ==> 38
secondTable["employed"] = False
print secondTable["employed"] # ==> False
# Hash Table Usage
Finally, it would be good to see usage of a hash table in a program. For this, I've written a basic implementation
of the Spanner & Co. program, described above.
Remember, of course, that in this circumstance the code of the program is more important than the program itself.


public interface Grid2D
extends java.io.Serializable
If you're using the Grid to define a toroidal (wrap-around) world, you can use the tx and ty methods to simplify the math for you. For example, to increment in the x direction, including wrap-around, you can do: x = tx(x+1).
If you're sure that the values you'd pass into the toroidal functions would not wander off more than a grid dimension in either direction (height, width), you can use the slightly faster toroidal functions stx and sty instead. For example, to increment in the x direction, including wrap-around, you can do: x = stx(x+1). See the documentation on these functions for when they're appropriate to use. Under most common situations, they're okay.
In HotSpot 1.4.1, stx, and sty are inlined.
The rules moving from a hex location (at CENTER) to another one are as follows:
UP x UPLEFT y - 1 UPRIGHT x - 1 x + 1 ((x % 2) == 0) ? y - 1 : y CENTER ((x % 2) == 0) ? y - 1 : y x DOWNLEFT y DOWNRIGHT x - 1 x + 1 ((x % 2) == 0) ? y : y + 1 DOWN ((x % 2) == 0) ? y : y + 1 x y + 1NOTE: (x % 2 == 0), that is, "x is even", may be written instead in this faster way: ((x & 1) == 0)
Because the math is a little hairy, we've provided the math for the UPLEFT, UPRIGHT, DOWNLEFT, and DOWNRIGHT directions for you. For example, the UPLEFT location from [x,y] is at [ulx(x,y) , uly(x,y)]. Additionally, the toroidal methods can be used in conjunction with the hex methods to implement a toroidal hex grid. Be sure to To use a toroidal hex grid properly, you must ensure that height of the grid is an even number. For example, the toroidal UPLEFT X location is at tx(ulx(x,y)) and the UPLEFT Y location is at ty(uly(x,y)). Similarly, you can use stx and sty.
While this interface defines various methods common to many grids, you should endeavor not to call these grids casted into this interface: it's slow.
How do you get around such a beast? Piece of cake! Well, to go to your right or left neighbor, you just add or subtract the X value. To go to your up or down neighbor, all you do is add or subtract the Y value. All you need to know is if your triangle has an edge on the top (so you can go up) or an edge on the bottom (so you can go down). The functions TRB (triangle with horizontal edge on 'bottom') and TRT (triangle with horizontal edge on 'top') will tell you this.
Like the others, the triangular grid can also be used in toroidal fashion, and the toroidal functions should work properly with it. To use a toroidal triangular grid, you should ensure that your grid's length and width are both even numbers.
We'll provide a distance-measure function for triangular grids just as soon as we figure out what the heck one looks like. :-)
| Modifier and Type | Field and Description |
|---|---|
static int |
ALL
"All" measurement rule for raidal neighborhood lookup.
|
static int |
ANY
"Any" measurement rule for raidal neighborhood lookup.
|
static int |
ANY_SIZE
Pass this into buildMap to indicate that it should make a map of any size it likes.
|
static int |
BOUNDED
Bounded Mode for neighborhood lookup.
|
static int |
CENTER
Center measurement rule for raidal neighborhood lookup.
|
static int |
TOROIDAL
Bounded Mode for toroidal lookup.
|
static int |
UNBOUNDED
Bounded Mode for neighborhood lookup.
|
| Modifier and Type | Method and Description |
|---|---|
java.util.Map |
buildMap(int size)
Creates a map of the provided size (or any size it likes if ANY_SIZE is passed in).
|
java.util.Map |
buildMap(java.util.Map other)
Creates a Map which is a copy of another.
|
int |
dlx(int x,
int y)
Hex downleft x.
|
int |
dly(int x,
int y)
Hex downleft y.
|
int |
downx(int x,
int y)
Hex down x.
|
int |
downy(int x,
int y)
Hex down y.
|
int |
drx(int x,
int y)
Hex downright x.
|
int |
dry(int x,
int y)
Hex downright y.
|
int |
getHeight()
Returns the width of the field.
|
void |
getHexagonalLocations(int x,
int y,
int dist,
int mode,
boolean includeOrigin,
IntBag xPos,
IntBag yPos)
Gets all neighbors located within the hexagon centered at (X,Y) and 2*dist+1 cells from point to opposite point
inclusive.
|
void |
getMooreLocations(int x,
int y,
int dist,
int mode,
boolean includeOrigin,
IntBag xPos,
IntBag yPos)
Gets all neighbors of a location that satisfy max( abs(x-X) , abs(y-Y) ) <= dist.
|
void |
getNeighborsHamiltonianDistance(int x,
int y,
int dist,
boolean toroidal,
IntBag xPos,
IntBag yPos)
Deprecated.
|
void |
getNeighborsHexagonalDistance(int x,
int y,
int dist,
boolean toroidal,
IntBag xPos,
IntBag yPos)
Deprecated.
|
void |
getNeighborsMaxDistance(int x,
int y,
int dist,
boolean toroidal,
IntBag xPos,
IntBag yPos)
Deprecated.
|
void |
getRadialLocations(int x,
int y,
double dist,
int mode,
boolean includeOrigin,
IntBag xPos,
IntBag yPos)
Gets all neighbors overlapping with a circular region centered at (X,Y) and with a radius of dist.
|
void |
getRadialLocations(int x,
int y,
double dist,
int mode,
boolean includeOrigin,
int measurementRule,
boolean closed,
IntBag xPos,
IntBag yPos)
Gets all neighbors overlapping with a circular region centered at (X,Y) and with a radius of dist.
|
void |
getVonNeumannLocations(int x,
int y,
int dist,
int mode,
boolean includeOrigin,
IntBag xPos,
IntBag yPos)
Gets all neighbors of a location that satisfy abs(x-X) + abs(y-Y) <= dist.
|
int |
getWidth()
Returns the width of the field.
|
int |
stx(int x)
Simple [and fast] toroidal x.
|
int |
sty(int y)
Simple [and fast] toroidal y.
|
boolean |
trb(int x,
int y)
Horizontal edge is on the bottom for triangle.
|
boolean |
trt(int x,
int y)
Horizontal edge is on the top for triangle.
|
int |
tx(int x)
Toroidal x.
|
int |
ty(int y)
Toroidal y.
|
int |
ulx(int x,
int y)
Hex upleft x.
|
int |
uly(int x,
int y)
Hex upleft y.
|
int |
upx(int x,
int y)
Hex up x.
|
int |
upy(int x,
int y)
Hex up y.
|
int |
urx(int x,
int y)
Hex upright x.
|
int |
ury(int x,
int y)
Hex upright y.
|
static final int BOUNDED
static final int UNBOUNDED
static final int TOROIDAL
static final int CENTER
static final int ALL
static final int ANY
static final int ANY_SIZE
int getWidth()
int getHeight()
int tx(int x)
int ty(int y)
int stx(int x)
int sty(int y)
int ulx(int x, int y)
int uly(int x, int y)
int urx(int x, int y)
int ury(int x, int y)
int dlx(int x, int y)
int dly(int x, int y)
int drx(int x, int y)
int dry(int x, int y)
int upx(int x, int y)
int upy(int x, int y)
int downx(int x, int y)
int downy(int x, int y)
boolean trb(int x, int y)
boolean trt(int x, int y)
void getNeighborsMaxDistance(int x, int y, int dist, boolean toroidal, IntBag xPos, IntBag yPos)
This function may only run in two modes: toroidal or bounded. Unbounded lookup is not permitted, and so this function is deprecated: instead you should use the other version of this function which has more functionality. If "bounded", then the neighbors are restricted to be only those which lie within the box ranging from (0,0) to (width, height), that is, the width and height of the grid. if "toroidal", then the environment is assumed to be toroidal, that is, wrap-around, and neighbors are computed in this fashion. Toroidal locations will not appear multiple times: specifically, if the neighborhood distance is so large that it wraps completely around the width or height of the box, neighbors will not be counted multiple times. Note that to ensure this, subclasses may need to resort to expensive duplicate removal, so it's not suggested you use so unreasonably large distances.
The origin -- that is, the (x,y) point at the center of the neighborhood -- is always included in the results.
This function is equivalent to: getNeighborsMaxDistance(x,y,dist,toroidal ? Grid2D.TOROIDAL : Grid2D.BOUNDED, true, xPos, yPos);
void getMooreLocations(int x, int y, int dist, int mode, boolean includeOrigin, IntBag xPos, IntBag yPos)
This function may be run in one of three modes: Grid2D.BOUNDED, Grid2D.UNBOUNDED, and Grid2D.TOROIDAL. If "bounded", then the neighbors are restricted to be only those which lie within the box ranging from (0,0) to (width, height), that is, the width and height of the grid. If "unbounded", then the neighbors are not so restricted. Note that unbounded neighborhood lookup only makes sense if your grid allows locations to actually be outside this box. For example, SparseGrid2D permits this but ObjectGrid2D and DoubleGrid2D and IntGrid2D and DenseGrid2D do not. Finally if "toroidal", then the environment is assumed to be toroidal, that is, wrap-around, and neighbors are computed in this fashion. Toroidal locations will not appear multiple times: specifically, if the neighborhood distance is so large that it wraps completely around the width or height of the box, neighbors will not be counted multiple times. Note that to ensure this, subclasses may need to resort to expensive duplicate removal, so it's not suggested you use so unreasonably large distances.
You can also opt to include the origin -- that is, the (x,y) point at the center of the neighborhood -- in the neighborhood results.
void getNeighborsHamiltonianDistance(int x, int y, int dist, boolean toroidal, IntBag xPos, IntBag yPos)
This function may only run in two modes: toroidal or bounded. Unbounded lookup is not permitted, and so this function is deprecated: instead you should use the other version of this function which has more functionality. If "bounded", then the neighbors are restricted to be only those which lie within the box ranging from (0,0) to (width, height), that is, the width and height of the grid. if "toroidal", then the environment is assumed to be toroidal, that is, wrap-around, and neighbors are computed in this fashion. Toroidal locations will not appear multiple times: specifically, if the neighborhood distance is so large that it wraps completely around the width or height of the box, neighbors will not be counted multiple times. Note that to ensure this, subclasses may need to resort to expensive duplicate removal, so it's not suggested you use so unreasonably large distances.
The origin -- that is, the (x,y) point at the center of the neighborhood -- is always included in the results.
This function is equivalent to: getNeighborsHamiltonianDistance(x,y,dist,toroidal ? Grid2D.TOROIDAL : Grid2D.BOUNDED, true, xPos, yPos);
void getVonNeumannLocations(int x, int y, int dist, int mode, boolean includeOrigin, IntBag xPos, IntBag yPos)
This function may be run in one of three modes: Grid2D.BOUNDED, Grid2D.UNBOUNDED, and Grid2D.TOROIDAL. If "bounded", then the neighbors are restricted to be only those which lie within the box ranging from (0,0) to (width, height), that is, the width and height of the grid. If "unbounded", then the neighbors are not so restricted. Note that unbounded neighborhood lookup only makes sense if your grid allows locations to actually be outside this box. For example, SparseGrid2D permits this but ObjectGrid2D and DoubleGrid2D and IntGrid2D and DenseGrid2D do not. Finally if "toroidal", then the environment is assumed to be toroidal, that is, wrap-around, and neighbors are computed in this fashion. Toroidal locations will not appear multiple times: specifically, if the neighborhood distance is so large that it wraps completely around the width or height of the box, neighbors will not be counted multiple times. Note that to ensure this, subclasses may need to resort to expensive duplicate removal, so it's not suggested you use so unreasonably large distances.
You can also opt to include the origin -- that is, the (x,y) point at the center of the neighborhood -- in the neighborhood results.
void getNeighborsHexagonalDistance(int x, int y, int dist, boolean toroidal, IntBag xPos, IntBag yPos)
This function may only run in two modes: toroidal or bounded. Unbounded lookup is not permitted, and so this function is deprecated: instead you should use the other version of this function which has more functionality. If "bounded", then the neighbors are restricted to be only those which lie within the box ranging from (0,0) to (width, height), that is, the width and height of the grid. if "toroidal", then the environment is assumed to be toroidal, that is, wrap-around, and neighbors are computed in this fashion. Toroidal locations will not appear multiple times: specifically, if the neighborhood distance is so large that it wraps completely around the width or height of the box, neighbors will not be counted multiple times. Note that to ensure this, subclasses may need to resort to expensive duplicate removal, so it's not suggested you use so unreasonably large distances.
The origin -- that is, the (x,y) point at the center of the neighborhood -- is always included in the results.
This function is equivalent to: getNeighborsHexagonalDistance(x,y,dist,toroidal ? Grid2D.TOROIDAL : Grid2D.BOUNDED, true, xPos, yPos);
void getHexagonalLocations(int x, int y, int dist, int mode, boolean includeOrigin, IntBag xPos, IntBag yPos)
This function may be run in one of three modes: Grid2D.BOUNDED, Grid2D.UNBOUNDED, and Grid2D.TOROIDAL. If "bounded", then the neighbors are restricted to be only those which lie within the box ranging from (0,0) to (width, height), that is, the width and height of the grid. If "unbounded", then the neighbors are not so restricted. Note that unbounded neighborhood lookup only makes sense if your grid allows locations to actually be outside this box. For example, SparseGrid2D permits this but ObjectGrid2D and DoubleGrid2D and IntGrid2D and DenseGrid2D do not. Finally if "toroidal", then the environment is assumed to be toroidal, that is, wrap-around, and neighbors are computed in this fashion. Toroidal locations will not appear multiple times: specifically, if the neighborhood distance is so large that it wraps completely around the width or height of the box, neighbors will not be counted multiple times. Note that to ensure this, subclasses may need to resort to expensive duplicate removal, so it's not suggested you use so unreasonably large distances.
You can also opt to include the origin -- that is, the (x,y) point at the center of the neighborhood -- in the neighborhood results.
void getRadialLocations(int x, int y, double dist, int mode, boolean includeOrigin, IntBag xPos, IntBag yPos)
Places each x and y value of these locations in the provided IntBags xPos and yPos, clearing the bags first.
This function may be run in one of three modes: Grid2D.BOUNDED, Grid2D.UNBOUNDED, and Grid2D.TOROIDAL. If "bounded", then the neighbors are restricted to be only those which lie within the box ranging from (0,0) to (width, height), that is, the width and height of the grid. If "unbounded", then the neighbors are not so restricted. Note that unbounded neighborhood lookup only makes sense if your grid allows locations to actually be outside this box. For example, SparseGrid2D permits this but ObjectGrid2D and DoubleGrid2D and IntGrid2D and DenseGrid2D do not. Finally if "toroidal", then the environment is assumed to be toroidal, that is, wrap-around, and neighbors are computed in this fashion. Toroidal locations will not appear multiple times: specifically, if the neighborhood distance is so large that it wraps completely around the width or height of the box, neighbors will not be counted multiple times. Note that to ensure this, subclasses may need to resort to expensive duplicate removal, so it's not suggested you use so unreasonably large distances.
You can also opt to include the origin -- that is, the (x,y) point at the center of the neighborhood -- in the neighborhood results.
void getRadialLocations(int x, int y, double dist, int mode, boolean includeOrigin, int measurementRule, boolean closed, IntBag xPos, IntBag yPos)
Places each x and y value of these locations in the provided IntBags xPos and yPos, clearing the bags first.
This function may be run in one of three modes: Grid2D.BOUNDED, Grid2D.UNBOUNDED, and Grid2D.TOROIDAL. If "bounded", then the neighbors are restricted to be only those which lie within the box ranging from (0,0) to (width, height), that is, the width and height of the grid. If "unbounded", then the neighbors are not so restricted. Note that unbounded neighborhood lookup only makes sense if your grid allows locations to actually be outside this box. For example, SparseGrid2D permits this but ObjectGrid2D and DoubleGrid2D and IntGrid2D and DenseGrid2D do not. Finally if "toroidal", then the environment is assumed to be toroidal, that is, wrap-around, and neighbors are computed in this fashion. Toroidal locations will not appear multiple times: specifically, if the neighborhood distance is so large that it wraps completely around the width or height of the box, neighbors will not be counted multiple times. Note that to ensure this, subclasses may need to resort to expensive duplicate removal, so it's not suggested you use so unreasonably large distances.
You can also opt to include the origin -- that is, the (x,y) point at the center of the neighborhood -- in the neighborhood results.
java.util.Map buildMap(java.util.Map other)
java.util.Map buildMap(int size)


GitLens
Git supercharged
GitLens supercharges the Git capabilities built into Visual Studio Code. It helps you to visualize code authorship at a glance via Git blame annotations and code lens, seamlessly navigate and explore Git repositories, gain valuable insights via powerful comparison commands, and so much more.
GitLens is an open-source extension for Visual Studio Code created by Eric Amodio.
GitLens simply helps you better understand code. Quickly glimpse into whom, why, and when a line or code block was changed. Jump back through history to gain further insights as to how and why the code evolved. Explore the history and evolution of a codebase. Dive right in and see how GitLens can help!
While GitLens is powerful and feature rich, it is also highly customizable to meet your specific needs — find code lens intrusive or the current line blame annotation distracting — no problem, it is quick and easy to turn them off or change how they behave via the built-in GitLens Settings editor, an interactive editor covering many of GitLens' powerful settings. While for more advanced customizations, refer to the GitLens docs and edit your User Settings.
Don't miss how easy it is to configure GitLens!
What's New in GitLens 9
See the release notes for the full set of changes
- 9.0 DEC 2018
-
NEW Adds GitLens over
Visual Studio Live Share
Live Share guests will now have read-only access to GitLens' features, provided both the host and guest have GitLens installed
-
NEW Adds a new Git
virtual file system provider for the
gitlens:
scheme — closes #430Replaces GitLens' internal handling of file revisions, which allows for better performance, as well as avoiding the use of temp files. It also provides a much better experience when dealing with file encodings, images, etc.
- NEW Adds an Explore the Repository from Here command which opens a virtual workspace folder (using the new Git virtual file system provider) for the repository at the specified point in time (commit, branch, tag, etc) — closes #398
-
NEW Adds a new
Repositories view, formerly the GitLens view, to visualize, navigate, and explore Git
repositories — closes
#456,
#470,
#494
Provides a cleaner information-rich view of your opened repositories, more git commands (fetch, push, pull, checkout, stage, unstage, etc), better visibility and accessibility of existing features, and more
-
NEW Adds a new
File History view, formerly the History view, to visualize, navigate, and explore the
revision history of the current file
Provides similar features to the former History view as well as quickly toggling file tracking on and off, changing the base (branch, tag, commit, etc) of the file's history, and more
-
NEW Adds an all-new
Line History view
to visualize, navigate, and explore the revision history of the selected lines of
current file — closes
#354
Provides similar features to the File History view including quickly toggling line tracking on and off, changing the base (branch, tag, commit, etc) of the selected lines' history, and more
-
NEW Adds an all-new
Search Commits view
to search and explore commit histories by message, author, files, id, etc —
closes
#455
Provides somewhat similar features to the former Results view as well as it is now a persistent view, makes it easier to start a commit search, and more
-
NEW Adds an all-new
Compare view
to visualize comparisons between branches, tags, commits, and more
Provides somewhat similar and powerful features to the former Results view as well as it is now a persistent view, makes it easier to start a comparison, and more
- NEW Reduces the overhead of all GitLens views — GitLens now only tracks changes and updates the views if they are visible, collapsed or hidden views should have almost zero overhead
- NEW Adds relative date markers (Less than a week ago, Over a week ago, Over a month ago, etc) to revision (commit) histories in GitLens views
- NEW Adds branch and tag tip markers to revision (commit) histories in GitLens views — closes #560
- NEW Adds a changes indicator (+x ~x -x) to commits in GitLens views — closes #493
-
NEW Adds comparisions
to commit ids, by prefixing with a
#
, in addition to branches and tags — closes #535 - NEW Adds support for git mailmap — closes #388
- NEW Adds support for Azure DevOps (formerly VSTS) remotes — closes #501
- NEW Adds better detection of on-prem BitBucket and GitLab remotes — closes #214
- NEW Adds some missing gitmojis — thanks to PR #510 by Loris Bettazza (@Pustur)
- IMPROVED Changes the sorting of branch, tags, and files in GitLens views to be a natural sort #547
- IMPROVED Changes the Apply Changes command to truly apply only the patch of the specified change #539
- FIXED Fixes #405 — Secondary, blank repository appears repeatedly in Repositories view
- FIXED Fixes #430 — File revisions can end up being parsed by language servers (causing errors and warnings, etc)
- FIXED Fixes #496 — Short hash length doesn't match git's default length
- FIXED Fixes #503 — Open Changes (with difftool) opens one difftool window per changed file
- FIXED Fixes #507 — Restrict commit message size
- FIXED Fixes #527 — GitLens icon flashes on startup
- FIXED Fixes #533 — Some descriptions not using markdown properly in Settings GUI
- FIXED Fixes #544 — Some commit messages have one letter missing


Sorry, but this page is terribly broken. It's not your fault. Really not. Head back to the homepage or contact me. Sorry!


Barb Schwarz has Educated Realtors®, Home Stagers, and the Public on Home Staging since 1972. Barb is the Inventor and True Visionary who came up with the Staging Concept. She has built the Staging Industry from day one before any others had thought of it. Barb has personally taught over one million people in her classes since 1985. This year Barb marks her 27th anniversary year as a Professional Speaker and A Certified Speaking Professional. Barb is rated in the top 50 Most Influential Women in Real Estate Around the World by The Real Estate Network. Barb Schwarz pioneered and created the "Staging To Sell" and "Staging To Live" ® concepts. She has traveled the country extensively from 1985 to present time, spreading the mission of Home Staging to millions.
As a seasoned speaker and top Real Estate producer, Barb Schwarz has logged over 22,000 hours on the platform. Hundreds of thousands of REALTORS® have attended her various programs. Her wonderful gift for speaking and her ability to educate, motivate and entertain was recognized by the National Speakers Association in 1990 when they awarded her the coveted designation of Certified Speaking Professional (CSP), earned by less than 250 speakers worldwide. Barb Schwarz is a leader, an innovator, a real visionary, and a truly gifted speaker who shares the wisdom of her personal triumphs. Those who experience Barb are always struck by her incredible energy as well as the highly educational and practical substance of her programs. IN 2016 Barb marked her 31st year as a Professional Speaker and Trainer.
Barb Schwarz has published articles in numerous national publications addressing a variety of real estate topics and is written about monthly in well known newspapers and magazines all around the U.S. and Canada. Barb is internationally known as The Creator of Home Staging® and The Home Staging Industry for which she holds the Federal registered trademark. Her video "How To Prepare Your Home For Sale...So It Sells" won the Consumer Education Product of the Year Award from the Real Estate Educators of America. Her Home Staging video entitled "How To Stage Your Home So It Sells For Top Dollar" receives rave reviews. She is the author of the best selling books entitled "How To List And Sell Residential Real Estate Successfully" and "Home Staging: The Winning Way to Sell Your House for More Money" and 'Building a Successful Home Staging Business' and "Staging To Sell: The Secret to Selling Homes in a Down Market" published by Wiley & Sons and ‘If You Wear Out Your Body Where Will You Live’ in bookstores and on Amazon.com.
Barb is the creator of "Staging To Sell and Staging To Live" ® concepts and she holds the Federally Registered Trademark from the US and Canadian Governments on Stage®. Barb Invented the Home Staging Concept and industry when she entered the world of Real Estate as an Agent in Bellevue, WA in the early 70’s. She quickly saw and realized the need sellers have of preparing their homes for sale. Her background in the theater and music gave her the idea of setting the scene and setting the Stage® for buyers to see properties in the best way. This is how she came up with her concepts and called it Home Staging. Barb Schwarz has also personally Staged and Sold over 5,000 homes in the greater Seattle area.
Barb Schwarz is the Founder of Stagedhomes.com. StagedHomes.com was the very first Staging Educational website in the world and is the Internationally recognized leader in the Home Staging Industry because of the: Home Staging educational trainings of the ASP® Course and Designation, the Stagedhomes.com Home Staging Directory where the public finds ASP® Real Estate Agents and ASP® Stagers to list and Stage® their homes, and the Stagedhomes.com Staged Homes portal which lists homes that are Staged for sale. Stagedhomes.com is also based upon over 44 years of experience and leadership through Barb Schwarz experience and innovation. Stagedhomes.com is the resource to the Home Staging industry and sets the bar of excellence in the Home Staging world. As The Creator of Home Staging® Barb developed the Accredited Staging Professional, ASP/ASPM® Courses and Designations. The ASP® designation is the premier Home Staging Designation in the Home Staging and Real Estate Industries. StagedHomes.com trains Real Estate agents, as they earn the ASP® Real Estate Designation, how to educate sellers on the benefits of Home Staging, how to price and market Staged Homes, Listing Presentation skills, and how to work with an ASP® Home Stager as well as Home Staging tips and ideas. Home Stagers earn the ASP® Stager Designation and learn how to open, market, run, and build a Home Staging Business. StagedHomes.com trains real estate agents in a 2 day ASP Course and Home Stagers in a 3 day course. The ASP® Courses are currently taught across the United States and Canada and around the world! The Masters, ASPM®, Course Barb developed and wrote as an additional 5 day Staging Training Course for ASP®’s to become ASPM® Masters as well.
Barb grew up in Kansas in her earlier years. She graduated from The University of Washington with degrees in Education, Music and Design. Barb taught school for several years before opening her decorating business, which then led her to become a Real Estate Broker. It is in Real Estate where she developed and created the concept of Staging in the early 70’s. After many successful years as a Real Estate Broker using her Staging Concept and ideas she became a professional speaker and trainer to help educate the world about Home Staging in 1985. Since then the rest is now history and with you above.
Barb has been married for over 33 years! She has a darling special needs daughter whom she loves, adores and learns so much from. Barb’s favorite hobby is gardening. She works tirelessly in her garden and Stages® her Garden as well. Barb also of course Stages® everything, loves to read, write, create and develop new ideas, shop for items for the home, continue to help ASP’s throughout the world and help others in her community. Barb and her family reside in Washington State in the Seattle area.


{
"use strict";
// Define the required modules for this class.
const fs = require('fs');
const path = require('path');
const DynamicDNS = require('./DynamicDNS');
/**
* This is a service class designed to run the Google DynamicDNS as a service on a time interval that checks if the public IP has
* changed in-order to update the Google host DNS IP address. This is intended to be simple and clean, for more complex features use
* this as a template in conjunction with DynamicDNS class.
*
* @class
* @memberof DEDA-Google-DDNS
* @author Charbel Choueiri<EMAIL_ADDRESS>*/
class Service
{
/**
* Creates a new class with the given options.
* @param {object} options See [getDefaultOptions()]{@link DEDA-Google-DDNS.Service.getDefaultOptions} for more details.
*/
constructor(options)
{
/**
* An instance of the Google DynamicDNS class used within this service.
* @member {DEDA-Google-DDNS.DynamicDNS}
*/
this.dynamicDNS = new DynamicDNS(options);
/**
* Keeps track of the number of consecutive errors in-order to determine what to do next base don the set options.
* @member {number}
*/
this.consecutiveErrors = 0;
/**
* The class options as defined by [getDefaultOptions()]{@link DEDA-Google-DDNS.Service.getDefaultOptions}
* On initialization the constructor options parameters are merged with the default options.
* @member {DEDA-Google-DDNS.Service.DefaultOptions}
*/
this.options = Object.assign(this.constructor.getDefaultOptions(), options);
// Update log file to include first entry.
this.log('Creating new service.\n');
}
/**
* @typedef {Object} DefaultOptions
* @property {number} [checkInterval = 60] - The amount of time in seconds to wait before checking if the public IP has changed.
* @property {number} [maxConsecutiveErrors = 10] - The maximum number of check consecutive errors before stopping the check timer loop.
* @property {boolean} [exitOnMaxErrors = true] - Defines whether to exit process when the max consecutive errors has been reached.
* @property {string | boolean} [logPath = './logs.log'] - Defines the log output path. Set to false to disable output logs.
* @property {boolean} [logToConsole = true] - Defines whether to log output to the console or not.
* @memberof DEDA-Google-DDNS.Service
*/
/**
* Returns a list of all possible options for this class with their default values.
* @returns {DEDA-Google-DDNS.Service.DefaultOptions} Returns the component default options.
*/
static getDefaultOptions()
{
return {
checkInterval: 60,
maxConsecutiveErrors: 3,
exitOnMaxErrors: true,
logPath: './logs.log',
logToConsole: true
};
}
/**
* Starts the service check loop that will check for public IP changes every set time interval to ensure it remains
* synchronized with the host name DNS IP address.
*/
async start()
{
let checkInterval = this.options.checkInterval;
// Call the sync method and get the results.
const result = await this.dynamicDNS.sync();
// If it was successful then set time out to the next interval.
if (result.status !== 'error')
{
// Clear the current error counter.
this.consecutiveErrors = 0;
// If it was actually updated then log it.
if (result.status === 'success') this.log(result.message);
}
// Otherwise if an error occurred then update the counter and log the error.
else
{
// Update the error counter and log the error.
this.consecutiveErrors++;
this.log(result.message, 'error');
// If google returned '911' then wait 5 minutes before trying again. Even if if checkInterval was longer than 5 minutes, we missed this one and should try again.
if (result.response === '911') checkInterval = 6*60;
}
// If we have not exceeded the consecutive errors then run the timer again.
if (this.consecutiveErrors < this.options.maxConsecutiveErrors) setTimeout(()=>this.start(), checkInterval*1000);
// Otherwise log the error and exit.
else this.log('The maximum consecutive errors have occurred.', 'error');
}
/**
*
* @param {*} message
* @param {*} type
*/
log(message, type = 'log')
{
// Get the current date time stamp as a string. Add the message type and time stamp.
const date = new Date();
message = `${type.toUpperCase()} (${date.getFullYear()}-${(date.getMonth()+1).toString().padStart(2, '0')}-${date.getDate().toString().padStart(2, '0')} ${date.getHours().toString().padStart(2, '0')}:${date.getMinutes().toString().padStart(2, '0')}:${date.getSeconds().toString().padStart(2, '0')}): ${message}`;
// Append the message to the log file if provided. Also append the message to the console if set.
if (this.options.logPath) fs.writeFileSync( path.resolve(process.argv[1], '../', this.options.logPath), message + '\n', {flag: 'a'} );
if (this.options.logToConsole) console[type](message);
}
}
// Export the class
Service.namespace = 'DEDA.Google.Domains.DynamicDNS.Service';
module.exports = Service;
};


Toggle navigation
LightUpPi Alarm Web Interface
Home
(current)
Add Alarm
About
Select Theme
{{theme.name}}
Next 24 hours weather and alarms
There was a problem loading the alarms from the server. Default alarms loaded for demonstration only.
Alarm {{alarm.id}}
{{panels.enabledButtonText(alarm.enabled)}}
Alarm time:
{{alarm.hour|leadingzero}}:{{alarm.minute|leadingzero}}
Repeat:
{{panels.formatedRepeat(alarm)}}
Label:
{{alarm.label}}
Timestamp:
{{alarm.timestamp | date:'dd/MM/yy @ h:mma'}}


findpath(list, curvature=1.0)
The findpath() command has been subsumed into the new bezier() command, though note that it gives you less control over curvature. The boolean smooth
argument to bezier() is equivalent to calling findpath() with a curvature of 1.0 or 0.
points = [(10, 10), (90, 90), (350, 200)] for x, y in points: oval(x-2, y-2, 4, 4) nofill() stroke(0.2) autoclosepath(False) path = findpath(points) drawpath(path)


Trust And Blockchain Marketplaces
Transcript By: Bryan Bishop
Tags: Mining
Category: Conference
David Vorick
Introduction
I founded Sia, a decentralized storage platform started in 2014. Today, Sia is the only decentralized storage platform out there. I also founded Obelisk which is a mining equipment manufacturing company.
Mining supply chains are centralized
Basically all the mining chips are coming out of TSMC or Samsung. For the longest time it was TSMC but for some reason Samsung is at the forefront for this cycle but I would expect them to fade out in the next cycle. There’s just two, and there’s nobody else.
Mining rig manufacturing is also centralized
At the next level down, TMSC and Samsung make the chips but you have to make the boards and rigs and stuff. There’s really only five major companies that manufacture these– Bitmain, Whatsminer, Innosilicon, Canaan, and Bitfury. Mining rigs don’t have multiple features to compete across; either it does a ton of hashrate at not much electricity consumption or it’s a worse product. So each cycle you end up with one miner that is pretty dominant. Bitfury is usually that one. Bitfury’s development team left and started Whatsminer.
Mining pools
Mining pools are also centralized. As we go down the stack, things get better. There’s 8 mining pools that have 80% of the hashrate.  Mining pools are also more flexible, it’s difficult– if you don’t like Bitmain, it’s difficult to push them out, but mining pools on the other hand, there’s a lot of software and it’s not that difficult to write some of it is but you can switch mining pools a lot more easily than switching manufacturers.
Mining farms
Mining farms are definitely the most decentralized. Mining farms don’t publish clean data, so it’s hard to figure out how many there are and where they are located. We know that roughly 60% of the hashrate is in China. It’s probably a few low dozens of mining farms to get 50-60% of the hashrate. It turns out that cheap electricity is not that scalable. It’s still not 1 CPU 1 vote vision that was originally presented.
Progress in decentralized mining is slow
If you look at decentralizing TMSC, that just seems like an insurmountable task. Decentralizing Bitmain has been tried a few times, but it has failed at great cost to the people that tried. And mining pool situation doesn’t look too bad, things are moving slowly but we might be able to get to the point where mining pools are actually decentralized.
Mining is inherently centralized
This is inherent to how mining economics are setup. Bitcoin mining is zero sum, and this kills everything. If Bitmain comes out with a better rig that is faster and more energy efficient, then this hurts all the other manufacturers. So your revenue drops and your profitability drops if you don’t keep up and buy the Bitmain rigs. So mining is ongoing and incredibly expensive. So if you’re not running competitive hardware or in a competitive data center, then you get pushed out of bitcoin.
One thing that we saw on, when we were manufacturing, is that if your competitors are raising money by using dubious means like lies or if there’s legal stuff happening that doesn’t make sense… that’s profit margin for them, that you don’t have. If you refuse to compete using dirty tactics, you just won’t be able to survive, at least in our experience. Basically, every dollar that your competitor can get that you’re exlcuding from yourself by ethical means, is you getting put out of business. Every dollar you place into true decentralization– to open-source stuff, for our engineers we needed to focus them on building and optimizing. We couldn’t take someone aside for 3 weeks to present something to the public. It was a lot more challenging, the survival grind was very strong.
This indicates to me that mining is inherently centralizing. The economies of scale cut a lot deeper than normal economies of scale. It’s a zero sum survival grind that binds you against doing anything else.
Challenge: Assume a monopoly miner
So maybe as protocol designers, we should get rid of the assumption that you have 51% of the hashrate not colluding. Maybe it doesn’t make sense to assume 50% honest hashrate. I think it would be interesting to open the doors to this new assumption where we assume that each blockchain ends up with a single monopoly miner on top of it, and we just see what happens to the ecosystem if you have to live under that assumption. Having been on the ground, assuming that 50% of the hashrate is not colluding is always going to be risky and tenuous. So maybe we should just accept that we’re going to end up with monopoly miners, and then design around that.
If we have a monopoly miner, then we want to eliminate what powers they have. Depending on how you design the protocol, blockchain miners can be malicious in different ways. We want to minimize the window of opportunity for a monopoly miner to be malicious. Also, we want a penalty where if we catch them being malicious then we should have some way to cause damage or disincentivize them from acting maliciously.
Two fnudamental miner problems that I don’t think you can get around… the first one is that miners choose transaction ordering and how blocks are formed. So your monopoly miner is able to censor transactions from being able to make it into consensus. Since they build chains, they can reorganize the chains and reorder history at a cost. They have to redo work. There is some price that miners can pay to organize history, but I don’t think in a standard blockchain you have a good way to stop reorgs.
A lot of protocols, we get these bonus powers. SPV nodes assume that miners are mining valid blocks. If you have a monopoly miner, this assumption maybe becomes a lot more questionable. In some protocols, miners can set the block fees, set the block size, etc. If you have a monopoly miner, they might play with these parameters. Some other protocols go a step further and give miners a unilateral power to change consensus rules, which if you have a monopoly miner is not something you should do.
If you assume a monopoly miner, then you want to cut out as much of this as possible. So don’t give miners bonus powers, don’t endorse SPV, and don’t let miners signal the activation of soft-forks. You don’t want miners to have power; they have a job to build blocks. If you let them choose about soft-forks, that gives powers to miners and maybe if we have monopoly miners that might not be what we want to do.
Limiting censorship potential
Miners can’t censor transactions if they can’t distinguish transactions from different actors. Either they choose to block everything which kills the chain, or they have to choose to accept almost everything. A miner can choose to censor, but if we can hide from them which transaction is which, this power won’t do a malicious miner any good. This would protect us against a monopoly miner.
Limiting double spend potential
The other thing we can do is limit double spending potential or history reorg potential by asking for more confirmations. So if it’s a valuable transaction, ask for a lot more confirmations. You should depend on layer 2 channels that are super burried, this might be too optimistic and maybe we should think about that more. For future research, what are design principles we can use or techniques we can use to limit the malice a miner can do if we assume a monopoly miner mining our chain?
Attacks are detectable
We should also penalize rogue miners. Censorship is detectable when a transaction with an appropriate fee is not being mined. You can determine censorship is happening there, it requires you to be watching in real time, so you can’t prove to an offline friend that the malice was happening. But in real time, we can see censorship. If the protocol is running honestly, there’s a probability of a reorg of a certain depth, and if we see a reorg on chain beyond the probable depth, we can assume an attack because it’s just probabilistically unlikely otherwise.
Out-of-band penalties
If we detect an attack, we need some means of penalizing miners. These penalties must be off-chain. The miners control what transactions get on the blockchain, therefore the miner can make sure that anything that penalizes the miners doesn’t make it on-chain. So fraud proofs on-chain doesn’t work, and the miner can deny access and never be penalized. We need an out-of-band way of penalizing miners.
Mining is expensive. It requires expensive hardware. It’s intentional. The out-of-band techniques we can use, we want to threaten that revenue by off-chain behaviors that we can have. One example of a really heavy handed thing is that if the miner attacks the chain, then you could just quit altogether and walk away. If there’s a lot of money at stake for the miner, then this is an effective deterrent. So it’s a big bet to pursue this strategy because we’re essentially putting the entire industry on the line. If we can’t find a way to get consensus stable in a reliable way, then it’s worth walkin gaway all together. This is not an empty threat, and we should take this seriously but it’s also not our only option.
Something less severe would be a PoW fork to switch from sha256 to sha512 or something. You can break the bad actor or you can just switch away to a new algorithm. You can also change the supply chain. This really damages the miners. Normally this is ASIC resistance coins breaking other coins. Sia did something about this a year ago now. From our perspective, it was super effective. Miners were really respectful after they lost like close to $100 million dollars. I do feel that on the ground floor, since the hard-fork miners have been more respectful of developers and altcoin developers which is really the point. You want miners to pay attention to you and take care of you. At the bitcoin level, this would require a ton of coordination and split the chain because it’s so heavy-handed.
There’s a third one, I’ll skip it.
Strategy four is to do a counter-attack. If you have more general purpose hardware, a chain gets attacked, then you can rent a ton of hashrate off of nicehash and counter-attack and the attacker will lose money making blocks. You’re going to lose money, or long range attacks get more complex. I owuld conjecture that there are counterattack games which are interesting and not as expensive as the defender as they are to the attacker, in the event the attacker wins and if the defender wins then it’s asymmetric in the other way. This amy or may not be useful.
You can also combine strategies: so if we ever see a successful attack, we leave altogether and the ecosystem collapses. You want everyone to participate in a counterattack; the person who is a victim of a censorship or double spend might not be the only one fighting to have the counterattack succeed. You get into more involved games beyond the scope of this attack.
Concluding remarks
I have more ideas, but they didn’t fit easily into this presentation. I think this is an underconsidered area and it merits more attention. I’m not saying we should just drop the assumption and change everything we do in bitcoin starting tomorrow, but I do think that we’re getting to the point where we should take this assumption more seriously and look at things we should be doing to protect ourselves if it turns out that monopoly miners are the steady state.


String.replaceAll()
or String.split()
where the first argument is a single regex meta character argument.
The regex meta characters are one of ".$|()[{^?*+\", and these have a special meaning in regular expressions.
For example calling "ab.cd".replaceAll(".", "-")
produces "-----"
, because the dot matches any character.
Most likely the escaped variant "\\."
was intended instead.
Example:
s.replaceAll(".", "-");
After the quick-fix is applied the result looks like:
s.replaceAll("\\.", "-");


Cascading Style Sheets describe the appearance of structured documents, usually written in HTML. The current standard for CSS is level 2 revision 1 (CSS 2.1) which is officially documented by the W3C in the Cascading Style Sheets Level 2 Revision 1 (CSS 2.1) Specification. CSS 3 is the new emerging standard. A good web site to follow what is going on with CSS 3 is www.css3.info.
| Property | Values | Used with Elements |
|---|---|---|
| color | #RRGGBB (Red, Green, Blue hex values) | any element that contains text |
| text-align | left | right | center | justify | block elements h1..h6, p, li, etc. |
| text-decoration | none | underline | overline | line-through | blink | inherit | mostly with a (anchor) elements |
| text-transformation | none | capitalize | uppercase | lowercase | any element that contains text |
| line-height | % or px | block elements h1..h6, p, li, etc. |
| letter-spacing | normal or px value | any element that contains text |
| font-family | font or font-family [, font or font-family ...] | any element that contains text |
| font-size | px or em value | any element that contains text |
| font-style | normal | italic | oblique | any element that contains text |
| font-weight | normal | bold | any element that contains text |
| background-color | #RRGGBB (Red, Green, Blue hex values) | any element with a background |
| background-image | url("[image url]") | mostly with body |
| background-repeat | repeat | repeat-x | repeat-y | no-repeat | mostly with body |
| background-position | left | center | right | top | center | bottom | mostly with body |
| list-style-type | disc | square | circle | ul |
| list-style-type | decimal | lower-roman | upper-roman | lower-alpha | upper-alpha | ol |


EPICORE
Dear [NAME],
Your application to become a member of EpiCore has been approved. Congratulations!
You are now set to start your online training!
Your background and experience make you an important part of EpiCore’s global member network that is enabling faster global disease outbreak detection and reporting. We are so pleased to have the opportunity to work alongside you!
You will receive a second email shortly which contains your username and temporary password. Please follow the instructions included in that email to set your new password and log in to EpiCore.
If you have any questions, please contact us at<EMAIL_ADDRESS>Sincerely,
The EpiCore Team


--- layout: page category: spec title: "Mathematical Markup Language (MathML) Version 3.0" ---
| Current Status: | Recommendation (REC) |
|---|---|
| Canonical URI: |
http://www.w3.org/TR/MathML3
|
| Abstract: | This specification defines the Mathematical Markup Language, or MathML. MathML is a markup language for describing mathematical notation and capturing both its structure and content. The goal of MathML is to enable mathematics to be served, received, and processed on the World Wide Web, just as HTML has enabled this functionality for text. This specification of the markup language MathML is intended primarily for a readership consisting of those who will be developing or implementing renderers or editors using it, or software that will communicate using MathML as a protocol for input or output. It is not a User's Guide but rather a reference document. MathML can be used to encode both mathematical notation and mathematical content. About thirty-eight of the MathML tags describe abstract notational structures, while another about one hundred and seventy provide a way of unambiguously specifying the intended meaning of an expression. Additional chapters discuss how the MathML content and presentation elements interact, and how MathML renderers might be implemented and should interact with browsers. Finally, this document addresses the issue of special characters used for mathematics, their handling in MathML, their presence in Unicode, and their relation to fonts. While MathML is human-readable, authors typically will use equation editors, conversion programs, and other specialized software tools to generate MathML. Several versions of such MathML tools exist, both freely available software and commercial products, and more are under development. |
Mathematical Markup Language (MathML) Version 3.0Updates:


Section 2.1 Earth's atmosphere in context
It is important to recognize that the atmosphere is not isolated from other Earth systems, and we can consider interactions between the and geosphere, hydrosphere, atmosphere, biosphere.
The geosphere is the solid rocky mass of the Earth and provides the lower boundary to the atmosphere and oceans (which cover 71% of the area of the Earth). As a whole, planet Earth has a average radius of 6371 km and a mass of 6x1024 kg. This provides clues to its bulk composition: an iron core surrounded by a large silicate (rocky) mantle.
The hydrosphere consists of the water inventory of the Earth, making up about 0.03% of the Earth's mass. The water of the Earth is distributed into 97% oceans and 3% freshwater; only about 0.001% of the Earth's water is present in the atmosphere. Of the freshwater inventory, less than 1% is found in surface lakes and rivers; most freshwater is present in glaciers (70%) or groundwater (30%).
The atmosphere is a thin layer of air (a mixture of different gases) above the Earth's surface. The mass of atmosphere is about one-millionth of the total mass of the Earth. The atmosphere is also relatively thin, and over 99% of the atmosphere's mass is found below an altitude of 30 km (19 miles)
The biosphere consists of all plant and animal life on the planet. The biosphere is closely connected to the atmosphere through the processes of photosynthesis and respiration.
The relative masses of each of these systems is summarized in the table below:
| System | Mass (kg) |
| Geosphere | \(6.0\times 10^{24}\) |
| Hydrosphere | \(1.7\times 10^{21}\) |
| Atmosphere | \(5.0\times 10^{18}\) |
| Biosphere | \(1.0\times 10^{16}\) |


This project was made for Seedling School by Coding Garden with CJ.
Made possible with Bulma and the Launch Library API


EXCLUSIVE: DeHaven on Helping Finance Jay Z's Music Career in the Beginning
by Jessica ToddDeHaven opened up to VladTV about Calvin "Klein" Bacote catching a case with Jay Z over a fight, but DeHaven added that he never knew the two of them to have a relationship. DeHaven went on to speak about Jay Z linking up with Jaz-O after he got a record deal, and Jay showing up on his album. DeHaven added that he financed the clothes, jewelry, and other expenses at the start of Jay's career, which you can hear more about above.


Page 1 of 1
talked to ej
Posted:
Sun Feb 18, 2007 11:02 pm
by 9sam1
talked to ej in game.. asked him bout pv he said " im not worried about it" yea just thought i should tell you i guess lol.
Posted:
Sun Feb 18, 2007 11:51 pm
by thadiusofx3
As a fellow programmer, I understand his position about the project.
He thinks that no one can produce a xenimus-like game in any timely fashion because it took him years and years or programming and design to do it.
Also as a fellow programmer, I understand that a challenge is always welcome =)
Posted:
Mon Feb 19, 2007 12:18 pm
by Karl G.
I'm surprised that he's so mellow. If it were me I'd at least try to talk to the people trying to recreate my game.
By the way, as I was doing my taxes this year, I discovered that if donations reach > $400 this venture becomes a business, and I have to pay 15% tax on it and start registering for trademarks and stuff, which incurs even more expense ($275!!!). So I guess if we get more than $400 things are going to get pretty interesting around here...but we'll get there when we get there. Let's finish this game first
Posted:
Mon Feb 19, 2007 12:49 pm
by Morn
Karl G. wrote:By the way, as I was doing my taxes this year, I discovered that if donations reach > $400 this venture becomes a business, and I have to pay 15% tax on it and start registering for trademarks and stuff, which incurs even more expense ($275!!!). So I guess if we get more than $400 things are going to get pretty interesting around here...but we'll get there when we get there. Let's finish this game first
Intrestingly enough if donations stop at exactly 400 dollars you'll have 5 dollars left after those expenses
Posted:
Mon Feb 19, 2007 1:22 pm
by Karl G.
Lol yeah, and no money left to buy models...which is annoying. So it's all or nothing I guess.
Posted:
Mon Feb 19, 2007 1:40 pm
by thadiusofx3
close donations at 399 lol
Posted:
Mon Feb 19, 2007 2:01 pm
by Morn
Make your donation goal below 400 or far above it.
Posted:
Mon Feb 19, 2007 2:51 pm
by 9sam1
it dont matter, EJ does not pay taxes and he makes more then that from xen. Also since its such a small amount the gov really wont bother. Trust me my dad tryed to shut down xenimus lol...
Posted:
Mon Feb 19, 2007 2:54 pm
by Karl G.
EJ doesn't pay taxes on Xenimus? That seems unlikely, he has a very apparent and traceable record of cash flow, etc...well then again, maybe that's why he never lets it out of beta.
So this brings up an interesting issue. If more than $400 makes me a business, releasing the open source code to this project wouldn't be a very good business move...
Posted:
Mon Feb 19, 2007 3:17 pm
by Morn
Depends on the goal of the business. It could be a very good move in proving that you are a Not-for-profit business
Posted:
Mon Feb 19, 2007 3:36 pm
by Karl G.
An NPO has to be charitable, and even then:
ila.org wrote:Not all not-for-profit organizations qualify for a tax exemption. For instance, the American Heart Association is a not-for-profit corporation which would also qualify for federal tax exemption. On the other hand, a neighborhood homeowners' association is also not-for-profit but would not qualify for a tax break. Only certain kinds of not-for-profit organizations--charities, schools, churches, clubs, etc.--fall into the tax exempt category.
I don't think producing a computer game is charitable, and so far, I definitely meet the IRS qualifications for being "self-employed", I'm just missing the $400 income it takes to put me there.
Posted:
Mon Feb 19, 2007 5:17 pm
by Morn
Then you need to determine how important it is to have an open source is. Open source doesn't mean no profit, if you willing to buy new ideas that other people (Ideally and most likely players) are going to develope and even test first.
Posted:
Mon Feb 19, 2007 5:25 pm
by Joe M.
pshaw. "non-profit business" is a contradictory phrase.
Life, Liberty, Property!
(and yes, Locke does, in fact, pwn Jefferson.
)
Posted:
Tue Feb 20, 2007 10:09 am
by Karl G.
haha thanks Joe.
Posted:
Mon Feb 26, 2007 4:10 pm
by secretrk1313
im currous karl, what are donations currently at?
Posted:
Mon Feb 26, 2007 5:30 pm
by thadiusofx3
there is a donation thread at the top of the forum with the current status


Toggle navigation
Github Overwier Admin Panel
{{isSession.username}}
Profile
Log Out
User Statistics
Search Statistics
Admins


Remove Comments
Configuration
The 'Remove Comments' filter is enabled by specifying:
- Apache:
ModPagespeedEnableFilters remove_comments
- Nginx:
pagespeed EnableFilters remove_comments;
in the configuration file. To retain comments that have semantic reason to be
delivered to the browser, you may specify one more wildcard patterns
using RetainComment
directives. For example:
- Apache:
ModPagespeedRetainComment " google_ad_section*"
- Nginx:
pagespeed RetainComment " google_ad_section*";
Description
The remove_comments
filter eliminates HTML comments,
which are often used to document the code or to comment out
experiments. Note that this directive applies only to HTML files.
CSS comments are eliminated with the
rewrite_css
filter, and Javascript comments are
eliminated with the rewrite_javascript
filter.
The filter reduces the transfer size of HTML files by removing most HTML
comments. Depending on the HTML file, this filter can significantly reduce the
number of bytes transmitted on the network. Also note that
the RetainComment
directive currently only applies to HTML files --
the wildcard pattern is not currently used for retaining CSS or Javascript
comments.
For example, if the HTML document looks like this:

Some content here

Then PageSpeed, with the above directives specified, will rewrite it into:

Some content here

Example
You can see the filter in action at www.modpagespeed.com
on this
example.
Notes
The "Remove Comments" filter is aware of Internet Explorer conditional comments and does not remove them.
Risks
This filter is low risk for most web pages. Some web pages use comments to embed data or JavaScript, in order to reduce the parse time of the HTML document. Such pages sould disable this filter, as it will remove the comments containing the data or JavaScript that is needed by these web pages.


{% extends 'base.html' %}
{% from 'macros.html' import render_form %}
{% block title %}Delete Transaction{% endblock %}
{% block content %}
{{ render_form(form, action_url='/delete', action_text='Delete Transaction',
class_='delete-transaction-form') }}
{% endblock %}


rokhimin
whd
Home
Projects
Tags
About
Projects
all my public projects
My Projects
Darkness Jekyll
Banner myBlog


Create an Enterprise Event Calendar on the Cheap
With Notes 8.5 comes the ability to overlay your own calendar with other calendars. An obvious use case for this functionality (besides your kids school calendar) is the list of corporate events. To get a corporate event calendar follow these easy steps:
Anybody who wants to manage an event would simply create a calendar entry (meeting invite) in his/her own calendar and invite "Corporate Events" to the "meeting". In the meeting body all event information like agenda, directions (take the staircase, all 27 steps, turn left at the water cooler) and other useful information can be listed. Almost always corporate events undergo changes when moving through their planning stages from idea to proposal to planned to confirmed. The event owner just needs to update the calendar entry in the personal mail file to keep the corporate events listing up to date. And we all know nothing is closer to you than anything in your mail file (except for Luis of course).
As usual: YMMV
- Create a new database on your server. Call it Corporateevents.nsf and base it on the standard mail template
- Give normal users "No access" with "Read Public Documents" access in the ACL
You can add this setting in the preferences too, same effect. - Create a mail-in document in your Domino directory pointing to that database
- Open the database and edit the profile (More - Preferences)
- Set the mailbox owner to the mail in name you just created (Corporate Events in our example)
- Edit the Autoprocessing settings in Calendar & ToDo to automatically accept all incoming invitations
- Check the access settings to verify our ACL change above worked (or make the changes here)
- Set the mailbox owner to the mail in name you just created (Corporate Events in our example)
Anybody who wants to manage an event would simply create a calendar entry (meeting invite) in his/her own calendar and invite "Corporate Events" to the "meeting". In the meeting body all event information like agenda, directions (take the staircase, all 27 steps, turn left at the water cooler) and other useful information can be listed. Almost always corporate events undergo changes when moving through their planning stages from idea to proposal to planned to confirmed. The event owner just needs to update the calendar entry in the personal mail file to keep the corporate events listing up to date. And we all know nothing is closer to you than anything in your mail file (except for Luis of course).
As usual: YMMV
Posted by Stephan H Wissel on 15 October 2010 | Comments (4) | categories: Show-N-Tell Thursday


- Create additional "site-" core theme elements making it easier to theme HAXcms and produce new themes (March '19)
- Support multiple Import
formats including WordPress, Drupal, Gitbook, GravCMS and more (April '19)
- Support multiple Publishing
end points, github being just one of many (May '19)
- Work on "IAM" wrapper project for HAXcms to allow for the organic deployment of multiple HAXcms instances from one; a SaaS style wrapper for hosting many users on one instance. (May '19)
- Continue to add themes and theme elements as well as improve documentation and support.


Europe worries about an under-committed Saracens
Marseille - Organisers of rugby's European Cup expressed concern on Wednesday that the 35-point English Premiership penalty handed to Saracens will affect the holders' appetite to defend their crown.
Saracens, who were also fined £5 million for breaching the Premiership Rugby salary cap over several seasons, have launched an appeal but face a stiff task to retain their place in the Premiership in England.
"Our concern rests in their capacity to put everything into the European Cup knowing that they will have to fight all the way to avoid relegation," said Vincent Gaillard, director general of European Professional Club Rugby (EPCR) at an event in Marseille to showcase the venue for the 2020 final.
Saracens, who also won the Premiership last season, beat Irish province Leinster in the 2019 final to win Europe's top trophy for the third time.
"Perhaps other clubs will be happy that they are going to be a bit wounded but it's not good news for us," said Gaillard.
"We would prefer that they are thoroughly behind the competition."
"An appeal is underway, this is only the start of the story, we don't know yet what the impact will be on the club."
Gaillard insisted that the penalty handed out to Saracens would not affect their European honours.
"Just as they won't lose their English titles nor will they be stripped of their three previous European titles," he said.
Saracens begin the defence of their title at Racing 92 in Paris on Sunday.


--- layout: archive title: Zulip Chat Archive permalink: /stream/113489-new-members/topic/finset.20semilattice_sup_bot.html ---
Hi! In finset.lean there is
instance : semilattice_inf_bot (finset α) := { bot := ∅, bot_le := empty_subset, ..finset.lattice.lattice }
but no equivalent instance for semilattice_sup_bot. Is there some good reason for this?
I don't see any reason why this is missing.
Thanks
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


| description |
To identify a digital object:
Syntax:
"info:fedora/" object-pid
Where:
"object-pid" is the Fedora PID of the object
Examples:
info:fedora/example:1
info:fedora/example:9876
To identify a dissemination:
Syntax:
"info:fedora/" object-pid "/" dissem-name
Where:
"object-pid" is the Fedora PID of the object (or "*" when the
URI indicates a dissemination without regard to
a particular object).
"dissem-name" is either a datastream ID or behavior definition
object PID, followed by "/", followed by a method name.
Examples:
info:fedora/example:3/DS1
info:fedora/example:3/example:1/index
info:fedora/*/DS1
info:fedora/*/example:1/index
Note that datastream ids and method names may consist of XML NCName
characters. NCName characters that are not safe to directly encode
in an "info" uri and must be escaped using one to four escaped UTF-8
octets per character, each of the form "%" HEXDIG HEXDIG. |


Improving patient education and adherence for a multi-indication drug
Strategy / Design
Janssen Pharmaceuticals was seeking to redesign the digital platform for their top cardiovascular drug after being approved for a number of new indications. They wanted to provide better education, support and promote adherence for current and new patients.
Impact
- Launched an 100+ page website with a personalized journey based on condition
- Helped clients commit to a user-centric mindset towards product design
- Implemented and embedded an atomic design system


{% extends "moya.debug/base.html" %} {% block "title" %}404 - Not Found{% endblock %} {%- def "info" %} {%- if map %} {% if title %}
${request.path} was not found on this server
You are seeing this page because you have moya.debug installed. If you set [project]/debug=no in your settings, Moya will use your "404.html" template.
The following route(s) matched the URL:
| Target | Application | URL data | Response | ||
|---|---|---|---|---|---|
| ${html:trace.target_html} | {%- if trace.app %}${trace.app.name} | {%- else %}N/A | {%- endif %}
{%- for k, v in items:trace.route_data if k != 'app' %}
${k} =
"${v}" {%- endfor %} |
{%- if trace.response %}
${trace.response} | {%- else %}none | {%- endif %}
The URL did not match any of the routes in the project.
{%- endif %}Moya attempted to match the requested URL with the following route(s):
Some routes may be omitted here if they didn't match .request.method (i.e. you wont see POST only route(s) for a GET request).
| Route | Method(s) | Application | Target(s) |
|---|---|---|---|
| ${html:url} | ${html:methods} | ${app} |
{%- for target, target_html in targets %}
${html:target_html}
{%- endfor %} |


--- layout: post title: 'Asteroid Database and Mining Rankings - Asterank' url: http://www.asterank.com/ source: http://www.asterank.com/ domain: www.asterank.com image: http://kinlane-productions.s3.amazonaws.com/screen-capture-api/www-asterank-com.png ---
Asterank is a scientific and economic database of over 600,000 asteroids.Weve collected, computed, or inferred important data such as asteroid mass and composition from multiple scientific sources.With this information, we estimate the costs and rewards of mining asteroids.Details on orbits and basic physical parameters are sourced from the Minor Planet Center and NASA JPL.Composition data is based on spectral classification and size.


---
title: Pupil Player - Incremental Release v<IP_ADDRESS>
description: >
Pupil Labs software release
created: !!timestamp '2014-07-10 11:00:00'
author: Pupil Development Team
---
{% mark excerpt -%}
{%- endmark %}
{% mark body -%}
## Overview
We have been doing a lot of work recently on the back-end of Pupil Capture and Player, which will allow for much greater control in the way video and audio are captured, encoded, and decoded. While back-end changes are not yet available for use, we just wanted to say that we're working on it and hope to release changes within the next few weeks.
## Pupil Player
We have just completed some incremental updates for Pupil Player in the offline marker detector plugin. Download Player and try it out for yourself by with our sample recording below.
Here is an overview of new features:
+ Surface and gaze metrics reports saved as .csv files
+ Surface metrics and visualizations within Pupil Player
+ Option to use markers in the scene to set trim marks for automated video export
Heat maps are now mapped onto the surfaces within Pupil Player during playback. Above we show a screenshot of the sample recording with heatmaps -- try it for yourself!
We did notice that some markers that we used in our sample recording did not have enough of a white border around them, which results in surface jitter. You can scale the markers to different sizes, but make sure to have a white border width of at least 1.2 x the marker grid size for marker stickers.
## Sample data
Sample data of gaze metrics and surface metric reports generated by Pupil Player for the sample recording. Below tables show overviews for the full duration of the sample video - to see all metrics download the recording.
surface_visibility.csv |
|
|
frame_count
|
3235
|
|
|
|
surface_name
|
visible_frame_count
|
|
box front
|
590
|
|
box bottom
|
263
|
|
box back
|
1182
|
|
box top
|
70
|
|
box left
|
119
|
|
box pullout
|
408
|
|
box inside
|
281
|
|
tablet front
|
2025
|
surface_gaze_distribution.csv |
|
|
total_gaze_point_count
|
6434
|
|
|
|
surface_name
|
gaze_count
|
|
box front
|
412
|
|
box bottom
|
100
|
|
box back
|
1327
|
|
box top
|
51
|
|
box left
|
112
|
|
box pullout
|
372
|
|
box inside
|
266
|
|
tablet front
|
1811
|
Let us know what you think and post questions (or links to your demos :-) on the [Pupil Google Group](https://groups.google.com/forum/#!forum/pupil-discuss "Pupil Google Group").
{%- endmark %}


{% extends 'base.html' %} {% import 'bootstrap/wtf.html' as wtf %} {% block app_content %}
Login as Student
Login as Teacher


vignettes/single_cell_analysis.Rmd
single_cell_analysis.Rmd
This vignette demonstrates how to summarize single-cell data from a morphological profiling experiment into treatment “profiles”. This dataset is from (Ljosa 2013) and is part of the BBBC021 dataset:
“This image set provides a basis for testing image-based profiling methods wrt. to their ability to predict the mechanisms of action of a compendium of drugs. The image set was collected using a typical set of morphological labels and uses a physiologically relevant p53-wildtype breast-cancer model system (MCF-7) and a mechanistically distinct set of targeted and cancer-relevant cytotoxic compounds that induces a broad range of gross and subtle phenotypes.”
The images were analyzed using CellProfiler. The CellProfiler pipelines and complete set of instructions to generate the data are provided in (Ljosa 2013).
Here, we analyze the single-cell data to perform a simple operation: summarizing them into per-well measurements by computing averages. This summarized data will later be used to predict mechanism-of-action of the compounds (see the predict_moa
vignette.)
This vignette assumes that the single-cell data https://s3.amazonaws.com/imaging-platform-collaborator/2016_09_09_cytominer_workshop/ljosa_jbiomolscreen_2013.sqlite has been downloaded into ~/Downloads
.
First, load the data! The data is contained in 4 tables named Image
, Cytoplasm
, Cells
, and Nuclei
. The code below joins these tables to create a single table named object
.
backend <- file.path(Sys.getenv("HOME"), "Downloads", "ljosa_jbiomolscreen_2013.sqlite") db <- src_sqlite(path = backend) image <- tbl(src = db, "Image") nuclei <- tbl(src = db, "Nuclei") %>% select(-ObjectNumber) cells <- tbl(src = db, "Cells") %>% select(-ObjectNumber) cytoplasm <- tbl(src = db, "Cytoplasm") %>% select(-ObjectNumber) object <- tbl(src = db, "Cells") %>% inner_join(tbl(src = db, "Nuclei"), by = c("TableNumber", "ImageNumber", "Cells_Parent_Nuclei" = "Nuclei_Number_Object_Number")) %>% inner_join(tbl(src = db, "Cytoplasm"), by = c("TableNumber", "ImageNumber", "Cells_Number_Object_Number" = "Cytoplasm_Parent_Cells")) object %<>% inner_join(image, by = c("TableNumber", "ImageNumber"))
In this table, the measurement columns start with Nuclei_
, Cells_
, or Cytoplasm_
.
variables <- colnames(object) %>% stringr::str_subset("^Nuclei_|^Cells_|^Cytoplasm_")
How many variables?
## [1] 514
How many cells?
## Warning: The `add` argument of `group_by()` is deprecated as of dplyr 1.0.0.
## Please use the `.add` argument instead.
## This warning is displayed once every 8 hours.
## Call `lifecycle::last_warnings()` to see where this warning was generated.
| n |
|---|
| 14821 |
Note that this is a smaller version of the BBBC021 dataset. The full dataset is here https://s3.amazonaws.com/imaging-platform-collaborator/2016_09_09_cytominer_workshop/ljosa_jbiomolscreen_2013.sqlite.
Before aggregating the data, let’s filter it down to one well and plot the histogram of a single feature:
Now let’s summarize the data by grouping by well and computing averages.
profiles <- cytominer::aggregate( population = object, variables = variables, strata = c("Image_Metadata_Plate", "Image_Metadata_Well"), operation = "mean" ) profiles %<>% collect() variables <- colnames(profiles) %>% str_subset("^Nuclei_|^Cells_|^Cytoplasm_")
How many wells?
| n |
|---|
| 30 |
The full version of this dataset is used in the vignette predict_moa
to predict the mechanism-of-action of compounds.
Before we move on to that, let’s plot the relationship between a pair of variables from this summarized data


Shopping
Select cathegory:
Activities
Artists
Childcare
Musicians
Local news
Politics
Rideshare
Volunteers
Classes
Other
Baking
Beverages
Catering
Meal Preparation
Pastry
Vegetarian
Other
Clothing
Consumer electronics
House, Garden
Sports Equipment
Vehicles
Antiques
Other
Apartments / housing
Rooms / shared
Sublets / temporary
Vacation rentals
Parking
Storage
Office / commercial
Real estate for sale
Other
Electrical
General
Mechanical
Painting
Plumbing
Renovation
Agriculture
Other
Concerts
Events
Hotels
Restaurants, Bars
Sports
Traveling
Other
Art / media / design
Business / management
Customer service
Education
Human resources
Manufacturing
Marketing / pr / ad
Medical / health
Nonprofit sector
Retail / wholesale
Security
Transport
Web / info design
Writing / editing
Other
Beauty
Consulting
Education
Entertainment
Financial
Health
IT, Telecom
Personal
Transportation
Other