Molecular Visualization
All of the structures are represented using JSMol, a free javascript molecular visualizer. Each atom in a strucutre has a unique position given by (x,y,z) coordinates, and a diameter given by a value measured in Angstroms (Å). Each atom is assumed to be a sphere with a defined center and diameter. This simplification drives the visualization and simplifies calculation. Colors are used to show different atom types, the most common being grey for Carbon, white for Hydrogen, red for Oxygen, blue for Nitrogen. MOFs are often crystalline or lattice structures consisting of many repeating units. The smallest such unit is the unit cell and is the default view when a structure is loaded. A supercell arises when a unit cell is repeated several times. To visualize a supercell, imagine that the structure continues from any boundary back around to that accross from it. Or open MOF Explorer and set the supercell parameters.
Periodic Boundary Conditions
When performing calculations it is often important to know the distance between two structure atoms. Due to periodic boundary conditions (PBC), the nearest atom to a point might not be in the same unit cell. To account for this, all distances are computed twice, as a straight line between points and then taking PBC into consideration. The former yields a distance vector between two points, the latter applies PBC to the vector by considering the image of a point - its analog in the neighboring cell. An important distinction can be made between unit cells that are orthorhombic (all angles are right angles) or not. For those that are, PBC calculations take two steps. First, each component of the distance vector is compared to the unit cell length. If point A is less than half a unit cell from point B, then the image of A in the neighboring cell (A') must be further away. No calculations are made because the original value is the smallest distance. Conversely, if A is more than half the unit cell from B, then A' is closer than A. The distance of A to B becomes the distance from A' to B by shifting the position of A to A':
If the cell is not orthorhombic, some of the implicit simplifications above no longer hold. Instead, matrix transformations are used to compute the distance to the image. There is a matrix
that defines any unit cell and can be found with:
// A, B, C are vector lengths
// (b) is in the xz-plane and (c) has a positive y component.
// alpha is the angle (bc), beta is (ac), gamma is (ab)
a_x = A;
a_y = 0.0;
a_z = 0.0;
b_x = B * Math.cos(gamma);
b_y = B * Math.sin(gamma);
b_z = 0.0;
c_x = C * Math.cos(beta);
c_y = (B * C * Math.cos(alpha) - b_x * c_x) / b_y;
c_z = Math.sqrt(Math.pow(C,2) - Math.pow(c_x,2) - Math.pow(c_y,2));
cellMatrix = [a_x, a_y, a_z, b_x, b_y, b_z, c_x, c_y, c_z];
The inverse of the cell matrix allows for the transformation of the cell to a non-slanted, or orthogonal basis. The same calculations as for an orthorhombic cell are then performed, subtracting
a vector length from the position if the distance is more than half of the vector (here unit cell and vector are not interchangeable). The distance vector is then transformed back to the
original basis by multiplication of the cell matrix. The result is a modified distance vector that takes into account PBC:
To determine if the cell is orthorhombic, a check is performed to see if the cell lengths are all equal and all angles are 90°. Based on the result, PBC are calculated using one of the two above methods.
function pbCond(dist) {
if (notOrthorhombic) {
fractional = [0,0,0];
fractional = matrixDotVector(inverseMatrix, dist);
xVect = [0,0,0];
xVect[0] = fractional[0] - Math.round(fractional[0]);
xVect[1] = fractional[1] - Math.round(fractional[1]);
xVect[2] = fractional[2] - Math.round(fractional[2]);
cartesian = matrixDotVector(cellMatrix, xVect);
return cartesian;
}
else {
if (dist[0] > cellSize[0]/2) {
dist[0] = dist[0] - cellSize[0];
}
if (dist[1] > cellSize[1]/2) {
dist[1] = dist[1] - cellSize[1];
}
if (dist[2] > cellSize[2]/2) {
dist[2] = dist[2] - cellSize[2];
}
return dist;
}
}
Void Fraction
The void fraction of a structure is a measure of the volume it occupies within a unit cell. A hollower or emptier cell corresponds to a greater void fraction. Calculating the void fraction is akin to throwing a large number of darts at the structure and seeing how many hit. Instead of darts the simulation uses spherical probes of a given size (point probes have size 0). These probes are inserted randomly into the unit cell and those that overlap with the structure are removed. This is done by comparing the distance from the probe to each of the structure atoms with the sum of their radii. If the sum of the radii is larger than the distance, then the two overlap and the probe is flagged for deletion.
The ratio of those that remain to the total used is the void fraction.
for (i=0;i<numProbes;i++) { // for all of the probes
x1 = probeLocation[i][0];
y1 = probeLocation[i][1];
z1 = probeLocation[i][2];
var dr = 0;
for (k=0;k<numStructureAtoms;k++) { // compare to coordinates of structure
if (!isInArray(i,flagged)) {
x2 = atomLocation[k]['x'];
y2 = atomLocation[k]['y'];
z2 = atomLocation[k]['z'];
radius = atomDiameters[atoms[k]['sym']]/2;
dist = distance(x1,y1,z1,x2,y2,z2);
dist = pbCond(dist);
dr = Math.sqrt(Math.pow(dist[0],2) + Math.pow(dist[1],2) + Math.pow(dist[2],2));
if (dr > (probeRadius + radius)) {
flagged[index] = i;
index++;
} } } }
flaggedProbeCount = flagged.length;
vFraction = 1-flaggedProbeCount/numProbes;
This calculation makes use of a function pbCond
which accepts the distance vector between two points as an argument and returns a distance vector. Details of periodic boundary
conditions can be found above in the periodic boundary conditions section.
Surface Area
The surface area of a MOF is a measure of the exposure of atoms to their surroundings. The term surface area conventionally refers to the van der Waals surface area which can be thought of as the size of a sheet required to cover a structure. Another measure of surface area is the solvent-accessible surface area which considers only the surfaces where a solvent molecule could be found.
The absolute and solvent-accessible surface areas are equivalent for a solvent of size 0. Measuring the solvent-accessible surface area can be thought of as rolling
a ball over the entire surface and measuring the area covered. Larger spheres will not be able to enter cavities in the structure and will result in a smaller measured surface area.
The surface area is measured by first randomly placing probes on the surface of structure atoms. This is achieved by taking the center of a structure atom and genrating random points
at a fixed distance from it. The distance is the sum of the radii of the structure atom and the probe. The following code shows how to generate uniformly distributed points on the surface of
a sphere:
theta = 2*Math.PI*Math.random();
phi = Math.acos(2*Math.random()-1.0);
xu = Math.cos(theta)*Math.sin(phi);
yu = Math.sin(theta)*Math.sin(phi);
zu = Math.cos(phi);
rad = atomRad + probeRad;
// x, y, z are the location of the structure atom in question
probeX = x + rad*xu;
probeY = y + rad*yu;
probeZ = z + rad*zu;
A check is perfomed to see if the probe overlaps with any other structure atoms (with PBC considered). If it does not, a counter is incremented to indicate a successfully placed probe. Once the atom is done being probed, its accessible surface area is computed.
In the above figure, 3 out 5 of the probes do not overlap with any structure atoms. The surface area of the structure atom in question
is (3/5 π r 2).
for (i=0;i<probesPerAtom;i++) { // for each of the probes given per atom
overlapP = probeOverlap([probeX,probeY,probeZ]);
if (!overlapP) { // if probe has no overlaps
notOverlap++; // increment number of non-overlapped
}
if (i == probesPerAtom -1) { // on the last iteration of the for loop, compute the surface area
totalRad = atomRad + probeRad; // sum of radii
// surface area of sphere S with radius (r(probe) + r(atom)) * non-overlapping probe fraction
surfaceArea = 4*Math.PI*Math.pow(totalRad,2)*notOverlap/probesPerAtom;
}
}
This is repeated for all of the structure atoms and the resultant volumetric and gravimetric surface areas (using atomic masses) are given.
Pore Size Distribution
Some MOFs are finding applications for gas adsorption due to their highly porous nature. The pores of a MOF can be quantified using a pore size distribution (PSD). The PSD is a measure
of the size and relative availability of pores in a structure and is presented as a plot of pore size and relative abundance. Finding the size of a pore using random sampling requires
locating the largest sphere that encompasses a given point but does not overlap with any of the structure atoms.
The PSD is the only physical property here that is not measured using a Monte Carlo simulation. Instead a more optimal algorithm is employed.
For each of the probes specified a random point is generated outside of any structure atoms. A small sphere is made centered at this point and its radius incremented until it overlaps with a structure
atom. The point is then moved slighlty in each of the six directions and the procedure is repeated. If a larger sphere can be made centered at a shifted point and this sphere encompasses the
original point, then it is accepted as the new standard against which spheres are compared when this procedure is repeated. When shifting the point slightly no longer yields a larger sphere,
the largest probe size is recorded as the pore size for that point. This is performed with points uniformly distributed throghout the unit cell gives the pore size distribution which is normalized
and plotted.
for (q=0;q<numProbes;q++) {
r = largestRadius(probePoint,0); // find the largest radius at the point, beginning with 0
testPointArray = incrementPoint(probePoint); // create an array of points shifted from the original point slightly
// recursively find the largest pore by finding the largest radius at each of the shifted points
// take the point which yields the largest radius, create an array of shifted points from there and repeat
probeSize = findPore(testPointArray,r);
probeSizeArray = binArray(probeSize,probeSizeArray); // for graphing purposes bin the array of pore sizes to the probe size found - the negative derrivative of this array is plotted
}
function largestRadius(point,startingRadius) {
i=startingRadius;
while (!checkOverlap(point,i)) {
i+=stepSize;
}
return i;
}
function incrementPoint(point) { // six directions, + x,y,z; - x,y,z
pointArray = [];
for (j=0;j<3;j++) {
up[j] = point[j] + step; // step is a fixed stepsize of 0.05
down[j] = point[j] - step;
}
pointArray[0] = [up[0], point[1], point[2]];
pointArray[1] = [point[0], up[1], point[2]];
pointArray[2] = [point[0], point[1], up[2]];
pointArray[3] = [down[0], point[1], point[2]];
pointArray[4] = [point[0], down[1], point[2]];
pointArray[5] = [point[0], point[1], down[2]];
return pointArray;
}
Plotting is performed with a javascript library called flot.


Adham Enaya
Software Engineer
Palestine & Jordan
YallaDroid.com
<EMAIL_ADDRESS>EDUCATION
- 2003-2005 Al-Karmel Secrondary School, (97%)
- 2005-2010 Bachlore of Engineering in Computer Systems, (87%)
VERIFIED TRAINING
- Mobile Cloud Computing with Android (100%)
- Building Mobile Experiences (96%)
- The Computing Technology Inside Your Smartphone (94%)
WORK EXPERINCE
- SAP ABAP Developer @ UNRWA (Dec 2013-Present)
- .NET Web Developer @ UNRWA (Dec 2011-Oct 2013)
- Teaching Assistant @ Al Azhar University (Oct 2010-Oct 2011)
- Android Trainer @ Mercy Corps Gaza (Dec 2013-Present)


Master record updated successfully!
Record type
User
Anniversary
Birthday
Category
Store
CSV File
Upload


Artudis Utils Dashboard
A set of tools for the Artudis IR.
What is your Artudis base URL?
Run checks on Person-export.json
'No Name Variant' Check
'No ORCID' Check
Download from Artudis
Run checks on Organisation-export.json
Download from Artudis
Run checks on Collection-export.json
Download from Artudis
Run checks on Publication-export.json
Download from Artudis


# These examples are taken from: https://prometheus.io/docs/prometheus/latest/querying/examples/
http_requests_total{job="apiserver", handler="/api/comments"}[5m]
http_requests_total{job=~".*server"}
max_over_time(deriv(rate(distance_covered_total[5s])[30s:5s])[10m:])
sum by (job) (
rate(http_requests_total[5m])
)
sum by (app, proc) (
instance_memory_limit_bytes - instance_memory_usage_bytes
) / 1024 / 1024


Hi, my name is Jorge Betancourt and I'm a student at the Georgia Institute of Technology. I have numerous interests ranging from electronic media to biomechanics, and I'm always enthusiastic to learn more through hands on experience!
Find Out MoreI am a 3rd year computer science student at Georgia Tech with a passion for learning. I'm always looking to expand my knowledge by contributing my talents to projects where I can hone my skills as a software engineer. I thrive for opportunities where I can be creative in the field of computer science, where I can use both sides of my brain to create something meaningful through code. That is why I explore my interests through the organizations I am a part of, such as Video Game Development Club and the Exoskeleton and Prosthetic Intelligent Controls (EPIC) Lab.
Ability to utilize coding languages such as Java, C#, and Python creatively in order to solve problems.
Familiarity with creator software such as Unity, Adobe Photoshop, and more.
Experience in lab settings across multiple academic institutes and fields.
Experience with working in project oriented groups in many diciplines.
Give me a call or send me an email and I will get back to you as soon as possible!
305-205-3266


This podcast is by far my favorite. Although every episode tends to be rather long, you will learn so much by listening to that podcast. Gruber and guests are giving great and deep reviews on the tech world and especially on Apple! Every episode is just a joy to listen to ❤
This Podcast is amazing. Casey Liss, Marco Arment, and John Siracusa are forming one of the best trios ever. They are so different but at the same time so complementary that every episode is worth listening to. ATP is at a solid second place 😍
Of course, The Vergecast had to be within my favorites! The Verge is probably one of the tech websites I read the most. Their analyses are quite complete but I tend to dislike the way they talk about Apple. Overall, the Vergecast is at a logical third place 🤓


| Package | Description |
|---|---|
| it.unimi.dsi.fastutil |
Provides static data/methods used by all implementations and some non-type-specific classes
that do not belong to
it.unimi.dsi.fastutil.objects . |
| it.unimi.dsi.fastutil.booleans |
Provides type-specific classes for boolean elements or keys.
|
| it.unimi.dsi.fastutil.bytes |
Provides type-specific classes for byte elements or keys.
|
| it.unimi.dsi.fastutil.chars |
Provides type-specific classes for character elements or keys.
|
| it.unimi.dsi.fastutil.doubles |
Provides type-specific classes for double elements or keys.
|
| it.unimi.dsi.fastutil.floats |
Provides type-specific classes for float elements or keys.
|
| it.unimi.dsi.fastutil.ints |
Provides type-specific classes for integer elements or keys.
|
| it.unimi.dsi.fastutil.longs |
Provides type-specific classes for long elements or keys.
|
| it.unimi.dsi.fastutil.objects |
Provides type-specific classes for object elements or keys.
|
| it.unimi.dsi.fastutil.shorts |
Provides type-specific classes for short elements or keys.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractStack<K>
An abstract class providing basic methods for implementing the
Stack interface. |
| Modifier and Type | Interface and Description |
|---|---|
interface |
BooleanStack
A type-specific
Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractBooleanBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface.
|
static class |
AbstractBooleanBigList.BooleanSubList
A class implementing a sublist view.
|
class |
AbstractBooleanList
An abstract class providing basic methods for lists implementing a type-specific list interface.
|
static class |
AbstractBooleanList.BooleanSubList
A class implementing a sublist view.
|
class |
AbstractBooleanStack
An abstract class providing basic methods for implementing a type-specific stack interface.
|
class |
BooleanArrayList
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
class |
BooleanBigArrayBigList
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
|
static class |
BooleanBigLists.ListBigList
A class exposing a list as a big list.
|
static class |
BooleanBigLists.Singleton
An immutable class representing a type-specific singleton big list.
|
static class |
BooleanLists.Singleton
An immutable class representing a type-specific singleton list.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
ByteStack
A type-specific
Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractByteBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface.
|
static class |
AbstractByteBigList.ByteSubList
A class implementing a sublist view.
|
class |
AbstractByteList
An abstract class providing basic methods for lists implementing a type-specific list interface.
|
static class |
AbstractByteList.ByteSubList
A class implementing a sublist view.
|
class |
AbstractByteStack
An abstract class providing basic methods for implementing a type-specific stack interface.
|
class |
ByteArrayFrontCodedList
Compact storage of lists of arrays using front coding.
|
class |
ByteArrayList
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
class |
ByteBigArrayBigList
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
|
static class |
ByteBigLists.ListBigList
A class exposing a list as a big list.
|
static class |
ByteBigLists.Singleton
An immutable class representing a type-specific singleton big list.
|
static class |
ByteLists.Singleton
An immutable class representing a type-specific singleton list.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
CharStack
A type-specific
Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractCharBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface.
|
static class |
AbstractCharBigList.CharSubList
A class implementing a sublist view.
|
class |
AbstractCharList
An abstract class providing basic methods for lists implementing a type-specific list interface.
|
static class |
AbstractCharList.CharSubList
A class implementing a sublist view.
|
class |
AbstractCharStack
An abstract class providing basic methods for implementing a type-specific stack interface.
|
class |
CharArrayFrontCodedList
Compact storage of lists of arrays using front coding.
|
class |
CharArrayList
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
class |
CharBigArrayBigList
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
|
static class |
CharBigLists.ListBigList
A class exposing a list as a big list.
|
static class |
CharBigLists.Singleton
An immutable class representing a type-specific singleton big list.
|
static class |
CharLists.Singleton
An immutable class representing a type-specific singleton list.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
DoubleStack
A type-specific
Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractDoubleBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface.
|
static class |
AbstractDoubleBigList.DoubleSubList
A class implementing a sublist view.
|
class |
AbstractDoubleList
An abstract class providing basic methods for lists implementing a type-specific list interface.
|
static class |
AbstractDoubleList.DoubleSubList
A class implementing a sublist view.
|
class |
AbstractDoubleStack
An abstract class providing basic methods for implementing a type-specific stack interface.
|
class |
DoubleArrayList
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
class |
DoubleBigArrayBigList
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
|
static class |
DoubleBigLists.ListBigList
A class exposing a list as a big list.
|
static class |
DoubleBigLists.Singleton
An immutable class representing a type-specific singleton big list.
|
static class |
DoubleLists.Singleton
An immutable class representing a type-specific singleton list.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
FloatStack
A type-specific
Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractFloatBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface.
|
static class |
AbstractFloatBigList.FloatSubList
A class implementing a sublist view.
|
class |
AbstractFloatList
An abstract class providing basic methods for lists implementing a type-specific list interface.
|
static class |
AbstractFloatList.FloatSubList
A class implementing a sublist view.
|
class |
AbstractFloatStack
An abstract class providing basic methods for implementing a type-specific stack interface.
|
class |
FloatArrayList
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
class |
FloatBigArrayBigList
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
|
static class |
FloatBigLists.ListBigList
A class exposing a list as a big list.
|
static class |
FloatBigLists.Singleton
An immutable class representing a type-specific singleton big list.
|
static class |
FloatLists.Singleton
An immutable class representing a type-specific singleton list.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
IntStack
A type-specific
Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractIntBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface.
|
static class |
AbstractIntBigList.IntSubList
A class implementing a sublist view.
|
class |
AbstractIntList
An abstract class providing basic methods for lists implementing a type-specific list interface.
|
static class |
AbstractIntList.IntSubList
A class implementing a sublist view.
|
class |
AbstractIntStack
An abstract class providing basic methods for implementing a type-specific stack interface.
|
class |
IntArrayFrontCodedList
Compact storage of lists of arrays using front coding.
|
class |
IntArrayList
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
class |
IntBigArrayBigList
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
|
static class |
IntBigLists.ListBigList
A class exposing a list as a big list.
|
static class |
IntBigLists.Singleton
An immutable class representing a type-specific singleton big list.
|
static class |
IntLists.Singleton
An immutable class representing a type-specific singleton list.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
LongStack
A type-specific
Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractLongBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface.
|
static class |
AbstractLongBigList.LongSubList
A class implementing a sublist view.
|
class |
AbstractLongList
An abstract class providing basic methods for lists implementing a type-specific list interface.
|
static class |
AbstractLongList.LongSubList
A class implementing a sublist view.
|
class |
AbstractLongStack
An abstract class providing basic methods for implementing a type-specific stack interface.
|
class |
LongArrayFrontCodedList
Compact storage of lists of arrays using front coding.
|
class |
LongArrayList
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
class |
LongBigArrayBigList
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
|
static class |
LongBigLists.ListBigList
A class exposing a list as a big list.
|
static class |
LongBigLists.Singleton
An immutable class representing a type-specific singleton big list.
|
static class |
LongLists.Singleton
An immutable class representing a type-specific singleton list.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractObjectBigList<K>
An abstract class providing basic methods for big lists implementing a type-specific big list interface.
|
static class |
AbstractObjectBigList.ObjectSubList<K>
A class implementing a sublist view.
|
class |
AbstractObjectList<K>
An abstract class providing basic methods for lists implementing a type-specific list interface.
|
static class |
AbstractObjectList.ObjectSubList<K>
A class implementing a sublist view.
|
class |
AbstractReferenceBigList<K>
An abstract class providing basic methods for big lists implementing a type-specific big list interface.
|
static class |
AbstractReferenceBigList.ReferenceSubList<K>
A class implementing a sublist view.
|
class |
AbstractReferenceList<K>
An abstract class providing basic methods for lists implementing a type-specific list interface.
|
static class |
AbstractReferenceList.ReferenceSubList<K>
A class implementing a sublist view.
|
class |
ObjectArrayList<K>
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
class |
ObjectBigArrayBigList<K>
A type-specific big-array-based big list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
static class |
ObjectBigLists.ListBigList<K>
A class exposing a list as a big list.
|
static class |
ObjectBigLists.Singleton<K>
An immutable class representing a type-specific singleton big list.
|
static class |
ObjectLists.Singleton<K>
An immutable class representing a type-specific singleton list.
|
class |
ReferenceArrayList<K>
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
class |
ReferenceBigArrayBigList<K>
A type-specific big-array-based big list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
static class |
ReferenceBigLists.ListBigList<K>
A class exposing a list as a big list.
|
static class |
ReferenceBigLists.Singleton<K>
An immutable class representing a type-specific singleton big list.
|
static class |
ReferenceLists.Singleton<K>
An immutable class representing a type-specific singleton list.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
ShortStack
A type-specific
Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractShortBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface.
|
static class |
AbstractShortBigList.ShortSubList
A class implementing a sublist view.
|
class |
AbstractShortList
An abstract class providing basic methods for lists implementing a type-specific list interface.
|
static class |
AbstractShortList.ShortSubList
A class implementing a sublist view.
|
class |
AbstractShortStack
An abstract class providing basic methods for implementing a type-specific stack interface.
|
class |
ShortArrayFrontCodedList
Compact storage of lists of arrays using front coding.
|
class |
ShortArrayList
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
class |
ShortBigArrayBigList
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
|
static class |
ShortBigLists.ListBigList
A class exposing a list as a big list.
|
static class |
ShortBigLists.Singleton
An immutable class representing a type-specific singleton big list.
|
static class |
ShortLists.Singleton
An immutable class representing a type-specific singleton list.
|
Copyright © 2019. All rights reserved.


Evaluating Text Extraction Algorithms
09 Jun 2011UPDATE 11/6/2011: Added the summary and the results table
Lately I've been working on evaluating and comparing algorithms, capable of extractinguseful content from arbitrary html documents. Before continuing I encourage you to pass trough some of my previous posts, just to get a better feel of what we're dealing with; I've written a short overview, compiled a list of resources if you want to dig deeper and made a feature wise comparison of related software and APIs.
Summary
- The evaluation environment presented in this post consists of 2 datasets with approximately 650 html documents.
- The gold standard of both datasets was produced by human annotators.
- 14 different algorithms were evaluated in terms of precision, recall and F1 score.
- The results have show that the best opensource solution is the boilerpipe library.
- Commercial APIs included in the evaluation environment produced consistent results on both datasets. Diffbot and Repustate API performed best, while others follow very closely.
- Readability's performance is surprisingly poor and lacking consistency between both ports that were put to use in the evaluation setup.
- Further work will include: adding more APIs and libraries to the setup, working on a new extraction technique and assembling a new dataset.
Evaluation Data
My evaluation setup consists of 2 fairly well known datasets:
- The final cleaneval evaluation dataset, with 681 documents (created by the ACL web-as-corpus community).
- Google news dataset, with 621 documents. (harvested by the authors of the boilerpipe library)
The former was harvested from all sorts of web pages, including: articles, blog posts, mailing list archives, forum conversations, dedicated form submission pages etc. The latter was gathered by scraping the google news stream for a longer period of time (cca 6 months). The random sample that became the final dataset of 621 documents from 408 different news type web sites, came from a larger set of 250k documents assembled during the scrapping process.
From their description and related documentation we can conclude that they represent 2 slightly distinctive domains: the google news dataset represents a specific domain of news articles and the cleaneval dataset represents a cross domain collection of documents.
The gold standard counterpart of both datasets was created by human annotators who assessed each document individually. Annotators who assembled the cleaneval gold standard, first used lynx text based browser to filter out all the non-text building blocks. Each annotator than cleaned out the redundant non-content text using his own visual interpretation of the website. On the other hand, annotators of the google news dataset inserted additional span tags (using class names as labels) into the original html document. The class names of span tags indicate the following content labels: headline, main text, supplemental text, user comments, related content. In my experimental setup I use only the content labeled under headline and main text as the gold standard.
As you might have noticed, these datasets are not as large as we would like them to be and there is a fairly good reason behind that: assessing and labeling html documents for content is a tedious task. So was the preprocessing of the cleaneval dataset on my part. The methodology of storing raw html documents for the cleaneval shared task included inserting a special <text> tag around the whole html markup to hold some meta data about the document itself. I had to remove these tags from all documents and insert the basic <html> and <body> tags to those who were obviously stripped of some starting and trailing boilerplate html markup. The reasoning of inserting such tags back into the raw html document is based on the nature of particular extraction software implementations which assume the existence of such tags.
Metrics
I'm using precision, recall and f1 score to evaluate the performance. I covered these in one of my previous posts, but here is a short recap:
Definitions:
Given an HTML document we predict/extract/retrieve a sequence of words and denote them as Sret. Consequentially the sequence of words representing relevant text is denoted as Srel .
Both sequences are constructed by the following procedure:
- Remove any sort of remaining inline html tags
- Remove all punctuation characters
- Remove all control characters
- Remove all non ascii characters (due to unreliable information of the document encoding)
- Normalize to lowercase
- Split on whitespace
The intersection of retrieved and the relevant sequence of words is calculated using the Ratcliff-Obershelff algorithm (python difflib).
As we're dealing with raw data, we have to account for 4 special cases of these metrics:
| Precision | Recall | F1-score | Case |
| 0 | 0 | inf | Missmatch - both retrieved and relevant sequences are not empty, but they don't intersect. |
| inf | 0 | nan | Set of retrieved words is empty - the extractor predicts that the observed document does not contain any content. |
| 0 | inf | nan | Set of relevant words is empty - the document itself does not contain anything useful. |
| inf | inf | nan | Both retrieved and relevant set is empty - the document does not contain nothing useful and the extractor comes back empty handed. |
Results
Currently my evaluation setup includes the following content extractors that were either already reviewed or mentioned in my preceding blog posts, so I won't get into the details of every single one in the context of this writeup:
- Boilerpipe - using two similar variants; the default extractor and the one especially tuned for article type of content.
- NCleaner - again using two of its variants; the non lexical n-gram character language independat model and the model trained on english corpora.
- Readability - using its python port and readability ported to node.js on top of jsdom.
- Pasternack & Roth algorithm (MSS) - authors provided me with access to the implementation presented in the www2009 paper.
- Goose - using my fork to expose the core content extraction functionality.
- Zextractor - internally used service developed by my friends/mentors at Zemanta.
- Alchemy API - using their text extraction API.
- Extractiv - using their semantic on demand RESTul API.
- Repustate API - using the clean html API call.
- Diffbot - using the article API.
Admittedly they are not all specialized for solving problems in a specific domain, say news article content extraction, but they all share one common property: they're capable of distinguishing useful textual content apart from boilerplate and useless content when observing an arbitrary html document.
Results were obtained by calculating precision and recall for each document in the dataset for every content extractor. Then we calculate the arithmetic mean of all three metrics for every extractor. Bar charts are employed to visualize the results.
| Cleaneval→ | precision | recall | f1 score |
| Boilerpipe DEF | 0.931 | 0.856 | 0.872 |
| Boilerpipe ART | 0.949 | 0.764 | 0.804 |
| Goose | 0.934 | 0.719 | 0.770 |
| MSS | 0.911 | 0.699 | 0.718 |
| Python Readability | 0.841 | 0.833 | 0.803 |
| Node Readability | 0.704 | 0.878 | 0.753 |
| Alchemy API | 0.950 | 0.828 | 0.854 |
| Diffbot | 0.932 | 0.890 | 0.891 |
| Extractiv | 0.935 | 0.871 | 0.887 |
| Repustate | 0.940 | 0.889 | 0.896 |
| Zextractor | 0.916 | 0.763 | 0.800 |
| NCleaner En | 0.923 | 0.895 | 0.897 |
| NCleaner NonLex | 0.882 | 0.927 | 0.892 |
| Google news→ | precision | recall | f1 score |
| Boilerpipe DEF | 0.863 | 0.938 | 0.887 |
| Boilerpipe ART | 0.931 | 0.955 | 0.939 |
| Goose | 0.934 | 0.887 | 0.901 |
| MSS | 0.907 | 0.882 | 0.875 |
| Python Readability | 0.638 | 0.825 | 0.681 |
| Node Readability | 0.688 | 0.968 | 0.789 |
| Alchemy API | 0.936 | 0.876 | 0.888 |
| Diffbot | 0.924 | 0.968 | 0.935 |
| Extractiv | 0.824 | 0.956 | 0.870 |
| Repustate | 0.917 | 0.907 | 0.898 |
| Zextractor | 0.850 | 0.806 | 0.803 |
| NCleaner En | 0.742 | 0.947 | 0.812 |
| NCleaner NonLex | 0.613 | 0.959 | 0.723 |
Next we explore the distribution of per document measurements. Instead of just calculating the mean of precision, recall and F1 score we can explore the frequencies of per document measurements. In the following chart we visualize frequencies for each metric for all extractors. Notice that we're splitting the [0,1] interval of each metric into 20 bins with equidistant intervals.
To account for previously mentioned 4 special cases, we employ a stacked bar chart to inspect the margins of useful/successful per document measurements for every dataset.
| Special cases of per document measurements - Cleaneval dataset |
Special cases of per document measurements - Google news dataset |
Every per document measurement can fall into one of the "special cases" category, "successful" category, or an extra "failed" category. The latter stands for measurement instances that failed due to: parsing errors, implementation specific errors, unsupported language errors etc. The right hand side of both figures depicts the same categories without the "successful" part.
This chart is important, because we only make use of measurements who fall under the "successful" category to obtain the distribution and mean for each metric, respectively.
Observations
The foremost observation is the varying performance of NCleaner outside the cleaneval domain, since both variants seem to perform poorly on the google news collection. The cause of such behavior might be the likelihood that NCleaner was trained on the cleaneval corpus.
Readability's poor performance came as a surprise, moreover, its varying results between both ports. Relatively low precision and high recall indicate that readability tends to include large portions of useless text in its output. I'm not quite satisfied of how readability is represented in this experiment as I'm not making use of the original implementation. The node.js port seems not to differ from the original as much as the python port, but I still worry I'll have to use the original implementation on top of a headless webkit browser engine like PhantomJS, to get a better representation.
Notice the consistent performance of commercial APIs (and zemanta's internal service), Alchemy API and Diffbot in particular. According to diffbot's co-founder Michael Tung, their article API is only a small portion of their technology stack. They're using common visual features of websites to train models in order to gain the understanding of various types of web pages (forum threads, photo galleries, contact info pages and about 50 other types). The article API used in this setup is just an additionally exposed model, trained on visual features of article type pages. On the other hand, zextractor (zemanta's internal service) leverages on libsvm to classify atomic text blocks of the newly observed document.
What I find especially interesting are the bimodal distributions of precision and/or recall for MSS and readability's python port. I suspect that they're failing to produce relevant content on really big documents or they're capable of extracting only a limited amount of content. It'll be interesting to explore this phenomena with some additional result visualizations.
Conclusion and Further Work
According to my evaluation setup and personal experience, the best open source solution currently available on the market is the boilerpipe library. If we treat precision with an equal amount of importance as recall (reflected in the F1 score) and take into account the performance consistency across both domains, then boilerpipe performs best. Performance aside, its codebase is seems to be quite stable and it works really fast.
If you're looking for an API and go by the same criteria (equal importance of precision and recall, performance consistency across both domains), diffbot seems to perform best, although alchemy, repustate and extractiv are following closely. If speed plays a greater role in your decision making process; Alchemy API seems to be a fairly good choice, since its response time could be measured in tenths of a second, while others rarely finish under a second .
My further work will be wrapped around adding new software to my evaluation environment (I was recently introduced to justext tool), compiling a new (larger) dataset and working on my own project, that'll hopefully yield some competative results.
Stay tuned for I'll be releasing all the data and code used in this evaluation setup in the near future.


Server and Version Info
User Statistics
Swagger OpenAPI JSON for API v1
Swagger OpenAPI JSON for API v2
API Help (v1 and v2)
Apply for Client ID
MiracleList Web UI
MiracleList Desktop App for Windows (Download, RAR Archive, ~43 MB)
MiracleList Desktop App for Linux (Download, RAR Archive, ~36 MB)
MiracleList Desktop App for MacOS (Download, ZIP Archive, ~44 MB)
Source Code on Github
Imprint


6.1.7 Blum-Blum-Shub Generator
The Blum-Blum-Shub pseudo random number generator is cryptologically
secure under the assumption that the quadratic residuosity problem is
intractable [8]. The algorithm consists of the following:
- Generate two large and distinct primes, p and q, each congruent to
3 mod 4.
Define m = pq.
- Select a seed s taking a value between 1 and m-1,
such that the greatest common divisor between s and m is
1.
- Let
x(0) = s * s mod m. For i = 1,2,... generate x(i) = x(i-1) * x(i-1) mod m,
z(i) = v least significant bits of x(i).
where v>=1
.
- The bit-sequence
z(1),z(2),z(3), ...
is then the output sequence used.


Source
(defmethod scan-contents ((marker (eql +p-object+))
(buffer serialization-buffer)
(gc mark-and-sweep-heap))
;; Hook into the garbage collector's scanner: when the scanner
;; finds a p-object, it adds that object to the gc's roots and
;; returns.
(let ((object-id (deserialize buffer)))
;; Add the object to the root set unless it's already marked.
(unless (object-alive-p (object-table gc) object-id)
;; By just pushing the child's id on the root list, we effectively
;; get a depth-first traversal.
(push object-id (roots gc)))))
Source Context


+ + +
+
+
Comparing sizes in our Solar System
Drag to zoom
+
created by Bethy Diakabana
|
data
|
images
+
+ + +


Welcome!
Visual Programming Guides for the everyday programmer
What I have created is simply a bunch of visual guides or explanations for the topics that are listed above. At one time or another every Developer has come across or had problems understanding some concepts. Sometimes reading all the material that is out there isn't enough you need something more visual that you can look at to really get or grasp what is going on or being used
Every Image in this resource is downloadable simply by clicking on the the button below the image
Here are a few quick examples.


HTML5 Image uploader with Jcrop (
Back to original tutorial
)
-- Image upload form --
Step1: Please select image file
Step2: Please select a crop region
File size
Type
Image dimension
W
H


SOCIAL ENGINEERING DISCUSSION
What is a social engineering attack?
In a social engineering attack, an attacker uses human interaction (social skills) to obtain or compromise information about an organization or its computer systems. An attacker may seem unassuming and respectable, possibly claiming to be a new employee, repair person, or researcher and even offering credentials to support that identity. However, by asking questions, he or she may be able to piece together enough information to infiltrate an organization's network. If an attacker is not able to gather enough information from one source, he or she may contact another source within the same organization and rely on the information from the first source to add to his or her credibility.
What is a phishing attack?
Phishing is a form of social engineering. Phishing attacks use email or malicious websites to solicit personal information by posing as a trustworthy organization. For example, an attacker may send email seemingly from a reputable credit card company or financial institution that requests account information, often suggesting that there is a problem. When users respond with the requested information, attackers can use it to gain access to the accounts.
Phishing attacks may also appear to come from other types of organizations, such as charities. Attackers often take advantage of current events and certain times of the year, such as
- natural disasters (e.g., Hurricane Katrina, Indonesian tsunami)
- epidemics and health scares (e.g., H1N1)
- economic concerns (e.g., IRS scams)
- major political elections
- holidays
How do you avoid being a victim?
- Be suspicious of unsolicited phone calls, visits, or email messages from individuals asking about employees or other internal information. If an unknown individual claims to be from a legitimate organization, try to verify his or her identity directly with the company.
- Do not provide personal information or information about your organization, including its structure or networks, unless you are certain of a person's authority to have the information.
- Do not reveal personal or financial information in email, and do not respond to email solicitations for this information. This includes following links sent in email.
- Don't send sensitive information over the Internet before checking a website's security. (See Protecting Your Privacy for more information.)
- Pay attention to the URL of a website. Malicious websites may look identical to a legitimate site, but the URL may use a variation in spelling or a different domain (e.g., .com vs. .net).
- If you are unsure whether an email request is legitimate, try to verify it by contacting the company directly. Do not use contact information provided on a website connected to the request; instead, check previous statements for contact information. Information about known phishing attacks is also available online from groups such as the Anti-Phishing Working Group.
- Install and maintain anti-virus software, firewalls, and email filters to reduce some of this traffic. (See Understanding Firewalls, Understanding Anti-Virus Software, and Reducing Spam for more information.)
- Take advantage of any anti-phishing features offered by your email client and web browser.
What do you do if you think you are a victim?
- If you believe you might have revealed sensitive information about your organization, report it to the appropriate people within the organization, including network administrators. They can be alert for any suspicious or unusual activity.
- If you believe your financial accounts may be compromised, contact your financial institution immediately and close any accounts that may have been compromised. Watch for any unexplainable charges to your account.
- Immediately change any passwords you might have revealed. If you used the same password for multiple resources, make sure to change it for each account, and do not use that password in the future.
- Watch for other signs of identity theft. (See Preventing and Responding to Identity Theft for more information.)
- Consider reporting the attack to the police, and file a report with the Federal Trade Commission


This inspection checks for comparisons of the name()-function against strings that contain a ":" - which usually indicates a hardwired namespace-prefix in the comparison. Such code will break when run against XML that uses a different prefix for the same namespace.
Example:
<xsl:if test="name() = 'xlink:href'">...<xsl:if>


Serialized Form
timeToLive
int timeToLive
- Time to live, in milliseconds
timestamps
java.util.Hashtable timestamps
- An internal Hashtable that stores a time to live timestamp associated
witheach entry (using the same key). The timestampt is the time in
millisecond at which the entry was putten + the time to live
numberOfGarbageCollectedEntriesSinceCreation
long numberOfGarbageCollectedEntriesSinceCreation
- Number of entries garbage collected since the creation of the
ConstantCapacityHashtable
readObject
public void readObject(java.io.ObjectInputStream in)
throws java.io.IOException
- Throws:
java.io.IOException
writeObject
public void writeObject(java.io.ObjectOutputStream out)
throws java.io.IOException
- Throws:
java.io.IOException
response
java.lang.String response
Copyright © -2004 JCaptcha corp.. All Rights Reserved.


Red Dwarf
Robert
28 yrs old
Robert is a U.S. Army veteran after 7 years of active duty. Left the Army in 2017 and drove semi-trucks. Robert had taught himself network engineering so after being told by a friend who had attended codefellows, Robert decided to give it a shot and has been loving it since.
Words of wisdom: True self-care is making the choice to build a life you dont need to regularly escape from.
 Completed his A-levels in a British boarding school in a small town called Ellesmere. Came to the US during his gap year to attend a coding boot-camp CodeFellows and to gain work experience. Before attending CodeFellows, Kris was a Business Development Manager at a start-up tech business called Anatomy Next.
Words of wisdom: The more you say "yes" is life the more exiting it will be
Dyson Sphere
Morgana
Almost 30
Morgana is a former theatrical costumer with a deep love of creating and puzzle solving. She is super excited to be entering the world of coding and exploring the scope it offers for expressing those passions.
Hobbies include (but are certainly not limited to), photography, painting, sewing, jewelry making, and writing (including one published short story).
Words of wisdom: Stay hydrated and know when it's time to stop.
Red Giant
Jon
OLD
Jon is a retired US Air Force officer who started programming back when dinosaurs walked the Earth.   Jon also is an author, painter, photographer, inventor, and public speaker on top of being the President of the International Association of Astronomical Artists (www.iaaa.org).
Words of wisdom: People are the sum of their life experiences, the only way to know who someone is is to listen to the stories they tell. Everyone has something interesting to say, so pay attention!


public class ParsecCursor
This file was autogenerated by JNAerator,
a tool written by Olivier Chafik that uses a few opensource projects..
For help, please visit NativeLibs4Java , Rococoa, or JNA.
public int size
Size in bytes of the cursor image buffer.
public int positionX
When leaving relative mode, the horizontal position in screen coordinates where the cursor reappears.
public int positionY
When leaving relative mode, the vertical position in screen coordinates where the cursor reappears.
public short width
Width of the cursor image in pixels.
public short height
Height of the cursor position in pixels.
public short hotX
Horizontal pixel position of the cursor hotspot within the image.
public short hotY
Vertical pixel position of the cursor hotspot within the image.
public byte modeUpdate
`true` if the cursor mode should be updated. The `relative`, `positionX`, and `positionY` members are valid.
public byte imageUpdate
`true` if the cursor image should be updated. The `width`, `height`, `hotX`, `hotY`, and `size` members are valid.
public byte relative
`true` if in relative mode, meaning the client should submit mouse motion in relative distances rather than absolute screen coordinates.
public kotlin.Array[] __pad
C type : uint8_t[1]


Study points blame at US Bank stadium for bird deaths
MINNEAPOLIS (AP) - A new study finds U.S. Bank Stadium and three high-rise buildings account for a high proportion of bird fatalities among 21 buildings surveyed in downtown Minneapolis.
The Star Tribune reports the study in PLOS One found the stadium and three unidentified towers were involved in 74% of collisions and 68% of fatalities among the buildings studied.
Data from two migratory seasons indicate around 111 birds died annually in collisions with the stadium.
The Minnesota Vikings and the stadium authority paid for the study, which was promoted by conservationists’ concerns about birds following the Mississippi River corridor colliding with the stadium’s glass walls.
Jerry Bahls of the Audubon Chapter of Minneapolis says the study appears to confirm their concerns and they want the Vikings and stadium authority to address the problem.
Information from: Star Tribune, http://www.startribune.com
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC.
Please read our comment policy before commenting.


--- layout: page title: STAT 757 — Fall 2020 ---
Time series of the difference in Arctic sea ice extent in March (the month of ice-extent maximum) and September
(the month of ice-extent minimum) from the mean values for the time period 1979-2007. Based on a least squares
linear regression, the rate of decrease for the March ice extents was 2.8% per decade and and September was 11.3% per decade.
Courtesy of NOAA - J. Richter-Menge, S. Nghiem, D. Perovich, I. Rigor (Public domain),
via Wikimedia Commons
This is the course web page for Applied Regression Analysis STAT 757 FALL 2020 – Section 1001. Please see the menus below for class resources, the up-to-date class schedule, assignments and solutions to homework and quizes.
The up-to-date schedule is in the table below.
| Week | Lecture slides | Activities | Homework, Quizzes, Midterms and Final |
|---|---|---|---|
| 08/24 - 08/28 | Introduction to scripting in R | Activity sheets: Supplementary materials: |
Homework 1:
|
| 08/31 - 09/04 | Simple linear regression | Supplementary Materials: |
Quiz 1:
|
| 09/07 - 09/11 |
Simple linear regression
| Supplementary Materials: |
Quiz 2:
|
| 09/14 - 09/18 | Analysis of variance and a matrix approach to simple regression | Supplementary Materials: |
Quiz 3:
|
| 09/21 - 09/25 | Midterm and review
|
Supplementary Materials: | Midterm 1:
|
| 09/28 - 10/02 | Multiple regression | Supplementary Materials: |
Quiz 4:
|
| 10/05 - 10/09 | Inference | Supplementary Materials: |
Quiz 5:
|
| 10/12 - 10/16 | Prediction and explanation | Supplementary Materials: |
Midterm 2:
|
| 10/19 - 10/23 | Diagnostics | Supplementary Materials: | |
| 10/26 - 10/30 | Diagnostics | Supplementary Materials: | |
| 11/02 - 11/06 | Linear and nonlinear transformations | Work on midterm project | |
| 11/09 - 11/13 | Model selection
|
Review week -- catch up on topics before final project | |
| 11/16 - 11/20 | Categorical predictors and a complete example |
Final project:
|
|
| 11/23 - 11/27 | Missing data and introduction to data assimilation | ||
| 11/30 - 12/04 | Final project review sessions | ||
| 12/07 - 12/11 | Final project review sessions |
|


So far we’ve introduced scalar fields and vector fields, and seen how the differential operator \(\underline{\nabla\mkern-2mu}\mkern 3mu\) can act on a scalar field \(f(\underline{x}):\mathbb{R}^n \to \mathbb{R}\) to give a vector field known as the gradient of the scalar field, \(\underline{\nabla\mkern-2mu}\mkern 3mu f\). We also saw that the gradient tells us the direction in which the scalar field increases fastest. As the title of this section suggests, we’re now going to see how we can define an action of \(\underline{\nabla\mkern-2mu}\mkern 3mu\) on vector fields \(\underline{v}(\underline{x}): \mathbb{R}^n \to \mathbb{R}^n\), and what these quantities can tell us about the original vector field.
Since \(\underline{\nabla\mkern-2mu}\mkern 3mu\) is a vector operator, and vector fields assign a vector \(\underline{v}(\underline{x})\) for each point \(\underline{x}\in \mathbb{R}^n\), we can take the dot product between \(\underline{\nabla\mkern-2mu}\mkern 3mu\) and \(\underline{v}(\underline{x})\). This quantity \(\underline{\nabla\mkern-2mu}\mkern 3mu .\underline{v}\) is the known as the divergence of \(\underline{v}\), and is also written as div \(\underline{v}\).
In the standard cartesian basis for \(\mathbb{R}^n\) \[\begin{aligned} \underline{v}(\underline{x}) &= \underline{e}_1 v_1(\underline{x}) + \underline{e}_2v_2(\underline{x}) + \dots + \underline{e}_n v_n(\underline{x}) \\ \Rightarrow \quad \quad\underline{\nabla\mkern-2mu}\mkern 3mu . \underline{v}\;\equiv\; {\rm div}\:\underline{v}&\equiv (\underline{e}_1 \frac{\partial}{\partial x_1} + \dots + \underline{e}_n \frac{\partial}{\partial x_n}) \: . \: (\underline{e}_1 v_1(\underline{x}) + \dots + \underline{e}_n v_n(\underline{x}) ) \\ &= \frac{\partial v_1}{\partial x_1} + \frac{\partial v_2}{\partial x_2} + \dots + \frac{\partial v_n}{\partial x_n} \\ &= \sum_{i=1}^n \frac{\partial v_i}{\partial x_i} \quad \quad\text{(index notation)} \\ &= \frac{\partial v_i}{\partial x_i}, \quad \quad\text{(Einstein Summation Convention)} \end{aligned}\] since the \(\underline{e}_a\) are orthonormal and constant.
Beware! In other coordinate systems the basis vectors \(\underline{e}_a\) might vary with \(\underline{x}\) and hence the formula needs more care. We may return to the divergence in other coordinate systems later in the term, depending on time.
Note: \(\underline{\nabla\mkern-2mu}\mkern 3mu . \underline{v}(\underline{x})\) is a scalar field, as can be seen in the following example.
\[\begin{aligned} \underline{v}(\underline{x}) &= (v_1(\underline{x}),v_2(\underline{x}),v_3(\underline{x})) \;=\; (x^2, y^2, z^2) \\ \underline{\nabla\mkern-2mu}\mkern 3mu .\underline{v}&= \frac{\partial x^2}{\partial x} + \frac{\partial y^2}{\partial y} + \frac{\partial z^2}{\partial z} \\ &= 2(x+y+z), \end{aligned}\] a number for each point \(\underline{x}=(x,y,z)\) not a vector.
Although we treat \(\underline{\nabla\mkern-2mu}\mkern 3mu\) like a vector, note that it is a vector differential operator, and therefore is not actually a vector in \(\mathbb{R}^n\) like \(\underline{x}\) is. Therefore although the inner product on \(\mathbb{R}^n\) is symmetric, note that \[\underline{\nabla\mkern-2mu}\mkern 3mu . \underline{v}\; \ne \; \underline{v}. \underline{\nabla\mkern-2mu}\mkern 3mu ,\] as the left-hand side of this is a scalar field, whereas the right-hand side is the (scalar) differential operator \[\left(x^2 \frac{\partial}{\partial x} + y^2\frac{\partial}{\partial y} + z^2\frac{\partial}{\partial z} \right)\] acting on scalar fields.
To get an intuition of what the divergence tells us about our vector field, we should think of our vector field as if it were a fluid, where the direction of a vector at a point tells us the direction of fluid flow at that point, and the magnitude of the vector tells us how fast the fluid is flowing at the point. The divergence of the vector field at a point then tells us whether the point is acting like a source (corresponding to positive divergence) or a sink (negative divergence) for the fluid. That is, whether more of the ‘fluid’ is entering than the point than is leaving. This is shown for a vector field \(\underline{v}\) in Figure 3, where the divergence at the origin is positive, negative and zero respectively.
| \(\underline{\nabla\mkern-2mu}\mkern 3mu .\underline{v}>0\) | \(\underline{\nabla\mkern-2mu}\mkern 3mu .\underline{v}<0\) | \(\underline{\nabla\mkern-2mu}\mkern 3mu .\underline{v}=0\) |
Let \(a,b\) be constants, \(f,g\) be scalar fields and \(\underline{v},\underline{w}\) vector fields, all in \(\mathbb{R}^n\). Then \[\begin{aligned} (i)& \underline{\nabla\mkern-2mu}\mkern 3mu .(a\underline{v}+ b\underline{w}) \;=\; a \underline{\nabla\mkern-2mu}\mkern 3mu .\underline{v}+ b \underline{\nabla\mkern-2mu}\mkern 3mu .\underline{w}\\ (ii)& \underline{\nabla\mkern-2mu}\mkern 3mu .(f\underline{v}) \;=\; (\underline{\nabla\mkern-2mu}\mkern 3mu f).\underline{v}+ f \underline{\nabla\mkern-2mu}\mkern 3mu .\underline{v} \end{aligned}\]
Proof: (i) This follows from linearity of the partial derivative: \[\begin{aligned} \underline{\nabla\mkern-2mu}\mkern 3mu . (a\underline{v}+ b\underline{w}) &= \frac{\partial (av_1 + bw_1)}{\partial x_1} + \dots + \frac{\partial (av_n + bw_n)}{\partial x_n} \\ &= a\frac{\partial v_1}{\partial x_1} + b\frac{\partial w_1}{\partial x_1} + \dots + a\frac{\partial v_n}{\partial x_n} + b\frac{\partial w_n}{\partial x_n} \\ &= a \left( \frac{\partial v_1}{\partial x_1} + \dots + \frac{\partial v_n}{\partial x_n} \right) + b \left( \frac{\partial w_1}{\partial x_1} + \dots + \frac{\partial w_n}{\partial x_n} \right) \\ &= a\underline{\nabla\mkern-2mu}\mkern 3mu .\underline{v}+ b \underline{\nabla\mkern-2mu}\mkern 3mu .\underline{w}. \end{aligned}\] (ii) First note that \(f\underline{v}\) is a vector field with components \((fv_1,fv_2, fv_3, \dots, fv_n)\), so \[\begin{aligned} \underline{\nabla\mkern-2mu}\mkern 3mu . (f\underline{v}) &= \frac{\partial fv_1}{\partial x_1}+\dots + \frac{\partial fv_n}{\partial x_n} \\ &= \frac{\partial f}{\partial x_1}v_1 + f\frac{\partial v_1}{\partial x_1} + \dots + \frac{\partial f}{\partial x_n}v_n + f\frac{\partial v_n}{\partial x_n} \\ &= \frac{\partial f}{\partial x_1}v_1 + \dots + \frac{\partial f}{\partial x_n}v_n \;+\; f\frac{\partial v_1}{\partial x_1} + \dots + f\frac{\partial v_n}{\partial x_n} \\ &= (\underline{\nabla\mkern-2mu}\mkern 3mu f).\underline{v}\:+\: f(\underline{\nabla\mkern-2mu}\mkern 3mu .\underline{v}). \end{aligned}\] Once we finish section 4, we’ll be able to derive this more effectively by using index notation.
Suppose \[\begin{aligned} f(\underline{x}) &= \underline{a}.\underline{x}\\ \underline{v}(\underline{x})&= \underline{a}\quad \quad\text{a constant} \\ \Rightarrow\quad \quad f\underline{v}&= (\underline{a}.\underline{x}) \underline{a}\\ &= (a_1x+a_2y+a_3 z)(a_1\underline{e}_1 + a_2\underline{e}_2 + a_3\underline{e}_3) \\ \Rightarrow\quad \underline{\nabla\mkern-2mu}\mkern 3mu .((\underline{a}.\underline{x}) \underline{a}) &= \frac{\partial}{\partial x}(a_1(a_1x+a_2y+a_3z)) \\ & +\frac{\partial}{\partial y}(a_2(a_1x+a_2y+a_3z)) \\ & +\frac{\partial}{\partial z}(a_3(a_1x+a_2y+a_3z)) \\ &= a_1^2 + a_2^2 + a_3^2 \;=\; \|\underline{a}\|^2 \quad \quad \end{aligned}\] by direct calculation. Or, using property (ii): \[\underline{\nabla\mkern-2mu}\mkern 3mu .((\underline{a}.\underline{x}) \underline{a}) \;=\; (\underline{\nabla\mkern-2mu}\mkern 3mu \underline{a}.\underline{x}). \underline{a}+ (\underline{a}.\underline{x}) \underline{\nabla\mkern-2mu}\mkern 3mu .\underline{a}.\] But \(\underline{\nabla\mkern-2mu}\mkern 3mu .\underline{a}=0\), while \[\begin{aligned} \underline{\nabla\mkern-2mu}\mkern 3mu (\underline{a}.\underline{x}) &= (\underline{e}_1\frac{\partial}{\partial x} + \underline{e}_2\frac{\partial}{\partial y} + \underline{e}_3\frac{\partial}{\partial z} ) (a_1x+a_2y+a_3z) \\ &= \underline{e}_1a_1 + \underline{e}_2a_2 + \underline{e}_3 a_3 \;=\; \underline{a}\\ \quad \quad\underline{\nabla\mkern-2mu}\mkern 3mu .((\underline{a}.\underline{x}) \underline{a}) &= \underline{a}.\underline{a}\;=\; \|\underline{a}\|^2 \end{aligned}\] agreeing with the direct calculation.
In 3 dimensions, there is a second type of product one can take between vectors, and this is the vector cross product. Recall that we define the vector product of two vectors \(\underline{A}\) and \(\underline{B}\) as \[\begin{aligned} \underline{A} \times \underline{B} &= \left| \begin{array}{ccc} \underline{e}_1 & \underline{e}_2 & \underline{e}_3 \\ A_1 & A_2 & A_3 \\ B_1 & B_2 & B_3 \\ \end{array} \right| \\ &= \underline{e}_1 (A_2 B_3 -A_3 B_2) + \underline{e}_2 (A_3B_1-A_1B_3) + \underline{e}_3 (A_1B_2 - A_2 B_1). \end{aligned}\]
Then, for a vector field \(\underline{v}(\underline{x})\) in 3 dimensions, define the curl of \(\underline{v}\) as \[\underline{\nabla\mkern-2mu}\mkern 3mu \times \underline{v}(\underline{x}) \;\equiv\; {\rm curl}\: \underline{v}\:\equiv\; \left| \begin{array}{ccc} \underline{e}_1 & \underline{e}_2 & \underline{e}_3 \\ \frac{\partial}{\partial x} & \frac{\partial}{\partial y} & \frac{\partial}{\partial z} \\ v_1 & v_2 & v_3 \\ \end{array} \right|,\] where we have to expand this always making sure that the derivatives \(\frac{\partial}{\partial x_i}\) are on the left of the \(v_i\). So therefore we have \[\begin{aligned} \underline{\nabla\mkern-2mu}\mkern 3mu \times \underline{v}(\underline{x}) &= \left| \begin{array}{ccc} \underline{e}_1 & \underline{e}_2 & \underline{e}_3 \\ \frac{\partial}{\partial x} & \frac{\partial}{\partial y} & \frac{\partial}{\partial z} \\ v_1 & v_2 & v_3 \\ \end{array} \right| &= \underline{e}_1 (\frac{\partial v_3}{\partial y} - \frac{\partial v_2}{\partial z}) + \underline{e}_2 (\frac{\partial v_1}{\partial z}-\frac{\partial v_3}{\partial x}) + \underline{e}_3 (\frac{\partial v_2}{\partial x} - \frac{\partial v_1}{\partial y}). \end{aligned}\] Note that the curl of a vector field is therefore a new vector field.
if \(\underline{v}: \mathbb{R}^3 \to \mathbb{R}^3\) is a vector field, and can be expressed in terms of its components as \(\underline{v}= (x^2z,xyz,x)\), then \[\begin{aligned} \text{curl } \underline{v}&= \underline{\nabla\mkern-2mu}\mkern 3mu \times \underline{v}\;=\; \left| \begin{array}{ccc} \underline{e}_1 & \underline{e}_2 & \underline{e}_3 \\ \frac{\partial}{\partial x} & \frac{\partial}{\partial y} & \frac{\partial}{\partial z} \\ x^2z & xyz & x \\ \end{array} \right| \\ &= \underline{e}_1 (\frac{\partial x}{\partial y} - \frac{\partial xyz}{\partial z}) + \underline{e}_2 (\frac{\partial x^2z}{\partial z}-\frac{\partial x}{\partial x}) + \underline{e}_3 (\frac{\partial xyz}{\partial x} - \frac{\partial x^2z}{\partial y}) \\ &= -xy \underline{e}_1 + (x^2-1) \underline{e}_2 + yz \underline{e}_3 \end{aligned}\]
Note that since \(\underline{\nabla\mkern-2mu}\mkern 3mu \times \underline{v}\) is a vector field, we can calculate its divergence. In the case of \(\underline{v}\) being the vector field from Example [eg:curl], \[\begin{aligned} \underline{\nabla\mkern-2mu}\mkern 3mu .(\underline{\nabla\mkern-2mu}\mkern 3mu \times \underline{v}) &= \frac{\partial}{\partial x}(-xy) + \frac{\partial}{\partial y} (x^2-1) + \frac{\partial}{\partial z}(yz) \\ &= -y +0 +y \;=\; 0. \end{aligned}\] In turns out that this is always true so long as \(\underline{v}\) has components with continuous second partial derivatives. We’ll come back to this in subsection 1.3.
The curl of a vector field \(\underline{v}\), tells us how much \(\underline{v}\) is ‘curling around’ at a point. If we imagine our vector field \(\underline{v}\) as a fluid, like when we thought about the meaning of the divergence (see subsection 1.1), the magnitude of the curl then tells us about the rotational speed of the fluid, and the direction of the curl then tells us which axis the fluid is rotating around. This axis is determined using the so-called ‘right-hand rule’: If you curl the fingers of your right hand, such that your fingers represent the rotation of the fluid, then your thumb points in the direction of the curl vector.
Consider the vector field \(\underline{v}\) with components \(\underline{v}=(-y,x,0)\). To imagine this vector field, realise that it is independent of \(z\), and so you can imagine the vector field in the \(z=0\) plane, and the vector field in any other plane of \(z\) is then just a translation of the vector field at \(z=0\). This \(z=0\) plane is shown in Figure 4
The curl of this vector field can then easily be checked to be \[\underline{\nabla\mkern-2mu}\mkern 3mu \times \underline{v}= (0,0,2),\] so is a vector field of constant magnitude pointing in the positive \(z\) direction, as one would expect using the right-hand rule.
Let \(a,b\) be constants, \(\underline{v},\underline{w}\) be vector fields, and \(f\) be a scalar field, all in \(\mathbb{R}^3\). Then: \[\begin{aligned} (i)& \underline{\nabla\mkern-2mu}\mkern 3mu \times(a\underline{u}+b\underline{v}) \;=\; a\underline{\nabla\mkern-2mu}\mkern 3mu \times\underline{u}+b \underline{\nabla\mkern-2mu}\mkern 3mu \times\underline{v}\\ (ii)& \underline{\nabla\mkern-2mu}\mkern 3mu \times(f\underline{v}) \;=\; (\underline{\nabla\mkern-2mu}\mkern 3mu f)\times \underline{v}+ f\underline{\nabla\mkern-2mu}\mkern 3mu \times\underline{v} \end{aligned}\]
Proof:
(i) follows from linearity of derivatives, as before.
Lets check (ii): \[\begin{aligned} \underline{\nabla\mkern-2mu}\mkern 3mu \times(f\underline{v}) =& \underline{e}_1 \left[ \frac{\partial}{\partial y}(fv_3) - \frac{\partial}{\partial z}(fv_2) \right] + \underline{e}_2 \left[ \frac{\partial}{\partial z}(fv_1) - \frac{\partial}{\partial x}(fv_3) \right] \\ &+ \underline{e}_3 \left[ \frac{\partial}{\partial x}(fv_2) - \frac{\partial}{\partial y}(fv_1) \right] \\ =&\ \underline{e}_1\left[ \left( \frac{\partial f}{\partial y} \right) v_3 + f\frac{\partial v_3}{\partial y} - \left( \frac{\partial f}{\partial z} \right) v_2 - f\frac{\partial v_2}{\partial z} \right] + \left[ \dots \right] + \left[ \dots \right] \\ =&\ \underline{e}_1 \left[ \left( \frac{\partial f}{\partial y} \right) v_3 - \left( \frac{\partial f}{\partial z} \right) v_2 \right] \;+\; \underline{e}_1 f \left[ \frac{\partial v_3}{\partial y} - \frac{\partial v_2}{\partial z} \right] + \dots + \dots \\ =&\ \underline{\nabla\mkern-2mu}\mkern 3mu f \times \underline{v}\:+\: f\underline{\nabla\mkern-2mu}\mkern 3mu \times\underline{v} \end{aligned}\]
This is tedious. Once we develop our index notation in section 4 we will be able to do this in a slicker way.
If \(f: \mathbb{R}^n\to \mathbb{R}\) is a scalar field then \(\underline{\nabla\mkern-2mu}\mkern 3mu f\) is a vector field and we can take its divergence. This is \[\begin{aligned} \underline{\nabla\mkern-2mu}\mkern 3mu .(\underline{\nabla\mkern-2mu}\mkern 3mu f) &= \text{div grad } f \equiv \nabla^2f \equiv \Delta f \\ &= \left( \underline{e}_1 \frac{\partial}{\partial x_1} + \dots + \underline{e}_n \frac{\partial}{\partial x_n} \right) . \left( \underline{e}_1 \frac{\partial}{\partial x_1} + \dots + \underline{e}_n \frac{\partial}{\partial x_n} \right) f \\ &= \frac{\partial^2 f}{\partial x_1^2} + \dots + \frac{\partial^2 f}{\partial x_n^2} \end{aligned}\] in cartesian coordinates - note that it will look different in other coordinates if the basis vectors are not constant (as in the case of polar coordinates for example).
\(\Delta f \equiv \nabla^2f\) is called the Laplacian of \(f\). Since the Laplacian is the divergence of a vector field, it is a scalar field.
Note that you actually met the Laplacian in Calculus I, when you considered Linear Partial Differential Equations. In particular, the Laplacian is a differential operator that appears in Laplace’s Equation, the Heat Equation and the Wave Equation. More on this next term.
For \(n=2\), let \(f=log(x^2+y^2) = log(\underline{x}.\underline{x})\). Then \[\begin{aligned} \Rightarrow\quad \frac{\partial f}{\partial x} &= \frac{2x}{x^2+y^2}, \quad \frac{\partial^2 f}{\partial x^2} \;=\; \frac{2}{x^2+y^2}-\frac{4x^2}{(x^2+y^2)^2} \;=\; \frac{2(y^2-x^2)}{(x^2+y^2)^2} \\ \Rightarrow\quad \frac{\partial f}{\partial y} &= \frac{2y}{x^2+y^2}, \quad \frac{\partial^2 f}{\partial y^2} \;=\; \frac{2(x^2-y^2)}{(x^2+y^2)^2} \quad \quad\text{(just swap $x$ and $y$)}\\ \Rightarrow\quad \nabla^2f &= \frac{\partial^2 f}{\partial x^2} + \frac{\partial^2 f}{\partial y^2} \;=\; \frac{2(y^2-x^2)}{(x^2+y^2)^2} + \frac{2(x^2-y^2)}{(x^2+y^2)^2} \\ &= 0 \quad \quad\text{if $\underline{x}\ne \underline{0}$} \end{aligned}\]
Again, with \(n=2\) let \(f=x^3-3xy^2\). Then \[\begin{aligned} \frac{\partial^2 f}{\partial x^2} &= \frac{\partial}{\partial x}(3x^2-3y^2) \;=\; 6x \\ \frac{\partial^2 f}{\partial y^2} &= \frac{\partial}{\partial y}(-6xy) \;=\; -6x \\ \Rightarrow\quad \nabla^2f &= 0 \end{aligned}\] Notice: If we let \(z=x+iy\), then \(f= {\rm Re}[(x+iy)^3] = \text{Re}[z^3]\). If you study Complex Analysis II, you will see that this is a differentiable complex function. As such, the real and imaginary parts of the function satisfy the Cauchy-Riemann equations. One can show (exercise) that in this case the Laplacian of both the real and imaginary parts of the function have Laplacian equal to 0.
For \(n=3\) (i.e. in \(\mathbb{R}^3\)) there are a couple of other natural combinations. Firstly, since the gradient of a scalar field is a vector field, we can take its curl: \[\begin{aligned} \underline{\nabla\mkern-2mu}\mkern 3mu \times\underline{\nabla\mkern-2mu}\mkern 3mu f &= \left| \begin{array}{ccc} \underline{e}_1 & \underline{e}_2 & \underline{e}_3 \\ \frac{\partial}{\partial x} & \frac{\partial}{\partial y} & \frac{\partial}{\partial z} \\ \frac{\partial f}{\partial x} & \frac{\partial f}{\partial y} & \frac{\partial f}{\partial z} \\ \end{array} \right| \\ &= \underline{e}_1 (\frac{\partial}{\partial y}\frac{\partial f}{\partial z} - \frac{\partial}{\partial z}\frac{\partial f}{\partial y}) + \underline{e}_2 (\frac{\partial}{\partial z}\frac{\partial f}{\partial x} - \frac{\partial}{\partial x}\frac{\partial f}{\partial z}) + \underline{e}_3 (\frac{\partial}{\partial x}\frac{\partial f}{\partial y} - \frac{\partial}{\partial y}\frac{\partial f}{\partial x}) \nonumber\\ &= \underline{0}, \end{aligned}\] assuming the 2nd partial derivatives of \(f\) are continuous (so we can equate \(\frac{\partial^2 f}{\partial y \partial z} = \frac{\partial^2 f}{\partial z \partial y}\) etc.). Also in \(\mathbb{R}^3\), we can find the divergence of a curl. We did this once follow example [eg:curl], but in general \[\begin{aligned} \underline{\nabla\mkern-2mu}\mkern 3mu .(\underline{\nabla\mkern-2mu}\mkern 3mu \times\underline{v}) &= \underline{\nabla\mkern-2mu}\mkern 3mu . \left| \begin{array}{ccc} \underline{e}_1 & \underline{e}_2 & \underline{e}_3 \\ \frac{\partial}{\partial x} & \frac{\partial}{\partial y} & \frac{\partial}{\partial z} \\ v_1 & v_2 & v_3 \\ \end{array} \right| \\ &= \frac{\partial}{\partial x} (\frac{\partial v_3}{\partial y} - \frac{\partial v_2}{\partial z}) + \frac{\partial}{\partial y} (\frac{\partial v_1}{\partial z}-\frac{\partial v_3}{\partial x}) + \frac{\partial}{\partial z} (\frac{\partial v_2}{\partial x} - \frac{\partial v_1}{\partial y}) \\ &= \underline{0}, \end{aligned}\] again, assuming the 2nd partial derivatives of \(f\) are continuous. Later we will redo these cases in a more elegant way using index notation.


|
Entity - entity handle
Alpha# - alpha level of entity |
|
Sets the entity alpha level of an entity.
The alpha# value should be in a floating point value in the range 0-1. The default entity alpha setting is 1. The alpha level is how transparent an entity is. A value of 1 will mean the entity is opaque. A value of 0 will mean the entity is completely transparent, i.e. invisible. Values between 0 and 1 will cause varying amount of transparency. This is useful for imitating the look of objects such as glass and other translucent materials. An EntityAlpha value of 0 is especially useful as Blitz3D will not render entities with such a value, but will still involve the entities in collision tests. This is unlike HideEntity, which doesn't involve entities in collisions. |
|
; EntityAlpha Example
; ------------------- Graphics3D 640,480 SetBuffer BackBuffer() camera=CreateCamera() light=CreateLight() RotateEntity light,90,0,0 cube=CreateCube() Back=CreateCube() PositionEntity cube,0,0,5 PositionEntity back,0,0,15 ScaleEntity Back,10,2,1 EntityColor back,255,0,0 ; Set initial entity color values Alpha#=1 While Not KeyDown( 1 ) ; Change alpha value depending on key pressed If alpha#<0.01 Then alpha# = 0 If alpha#>1 Then alpha# = 1 If KeyDown( 2 )=True And Alpha#>0 Then Alpha#=Alpha#-0.01 If KeyDown( 3 )=True And alpha#<1 Then Alpha#=Alpha#+0.01 ; Set entity alpha value EntityAlpha cube,Alpha# TurnEntity cube,0.1,0.1,0.1 TurnEntity back,1,0,0 RenderWorld Text 0,0,"Press keys 1-2 to change EntityAlpha" Text 0,20,"Entity Alpha: "+Alpha Flip Wend End |


Foods (eg. sandwiches, salads, soups, breads, pastries, yoghurts, fruits) are collected from food stores close to the store's closing time and transported to the Imperial College Union kitchen (ICU Kitchen). This not only redistributes unwanted food, but also reduces food waste.
Map of key locations & collection points
Hot drinks, which are tea, coffee and hot chocolate, are made in the Union Kitchen*.
Drink Recipe:
Hot water can be boiled using the kettle and pots. Below describes the other ingredients that are used for the different drinks. We make sure that everything is mixed well by borrowing the giant kitchen spoon.
| Coffee | Chocolate | Tea |
| 1/2 pot coffee powder 750ml milk Add sugar to taste |
1 Cadbury choc. powder 2 Sainsbury choc. powder 500ml milk |
1 silver pack tea 750ml milk Add sugar to taste |
All the food are usually organised into the following categories: ham and pork, vegetarian, chicken, fish, salads and soups, bread, and desserts.The food and drinks are then loaded into the van ready to leave. Before leaving the kitchen and the storage area are locked up.*
* The driver will pick up the van and park it in the back entrance (first floor) of ICU, which leads directly outside Albert Hall. The keys for the storage and the kitchen are returned.At 7:50pm, we start the journey to the distribution point (LIF). To prevent disappointment of people missing food because we came early or of us coming late, we aim to arrive at exactly 8:30pm. Roles for who are in charge of distributing what are assigned in the bus ride. Afterwards, we usually mingle with the guests. :) Then we make the trip back.
After returning back to the Union Kitchen, we wash up and return all the things into the storage area. Finally, we're done (:
* The driver returns the van. The Union kitchen key is borrowed from FIveSixEight for access to the kitchen. A member in the key list will borrow and return the storage key.


Select which mode you would like to play in.
Easy
Medium
Difficult
Insane
Get your current high score for this game.


person
Bryan Cranston
person
Aaron Paul
person
Bob Odenkirk
person
Corrie Quintana
person
Bertram Bank
person
Russel Bigger
person
Therese Biggins
person
Kassandra Holford


29 Mar 2014
This week we have released a much requested feature by our customers:
analytics.
The importance of analytics to search
At Algolia, our goal is to revolutionize the way people search and access
content inside the Web and mobile services. Think about Spotify, LinkedIn,
Amazon: Everyone wants to find the right songs, people and products in just a
couple keystrokes. Our challenge is to provide fast and meaningful access to
all of this content via a simple search box. In March, we answered more than
200 million user queries for our customers on every continent.
Providing the right content through the right search and browsing experience
is key. For our customers, understanding their users - what they like, what
they want and when they want it - is just as important, if not more. This is
why we came up with this new analytics section, built on top of our API and
available on our customers' online dashboards when they log in to their
Algolia account. So what exactly do we track for you?
We describe here some of the top features that are now available to all our
users.
Most popular queries
In this chart, we show which items were most queried. It would be useful, for
example, to a procurement department for anticipating their most frequently-
searched products' inventory needs. And if you monetize your service through
advertising, know what people are most interested in is especially valuable.
A new analytics feature supports the most popular queries.
Queries with no or a few results
Today, most services are simply clueless when it comes to what is missing in
their content base. How do you know that your catalogue of products fits your
users' expectations? Knowing whether or not you provide what your users need
is critical for your business.
Algolia lets you determine which top queries have few or
nonexistent results.
How does a query evolve over time?
Is Chanel more popular than Louis Vuitton in the morning or at night? Are
bikes more popular in June or in December? With this new feature, you can now
answer such questions for your own content by following the number of times a
specific query is typed on an hourly basis.
Example: Search
analytics lets you track the evolution of the query "louboutin" over 24
hours.
Which categories do people search the most?
When users type in a query, they often use categories to refine the results.
We let you know which categories were the most frequently used for refinement.
We even provide the most used combinations of categories (such as "dress" +
"blue" + "size M"). It should help you understand how your users browse your
content and has broader implications if the ergonomics of your app is
optimized.
Track which
combinations of categories people search for the most.
These new analytics features are included in our existing plans at no extra
cost. The number of days when our analytics tools are available vary based on
the plan you choose. We hope you will like it, and we will be more than happy
to read your feedback and feature requests!
25 Mar 2014
As you may probably know, we're using HipChat to build our live-help chat. If
you want to know more, go ahead and read our guest post on HipChat's
blog.
Algolia uses HipChat to
provide live customer service over chat.
18 Mar 2014
Edit: As suggested on Hacker
News, SHA256 is not secure, as
it allows a length extension attack. We have replaced it with HMAC-SHA256.
Instant is in our DNA, so our first priority was to build a search backend
that would be able to return relevant realtime search results in a few
milliseconds. However, the backend is just one variable in our realtime
equation. The response time perceived by the end user is the total lapse of
time between their first keystroke and the final display of their results.
Thus, with an extremely fast backend, solving this equation comes down to
optimising network latency. This is an issue we solve in two steps:
- First, we have datacenters in three different locations, allowing us to answer queries in North America, Europe and Asia in less than 100ms (including search computation).
- Second, to keep reducing this perceived latency, queries must be sent directly from the end users' browsers or mobile phones to our servers. To avoid intermediaries like your own servers, we offer a JavaScript client for websites and ObjC/Android/C# clients for mobile apps.
The security challenge of JavaScript
Using this client means that you need to include an API key in your JavaScript
(or mobile app) code. The first security issue with this approach is that this
key can be easily retrieved by anyone who simply looks at the code of the
page. This gives that person the potential to modify the content behind the
website/mobile application! To fix this problem, we provide search-only API
keys which protect your indexes from unauthorized modifications.
This was a first step and we've quickly had to solve two other security
issues:
- *Limiting the ability to crawl your data: *you may not want people to get all your data by continuous querying. The simple solution was to limit the number of API calls a user could perform in a given period of time. We implemented this by setting a rate limit per IP address. However, this approach is not acceptable if a lot of users are behind a global firewall, thus sharing one IP address. This is very likely for our corporate users.
- Securing access control: you may need to restrict the queries of a user to specific content. For example, you may have power users who should get access to more content than "regular" users. The easy way to do it is by using filters. The problem here with simple filters in your JavaScript code is that people can figure out how to modify these filters and get access to content they are not be supposed to see.
How we solve it altogether
Today, most websites and applications require people to create an account and
log in to access a personalized experience (think of CRM applications,
Facebook or even Netflix). We decided to use these user IDs to solve these two
issues by creating signed API keys. Let's say you have an API key with search
only permission and want to apply a filter on two groups of content (public OR
powerusersonly) for a specific user (id=42):
api_key=20ffce3fdbf036db955d67645bb2c993
query_filters=(public,power_users_only)
user_token=42
You can generate a secured API key in your backend that is defined by a hash
(HMAC SHA 256) of three elements:
secured_api_key=HMAC_SHA_256(api_key, query_filters + user_token)
secured_api_key=HMAC_SHA_256("20ffce3fdbf036db955d67645bb2c993", "(public,power_users_only)" + "42")
secured_api_key="3abb95c273455ce9b57c61ee5258ba44093f17022dd4bfb39a37e56bee7d24a5"
For example, if you are using rails, the code in your backend would be:
secured_key = Algolia.generate_secured_api_key('20ffce3fdbf036db955d67645bb2c993', '(public,power_users_only)', '42')
You can then initialize your JavaScript code with the secured API key and
associated information:
The user identifier (defined by SetUserToken) is used instead of the IP
address for the rate limit and the security filters (defined by
SetSecurityTags) are automatically applied to the query.
In practice, if a user wants to overstep her rights, she will need to modify
her security tags and figure out the new hash. Our backend checks if a query
is legit by computing all the possible hashes using all your available API
keys for the queried index, as well as the security tags defined in the query
and the user identifier (if set). If there is no match between the hash of
the query and the ones we computed, we will return a permission denied (403).
Don't worry, reverse-engineering the original API key using brute-force would
require years and thousands of
core.
You may want to apply security filters without limiting the rate of queries,
so if you don't need both of these features, you can use only one.
We launched this new feature a few weeks ago and we have received very good
feedback so far. Our customers don't need to choose anymore between security
and realtime search. If you see any way to improve this approach, we would
love to hear your feedback!
17 Mar 2014
During a few hours on March 17th you may have noticed longer response times
for some of the queries sent by your users.
Average latency for one of our European clusters on March 17th
As you can see above, our slowest average response time (measured from the
user's browser to our servers and back to the user's browser) on one of our
European clusters peaked at 858ms. On a normal day, this peak is usually no
higher than 55ms.
This was clearly not a normal behavior for our API, so we investigated.
How indexing and search calls share the resource
Each cluster handles two kinds of calls on our REST API: the ones to build and
modify the indexes (Writes) and the ones to answer users' queries (Search).
The resources of each cluster are shared between these two uses. As Write
operations are far more expensive than Search calls, we designed our API so
that indexing should never use more than 10% of these resources.
Up until now, we used to set a limitation on the rate of Writes per HTTP
connection. There was no such limit for queries (Search); We simply limited
Write calls to keep search quality. To avoid reaching the Write rate limit too
quickly, we recommended users to Write by batching up to 1GB of operations per
call, rather than sending them one by one. (A batch, for example, could be
adding 1M products to an index on a single network call.) A loophole in this
recommendation was the origin of yesterday's issues.
What happened yesterday is that on one of our European clusters, one customer
pushed so many unbatched indexing calls from different HTTP connections that
they massively outnumbered the search calls of the other users on the cluster.
This eventually slowed down the average response time for the queries on this
cluster, impacting our usual search performance.
The Solution
As of today, we now set the rate limit of Writes per account and not per
HTTP connection. It prevents anyone from using multiple connections to bypass
this Write rate limit. This also implies that customers who want to push a lot
of operations in a short time simply need to send their calls in batches.
How would you batch your calls? The explanation is in our documentation. See
here for an example with our Ruby client: https://github.com/algolia
/algoliasearch-client-ruby#batch-writes
15 Mar 2014
We launched the first beta of our Heroku add-on in October 2013 and are now
happy to announce its general availability!
During the beta period we received excellent feedback (and some bug reports!)
that helped us improve our integration. We are now fully ready to serve
production on both Heroku datacenters. If you were part of our beta program,
we will contact you shortly to invite you to migrate to a standard plan.
You can directly install it from our Heroku add-on
page and as ever, please let us
know if you have any feedback!


scores = []
if len(ft) == 0: return 0.0 // invalid length for first string
for x in second:
scores.append(max([_levenshtein_distance(x, y) for y in ft]))
s = np.sum(scores) / maxlen
return s
for o in n[:5]:
ft_1.add(o)
ft_2 = set() // all related words with second sentence
for x in second:
ft_2.add(x)
n, _ = nearby(x)


Here we provide details how to reproduce experiments from our
papers via Collective
Knowledge Framework and Repository (CK). All artifacts are
shared via CK
"reproduce-ck-paper" repository at GitHub. If you have
CK installed (docs),
you can download and install this repository via CMD simply asck pull repo:reproduce-ck-paperWe would like to thank the community for validating various results and sharing unexpected behavior with us via our public CK repository! |
Nowadays, engineers have to develop software often without even knowing which hardware it will eventually run on in numerous mobile phones, tablets, desktops, laptops, data centers, supercomputers and cloud services. Unfortunately, optimizing compilers are not keeping pace with ever increasing complexity of ever changing computer systems anymore and may produce severely underperforming executable codes while wasting expensive resources and energy.
We present the first to our knowledge practical, collaborative and publicly available solution to this problem. We help the software engineering community gradually implement and share light-weight wrappers around any software piece with more than one implementation or optimization choice available. These wrappers are connected with a public Collective Mind autotuning infrastructure and repository of knowledge * to continuously monitor all important characteristics of these pieces (computational species) across numerous existing hardware configurations in realistic environments together with randomly selected optimizations. At the same time, Collective Mind Node allows to easily crowdsource time-consuming autotuning across existing Android-based mobile device including commodity mobile phones and tables.
Similar to natural sciences, we can now continuously track all winning solutions (optimizations for a given hardware such as compiler flags, OpenCL/CUDA/OpenMP/MPI/skeleton parameters, number of threads and any other exposed by users) that minimize all costs of a computation (execution time, energy spent, code size, failures, memory and storage footprint, optimization time, faults, contentions, inaccuracy and so on) of a given species on a Pareto frontier along with any unexpected behavior at c-mind.org/repo. Furthermore, the community can continuously classify solutions, prune redundant ones, and correlate them with various features of software, its inputs (data sets) and used hardware either manually (similar to Wikipedia) or using available big data analytics and machine learning techniques.
Our approach can also help computer engineering community create the first public, realistic, large, diverse, distributed, representative, and continuously evolving benchmark with related optimization knowledge while gradually covering all possible software and hardware to be able to predict best optimizations and improve compilers depending on usage scenarios and requirements. Such continuously growing collective knowledge accessible via simple web service can become an integral part of the practical software and hardware co-design of self-tuning computer systems as we demonstrate in several real usage scenarios validated in industry.
* Note that we have moved all our developments to a newer, smaller, simpler and faster version of Collective Mind aka Collective Knowledge or CK. This open source, BSD-licensed framework with a live repository is available here: http://github.com/ctuning/ck and http://cknowledge.org/repo. Documentation with all examples is also available at http://github.com/ctuning/ck/wiki.
CK scripts: reproduce-filter-speedup
CK datasets:
| Data set "image-raw-bin-fgg-office-day-gray" (features) | Data set "image-raw-bin-fgg-office-night-gray" (features) |
Lenovo X240; Intel(R) Core(TM) i5-4210U CPU @ 1.70GHz; Ubuntu 14.04 64bit; GCC 4.4.4
(CK public repo: all experiments,
compiler description,
all compilers)
| Dataset image-raw-bin-fgg-office-day-gray: | Dataset image-raw-bin-fgg-office-night-gray: | ||
| Optimization: | Binary size: | min time (s); exp time (s); var (%): | min time (s); exp time (s); var (%): |
| -O3 | 10776 | 4.622 ; 4.634 ; 0.7% | 4.630 ; 4.653 ; 1.0% |
| -O3 -fno-if-conversion | 10784 | 5.169 ; 5.193 ; 1.0% (Slow down over -O3: 1.12) | 4.091 ; 4.094 ; 0.2% (Speed up over -O3: 1.14) |
| -O2 | 10168 | 4.631 ; 4.754 ; 10.2% | 4.623 ; 4.639 ; 0.7% |
| -O1 | 10152 | 4.621 ; 4.633 ; 0.8% | 4.623 ; 4.685 ; 3.6% |
| -Os | 9744 | 4.668 ; 4.678 ; 0.6% | 4.666 ; 4.685 ; 0.9% |
Lenovo X240; Intel(R) Core(TM) i5-4210U CPU @ 1.70GHz; Ubuntu 14.04 64bit; GCC 4.9.1
(CK public repo: all experiments,
compiler description,
all compilers)
| Dataset image-raw-bin-fgg-office-day-gray: | Dataset image-raw-bin-fgg-office-night-gray: | ||
| Optimization: | Binary size: | min time (s); exp time (s); var (%): | min time (s); exp time (s); var (%): |
| -O3 | 11008 | 4.619 ; 4.630 ; 0.6% | 4.603 ; 4.628 ; 1.0% (slower than GCC 4.4.4 -O3 -fno-if-conversion) |
| -O3 -fno-if-conversion | 11008 | 4.615 ; 4.625 ; 0.6% | 4.624 ; 4.628 ; 0.3% (slower than GCC 4.4.4 -O3 -fno-if-conversion) |
| -O2 | 10880 | 4.632 ; 4.635 ; 0.1% | 4.602 ; 4.647 ; 2.5% |
| -O1 | 10360 | 4.625 ; 4.637 ; 0.7% | 4.630 ; 4.654 ; 1.8% |
| -Os | 10376 | 4.635 ; 4.653 ; 0.8% | 4.630 ; 4.652 ; 0.8% |
Lenovo X240; Intel(R) Core(TM) i5-4210U CPU @ 1.70GHz; Ubuntu 14.04 64bit; GCC 5.2.0
(CK public repo: all experiments,
compiler description,
all compilers)
| Dataset image-raw-bin-fgg-office-day-gray: | Dataset image-raw-bin-fgg-office-night-gray: | ||
| Optimization: | Binary size: | min time (s); exp time (s); var (%): | min time (s); exp time (s); var (%): |
| -O3 | 10776 | 4.622 ; 4.632 ; 0.8% | 4.630 ; 4.631 ; 0.2%(slower than GCC 4.4.4 -O3 -fno-if-conversion) |
| -O3 -fno-if-conversion | 10776 | 4.629 ; 4.649 ; 0.8% | 4.610 ; 4.626 ; 1.1%(slower than GCC 4.4.4 -O3 -fno-if-conversion) |
| -O2 | 10568 | 4.599 ; 4.610 ; 0.6% | 4.597 ; 4.603 ; 0.4% |
| -O1 | 10032 | 4.613 ; 4.616 ; 0.2% | 4.605 ; 4.616 ; 0.8% |
| -Os | 10088 | 4.609 ; 4.630 ; 1.4% | 4.608 ; 4.615 ; 0.4% |
Just for comparison during crowd-benchmarking: Samsung Chromebook 2; Samsung EXYNOS5; ARM Cortex A15/A7; ARM Mali-T628; Ubuntu 12.04 32bit; GCC 4.9.2
(CK public repo: all experiments,
compiler description,
all compilers)
| Dataset image-raw-bin-fgg-office-day-gray: | Dataset image-raw-bin-fgg-office-night-gray: | ||
| Optimization: | Binary size: | min time (s); exp time (s); var (%): | min time (s); exp time (s); var (%): |
| -O3 | 7416 | 7.396 ; 7.513 ; 2.9% | 7.390 ; 7.464 ; 2.6% |
| -O3 -fno-if-conversion | 7424 | 7.345 ; 7.455 ; 3.8% | 7.384 ; 7.490 ; 2.6% |
| -O2 | 7100 | 7.398 ; 7.926 ; 39.2% | 7.450 ; 7.514 ; 2.3% |
| -O1 | 7072 | 7.404 ; 7.444 ; 1.4% | 7.389 ; 7.443 ; 2.9% |
| -Os | 6292 | 7.367 ; 7.409 ; 1.5% | 7.375 ; 7.479 ; 2.7% |


REPORT: Patriots Have ‘Kicked The Tires’ On Bringing Back Antonio Brown
by Darrelle LincolnJust a little over 2 months ago, the New England Patriots parted ways with Antonio Brown due to his behavior of sending text messages to a sexual assault accuser, but things have seemingly changed since that time period.
WEEI in Boston is reporting the Patriots have ‘kicked the tires’ on the idea of bringing the controversial wide receiver back on the team.
Brown took to social media on Tuesday and formally apologized to owner Robert Kraft following his release from the team. Even Tom Bradfy and several other Patriots players liked that post.
Brown only played one game for the franchise and lasted just eleven days before things soured. He grabbed four catches including a touchdown, on eight targets during New England’s 43-0 win over the Dolphins.
Brady has already stated how much he likes Brown and has griped about the team’s offense, especially after the team’s win over the Eagles last Sunday.


Welcome to PEM, the newest event management website. We offer services to different occasions. Our services are one of a kind meant to last a lifetime, talk about your weddind, kid's birthday parties, anniversaries, meetings either formal or informal, or any occasion you want to celebrate; Count on us!


I am currently under a program of BS in Computer Engineering. I am 21 years old of age, I was born on April 10 2000.
2017-2018
AUTOMOTIVE SERVICING (K-12), TANZA NATIONAL TRADE SCHOOL
2018-2021
BACHELOR OF SCIENCE IN COMPUTER ENGINEERING, CVSU-CCAT CAMPUS
> Web Front end stuffs (HTML, CSS, JS)
> Have knowledge in Java Programming
> Arduino programming
> Have knowledge in core C# and C++
> Windows form application using C# (OOP)
I like programming and such things that can train or enhance my logical abilities and my creativity as well