Unofficial BSP v30 File Spec
Table of content
- Introduction
- Header
- LUMP_ENTITIES
- LUMP_PLANES
- LUMP_TEXTURES
- LUMP_VERTICES
- LUMP_VISIBILITY
- LUMP_NODES
- LUMP_TEXINFO
- LUMP_FACES
- LUMP_LIGHTING
- LUMP_CLIPNODES
- LUMP_LEAVES
- LUMP_MARKSURFACES
- LUMP_EDGES
- LUMP_SURFEDGES
- LUMP_MODELS
Introduction
The following file specification concerns the BSP file format version 30, as it has been designed by the game developper Valve and used in their famous GoldSrc Engine. The file extension is ".bsp".
Important: The following informations do NOT rely on any officially published file specification from Valve Corporation. The file format is still in use by the proprietary Half-Life Engine (better known name of the GoldSrc Engine) implying that there is no public source code of either the file loader or renderer. The following specification has been put together based on informations from the open source project Black Engine as well as the compilers included in the Half-Life SDK which also contains their source.
This file spec uses constructs from the C programming language to describe the different data structures used in the BSP file format. Architecture dependent datatypes like integers are replaced by exact-width integer types of the C99 standard in the stdint.h header file, to provide more flexibillity when using x64 platforms. Basic knowledge about Binary Space Partitioning is recommended. There is a common struct used to represent a point in 3-dimensional space which is used throughout the file spec and the code of the hlbsp project.
#include <stdint.h>
typedef struct _VECTOR3D
{
float x, y, z;
} VECTOR3D;
Header
Like almost every file also a BSP file starts with a specific file header which is constucted as follows:
#define LUMP_ENTITIES 0
#define LUMP_PLANES 1
#define LUMP_TEXTURES 2
#define LUMP_VERTICES 3
#define LUMP_VISIBILITY 4
#define LUMP_NODES 5
#define LUMP_TEXINFO 6
#define LUMP_FACES 7
#define LUMP_LIGHTING 8
#define LUMP_CLIPNODES 9
#define LUMP_LEAVES 10
#define LUMP_MARKSURFACES 11
#define LUMP_EDGES 12
#define LUMP_SURFEDGES 13
#define LUMP_MODELS 14
#define HEADER_LUMPS 15
typedef struct _BSPHEADER
{
int32_t nVersion; // Must be 30 for a valid HL BSP file
BSPLUMP lump[HEADER_LUMPS]; // Stores the directory of lumps
} BSPHEADER;
The file header begins with an 32bit integer containing the file version of the BSP file (the magic number). This should be 30 for a valid BSP file used by the Half-Life Engine. Subseqently, there is an array of entries for the so-called lumps. A lump is more or less a section of the file containing a specific type of data. The lump entries in the file header address these lumps, accessed by the 15 predefined indexes. A lump entry struct is defined as follows:
typedef struct _BSPLUMP
{
int32_t nOffset; // File offset to data
int32_t nLength; // Length of data
} BSPLUMP;
To read the different lumps from the given BSP file, every lump entry file states the beginning of each lump as an offset relativly to the beginning of the file. Additionally, the lump entry also gives the length of the addressed lump in bytes. The Half-Life BSP compilers also define several constants for the maximum size of each lump, as they use static, global arrays to hold the data. The hlbsp project uses malloc() to allocate the required memory for each lump depending on their actual size.
#define MAX_MAP_HULLS 4
#define MAX_MAP_MODELS 400
#define MAX_MAP_BRUSHES 4096
#define MAX_MAP_ENTITIES 1024
#define MAX_MAP_ENTSTRING (128*1024)
#define MAX_MAP_PLANES 32767
#define MAX_MAP_NODES 32767
#define MAX_MAP_CLIPNODES 32767
#define MAX_MAP_LEAFS 8192
#define MAX_MAP_VERTS 65535
#define MAX_MAP_FACES 65535
#define MAX_MAP_MARKSURFACES 65535
#define MAX_MAP_TEXINFO 8192
#define MAX_MAP_EDGES 256000
#define MAX_MAP_SURFEDGES 512000
#define MAX_MAP_TEXTURES 512
#define MAX_MAP_MIPTEX 0x200000
#define MAX_MAP_LIGHTING 0x200000
#define MAX_MAP_VISIBILITY 0x200000
#define MAX_MAP_PORTALS 65536
The following sections will focus on every lump of the BSP file.
The Entity Lump (LUMP_ENTITIES)
The entity lump is basically a pure ASCII text section. It consists of the string representations of all entities, which are copied directly from the input file to the output BSP file by the compiler. An entity might look like this:
{
"origin" "0 0 -64"
"angles" "0 0 0"
"classname" "info_player_start"
}
Every entity begins and ends with curly brackets. Inbetween there are the attributes of the entity, one in each line, which are pairs of strings enclosed by quotes. The first string is the name of the attribute (the key), the second one its value. The attribute "classname" is mandatory for every entity specifiying its type and therefore, how it is interpreted by the engine.
The map compilers also define two constants for the maximum length of key and value:
#define MAX_KEY 32
#define MAX_VALUE 1024
The Planes Lump (LUMP_PLANES)
This lump is a simple array of binary data structures:
#define PLANE_X 0 // Plane is perpendicular to given axis
#define PLANE_Y 1
#define PLANE_Z 2
#define PLANE_ANYX 3 // Non-axial plane is snapped to the nearest
#define PLANE_ANYY 4
#define PLANE_ANYZ 5
typedef struct _BSPPLANE
{
VECTOR3D vNormal; // The planes normal vector
float fDist; // Plane equation is: vNormal * X = fDist
int32_t nType; // Plane type, see #defines
} BSPPLANE;
Each of this structures defines a plane in 3-dimensional space by using the Hesse normal form:
normal * point - distance = 0
Where vNormal is the normalized normal vector of the plane and fDist is the distance of the plane to the origin of the coord system. Additionally, the structure also saves an integer describing the orientation of the plane in space. If nType equals PLANE_X, then the normal of the plane will be parallel to the x axis, meaning the plane is perpendicular to the x axis. If nType equals PLANE_ANYX, then the plane's normal is nearer to the x axis then to any other axis. This information is used by the renderer to speed up some computations.
The Texture Lump (LUMP_TEXTURES)
The texture lump is somehow a bit more complex then the other lumps, because it is possible to save textures directly within the BSP file instead of storing them in external WAD files. This lump also starts with a small header:
typedef struct _BSPTEXTUREHEADER
{
uint32_t nMipTextures; // Number of BSPMIPTEX structures
} BSPTEXTUREHEADER;
The header only consists of an unsigned 32bit integer indicating the number of stored or referenced textures in the texture lump. After the header follows an array of 32bit offsets pointing to the beginnings of the seperate textures.
typedef int32_t BSPMIPTEXOFFSET;
Every offset gives the distance in bytes from the beginning of the texture lump to one of the beginnings of the BSPMIPTEX structure, which are equal in count to the value given in the texture header.
#define MAXTEXTURENAME 16
#define MIPLEVELS 4
typedef struct _BSPMIPTEX
{
char szName[MAXTEXTURENAME]; // Name of texture
uint32_t nWidth, nHeight; // Extends of the texture
uint32_t nOffsets[MIPLEVELS]; // Offsets to texture mipmaps BSPMIPTEX;
} BSPMIPTEX;
Each of this structs describes a texture. The name of the texture is a string and may be 16 characters long (including the null-character at the end, char equals a 8bit signed integer). The name of the texture is needed, if the texture has to be found and loaded from an external WAD file. Furthermore, the struct contains the width and height of the texture. The 4 offsets at the end can either be zero, if the texture is stored in an external WAD file, or point to the beginnings of the binary texture data within the texture lump relative to the beginning of it's BSPMIPTEX struct.
The Vertices Lump (LUMP_VERTICES)
This lump simply consists of all vertices of the BSP tree. They are stored as a primitve array of triples of floats.
typedef VECTOR3D BSPVERTEX;
Each of this triples, obviously, represents a point in 3-dimensional space by giving its three coordinates.
The VIS Lump (LUMP_VISIBILITY)
The VIS lump contains data, which is irrelevant to the actual BSP tree,
but offers a way to boost up the speed of the renderer significantly.
Especially complex maps profit from the use if this data. This lump
contains the so-called Potentially Visible Sets (PVS) (also called VIS
lists) in the same amout of leaves of the tree, the user can enter
(often referred to as VisLeaves). The visiblilty lists are stored as
sequences of bitfields, which are run-length encoded.
Important: The generation of the VIS data is a very time
consuming process (several hours) and also done by a seperate compiler.
It can therefore be skipped when compiling the map, resulting in BSP
files with no VIS data at all!
The Nodes Lump (LUMP_NODES)
This lump is simple again and contains an array of binary structures, the nodes, which are a major part of the BSP tree.
typedef struct _BSPNODE
{
uint32_t iPlane; // Index into Planes lump
int16_t iChildren[2]; // If > 0, then indices into Nodes // otherwise bitwise inverse indices into Leafs
int16_t nMins[3], nMaxs[3]; // Defines bounding box
uint16_t firstFace, nFaces; // Index and count into Faces
} BSPNODE;
Every BSPNODE structure represents a node in the BSP tree and every node equals more or less a division step of the BSP algorithm. Therefore, each node has an index (iPlane) referring to a plane in the plane lump which devides the node into its two child nodes. The childnodes are also stored as indexes. Contrary to the plane index, the node index for the child is signed. If the index is larger than 0, the index indicates a child node. If it is equal to or smaller than zero (no valid array index), the bitwise inversed value of the index gives an index into the leaves lump. Additionally two points (nMins, nMaxs) span the bounding box (AABB, axis aligned bounding box) delimitting the space of the node. Finally firstFace indexes into the face lump and spezifies the first of nFaces surfaces contained in this node.
The Texinfo Lump (LUMP_TEXINFO)
The texinfo lump contains informations about how textures are applied to surfaces. The lump itself is an array of binary data structures.
typedef struct _BSPTEXTUREINFO
{
VECTOR3D vS;
float fSShift; // Texture shift in s direction
VECTOR3D vT;
float fTShift; // Texture shift in t direction
uint32_t iMiptex; // Index into textures array
uint32_t nFlags; // Texture flags, seem to always be 0
} BSPTEXTUREINFO;
This struct is mainly responsible for the calculation of the texture coordinates (vS, fSShift, vT, fTShift). This values determine the position of the texture on the surface. The iMiptex integer refers to the textures in the texture lump and would be the index in an array of BSPMITEX structs. Finally, there are 4 Bytes used for flags. Somehow they seem to always be 0;
The Faces Lump (LUMP_FACES)
The face lump contains the surfaces of the scene. Once again an array of structs:
typedef struct _BSPFACE
{
uint16_t iPlane; // Plane the face is parallel to
uint16_t nPlaneSide; // Set if different normals orientation
uint32_t iFirstEdge; // Index of the first surfedge
uint16_t nEdges; // Number of consecutive surfedges
uint16_t iTextureInfo; // Index of the texture info structure
uint8_t nStyles[4]; // Specify lighting styles
uint32_t nLightmapOffset; // Offsets into the raw lightmap data
} BSPFACE;
The first number of this data structure is an index into the planes lump giving a plane which is parallel to this face (meaning they share the same normal). The second value may be seen as a boolean. If nPlaneSide equals 0, then the normal vector of this face equals the one of the parallel plane exactly. Otherwise, the normal of the plane has to be multiplied by -1 to point into the right direction. Afterwards we have an index into the surfedges lump, as well as the count of consecutive surfedges from that position. Furthermore there is an index into the texture info lump, which is used to find the BSPTEXINFO structure needed to calculate the texture coordinates for this face. Afterwards, there are four bytes giving some lighting information (partly used by the renderer to hide sky surfaces). Finally we have an offset in byes giving the beginning of the binary lightmap data of this face in the lighting lump.
The Lightmap Lump (LUMP_LIGHTING)
This is one of the largest lumps in the BSP file. The lightmap lump stores all lightmaps used in the entire map. The lightmaps are arrays of triples of bytes (3 channel color, RGB) and stored continuously.
The Clipnodes Lump (LUMP_CLIPNODES)
This lump contains the so-called clipnodes, which build a second BSP tree used only for collision detection.
typedef struct _BSPCLIPNODE
{
int32_t iPlane; // Index into planes
int16_t iChildren[2]; // negative numbers are contents
} BSPCLIPNODE;
This structure is a reduced form of the BSPNODE struct from the nodes lump. Also the BSP tree built by the clipnodes is simpler than the one described by the BSPNODEs to accelerate collision calculations.
The Leaves Lump (LUMP_LEAVES)
The leaves lump contains the leaves of the BSP tree. Another array of binary structs:
#define CONTENTS_EMPTY -1
#define CONTENTS_SOLID -2
#define CONTENTS_WATER -3
#define CONTENTS_SLIME -4
#define CONTENTS_LAVA -5
#define CONTENTS_SKY -6
#define CONTENTS_ORIGIN -7
#define CONTENTS_CLIP -8
#define CONTENTS_CURRENT_0 -9
#define CONTENTS_CURRENT_90 -10
#define CONTENTS_CURRENT_180 -11
#define CONTENTS_CURRENT_270 -12
#define CONTENTS_CURRENT_UP -13
#define CONTENTS_CURRENT_DOWN -14
#define CONTENTS_TRANSLUCENT -15
typedef struct _BSPLEAF
{
int32_t nContents; // Contents enumeration
int32_t nVisOffset; // Offset into the visibility lump
int16_t nMins[3], nMaxs[3]; // Defines bounding box
uint16_t iFirstMarkSurface, nMarkSurfaces; // Index and count into marksurfaces array
uint8_t nAmbientLevels[4]; // Ambient sound levels
} BSPLEAF;
The first entry of this struct is the type of the content of this leaf. It can be one of the predefined values, found in the compiler source codes, and is litte relevant for the actual rendering process. All the more important is the next integer containing the offset into the vis lump. It defines the start of the raw PVS data for this leaf. If this value equals -1, no VIS lists are available for this leaf, usually if the map has been built without the VIS compiler. The next two 16bit integer triples span the bounding box of this leaf. Furthermore, the struct contains an index pointing into the array of marksurfaces loaded from the marksufaces lump as well as the number of consecutive marksurfaces belonging to this leaf. The marksurfaces are looped through during the rendering process and point to the actual faces. The final 4 bytes somehow spezify the volume of the ambient sounds.
The Marksurfaces Lump (LUMP_MARKSURFACES)
The marksurfaces lump is a simple array of short integers.
typedef uint16_t BSPMARKSURFACE;
This lump is a simple table for redirecting the marksurfaces indexes in the leafs to the actial face indexes. A leaf inserts it's marksurface indexes into this array and gets the associated faces contained within this leaf.
The Edges Lump (LUMP_EDGES)
The edges are defined as an array of structs:
typedef struct _BSPEDGE
{
uint16_t iVertex[2]; // Indices into vertex array
} BSPEDGE;
The edges delimit the face and further refer to the vertices of the face. Each edge is pointing to the start and end vertex of the edge.
The Surfedges Lump (LUMP_SURFEDGES)
Another array of integers.
typedef int32_t BSPSURFEDGE;
This lump represents pretty much the same mechanism as the marksurfaces. A face can insert its surfedge indexes into this array to get the corresponding edges delimitting the face and further pointing to the vertexes, which are required for rendering. The index can be positive or negative. If the value of the surfedge is positive, the first vertex of the edge is used as vertex for rendering the face, otherwise, the value is multiplied by -1 and the second vertex of the indexed edge is used.
The Models Lump (LUMP_MODELS)
Array of structs:
#define MAX_MAP_HULLS 4
typedef struct _BSPMODEL
{
float nMins[3], nMaxs[3]; // Defines bounding box
VECTOR3D vOrigin; // Coordinates to move the // coordinate system
int32_t iHeadnodes[MAX_MAP_HULLS]; // Index into nodes array
int32_t nVisLeafs; // ???
int32_t iFirstFace, nFaces; // Index and count into faces
} BSPMODEL;
A model is kind of a mini BSP tree. Its size is determinded by the bounding box spaned by the first to members of this struct. The major difference between a model and the BSP tree holding the scene is that the models use a local coordinate system for their vertexes and just state its origin in world coordinates. During rendering the coordinate system is translated to the origin of the model (glTranslate()) and moved back after the models BSP tree has been traversed. Furthermore their are 4 indexes into node arrays. The first one has proofed to index the root node of the mini BSP tree used for rendering. The other three indexes could probably be used for collision detection, meaning they point into the clipnodes, but I am not sure about this. The meaning of the next value is also somehow unclear to me. Finally their are direct indexes into the faces array, not taking the redirecting by the marksurfaces.


Samarkand
Samarkand is considered as on of the oldest cities in the world, and it was a key point of the Great Silk Road, and many conquerors left their mark here. It is an amazing city. One cannot put this city's all beauty and wealth into the words. Samarkand has a long and dramatic story: Samarkand was almost wiped out by the Mongols of Genghis Khan, then Tamerlan brought him back to life and made the capital of his vast empire, and under Ulugbek, the grandson of Tamerlane, many madrasahs were built in the city, so it became educational capital of the East. Almost all the unique artichectural monuments of the times of Tamerlene have been preserved here to this day.
Popular Monuments and Landmarks of Samarkand
Samarkand may not be called very popular tourist city, but travellers who reach it are delighted with the beauty of the local architecture, transferring to magical oriental tales, the hospotality of local residents, the amazing and very bright cuisine of these places.
Bibi Khanum Mosque
The name of Bibi-Khanum Mosque is very poetic as well as a legend, related with its construction. By the legend the mosque was built by the Tamerlane's favorite wife, Bibi-Khanum, in honor of his return from a trip to India.
Registan Square
The Registan Square is a real gem located in the very heart of the ancient city of Samarkand. It has gained its worldwide fame thanks to the great architectural ensemble that has become a monument of the oriental architecture.
UlughBek Observatory
UlughBek Observatory is considered as an astronomical miracle, one of the most significant medieval observatories. It was built by Ulughbek on the hilltop near Samarkand 1428-1429. During the reign of Ulugbek, Samarkand turned into one of the centers of science. He proved himself as a talented researchers in astronomy and mathematical sciences (geometry, trigonometry), well acquainted with the works of his predecessors.


2.7.2. Predicting Grades
In order for a student to predict their final grades, they must first select an empty cell in which to put a predicted grade as shown in Figure 1.
Figure 1: Predicting Grades
Figure 2 shows shows the result of the stdent inputing their temporary grades into the Final grade cell. The temporary "predicted" grades are highlighted in red. These temporary grades are never saved, and therefore will be deelted upon closing of the Grader program.
Figure 2: Predicting Grades
Prev: gradebooks
| Next: submit
| Up: student-functions
| Top: index


|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||
| SUMMARY: NESTED | ENUM CONSTANTS | FIELD | METHOD | DETAIL: ENUM CONSTANTS | FIELD | METHOD |
java.lang.Object java.lang.Enum<Queue.Access> ionic.Msmq.Queue.Access
public static enum Queue.Access
The Queue.Access enum provides options for access to the MSMQ Queue: Either Receive, Send, or both. Specify this when opening a queue.
Applications may wish to open queues for only the access they need, in order to save resources and memory.
| Enum Constant Summary | |
|---|---|
RECEIVE
The queue will be accessible for Receive or READ (or GET) operations. |
|
SEND
The queue will be accessible for Send or WRITE (or PUT) operations. |
|
SEND_AND_RECEIVE
The queue will be accessible for both Send ad Receive operations. |
| Method Summary | |
|---|---|
static Queue.Access |
valueOf(java.lang.String name)
Returns the enum constant of this type with the specified name. |
static Queue.Access[] |
values()
Returns an array containing the constants of this enum type, in the order they are declared. |
| Methods inherited from class java.lang.Enum |
|---|
clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf |
| Methods inherited from class java.lang.Object |
|---|
getClass, notify, notifyAll, wait, wait, wait |
| Enum Constant Detail |
|---|
public static final Queue.Access RECEIVE
public static final Queue.Access SEND
public static final Queue.Access SEND_AND_RECEIVE
| Method Detail |
|---|
public static Queue.Access[] values()
for (Queue.Access c : Queue.Access.values()) System.out.println(c);
public static Queue.Access valueOf(java.lang.String name)
name
- the name of the enum constant to be returned.
java.lang.IllegalArgumentException
- if this enum type has no constant
with the specified name
java.lang.NullPointerException
- if the argument is null
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||
| SUMMARY: NESTED | ENUM CONSTANTS | FIELD | METHOD | DETAIL: ENUM CONSTANTS | FIELD | METHOD |


crypto-api
/
net.corda.v5.crypto
/
CompositeKey
/
leafKeys
leafKeys
val
leafKeys
:
Set
<
PublicKey
>
Set of all leaf keys of that
CompositeKey
.


Timeout, in seconds, to apply when expecting data from the Docker API when performing the docker pull operation.
0 means no time limit, but this is not recommended (if your docker API locks up, some aspects of Jenkins can also lock up).
i.e. you probably want this set to as long as it takes to pull the entire image onto a fresh docker server.
e.g. a few minutes.
Note:
This overrides the read timeout specified for the cloud,
but only for the docker pull operation
(as this operation is expected to take longer than most docker operations).


PropertyChanges QML Type
Describes new property bindings or values for a state. More...
| Import Statement: | import QtQuick 2.7 |
Properties
- explicit : bool
- restoreEntryValues : bool
- target : Object
Detailed Description
PropertyChanges is used to define the property values or bindings in a State. This enables an item's property values to be changed when it changes between states.
To create a PropertyChanges object, specify the target item whose properties are to be modified, and define the new property values or bindings. For example:
import QtQuick 2.0 Item { id: container width: 300; height: 300 Rectangle { id: rect width: 100; height: 100 color: "red" MouseArea { id: mouseArea anchors.fill: parent } states: State { name: "resized"; when: mouseArea.pressed PropertyChanges { target: rect; color: "blue"; height: container.height } } } }
When the mouse is pressed, the Rectangle changes to the resized state. In this state, the PropertyChanges object sets the rectangle's color to blue and the height
value to that of container.height
.
Note this automatically binds rect.height
to container.height
in the resized state. If a property binding should not be established, and the height should just be set to the value of container.height
at the time of the state change, set the explicit property to true
.
A PropertyChanges object can also override the default signal handler for an object to implement a signal handler specific to the new state:
PropertyChanges { target: myMouseArea onClicked: doSomethingDifferent() }
Note: PropertyChanges can be used to change anchor margins, but not other anchor values; use AnchorChanges for this instead. Similarly, to change an Item's parent value, use ParentChange instead.
Resetting property values
The undefined
value can be used to reset the property value for a state. In the following example, when myText
changes to the widerText state, its width
property is reset, giving the text its natural width and displaying the whole string on a single line.
Rectangle { width: 300; height: 200 Text { id: myText width: 50 wrapMode: Text.WordWrap text: "a text string that is longer than 50 pixels" states: State { name: "widerText" PropertyChanges { target: myText; width: undefined } } } MouseArea { anchors.fill: parent onClicked: myText.state = "widerText" } }
Immediate property changes in transitions
When Transitions are used to animate state changes, they animate properties from their values in the current state to those defined in the new state (as defined by PropertyChanges objects). However, it is sometimes desirable to set a property value immediately during a Transition, without animation; in these cases, the PropertyAction type can be used to force an immediate property change.
See the PropertyAction documentation for more details.
Note: The visible and enabled properties of Item do not behave exactly the same as other properties in PropertyChanges. Since these properties can be changed implicitly through their parent's state, they should be set explicitly in all PropertyChanges. An item will still not be enabled/visible if one of its parents is not enabled or visible.
See also States example, Qt Quick States, and Qt QML.
Property Documentation
If explicit is set to true, any potential bindings will be interpreted as once-off assignments that occur when the state is entered.
In the following example, the addition of explicit prevents myItem.width
from being bound to parent.width
. Instead, it is assigned the value of parent.width
at the time of the state change.
PropertyChanges { target: myItem explicit: true width: parent.width }
By default, explicit is false.
This property holds whether the previous values should be restored when leaving the state.
The default value is true
. Setting this value to false
creates a temporary state that has permanent effects on property values.


Package Class
The Package class allows you to easily load, unload, check if a package is loaded, or get all packages loaded.
load($package, $path = null)
The load method allows you to load one or more packages at runtime. If the package cannot be found a PackageNotFoundException will be thrown.
| Static |
Yes |
| Parameters |
| Param |
Default |
Description |
| $package |
required |
Name of the package to be loaded, or an array of packages and package paths. |
| $path |
PKGPATH |
Name of the package to be loaded, or an array of packages and package paths. |
|
| Returns |
void |
| Example |
// load the orm package
Package::load('orm');
// load the parser package from a specific directory
Package::load('parser', '/path/to/packages/dir/');
// load multiple packages from a single package installation
Package::load( array('First' => PKGPATH.'my'.DS.'first'.DS, 'Last' => PKGPATH.'my'.DS.'last'.DS) );
// load the non-existent package
Package::load('awesome'); // Throws a PackageNotFoundException
|
unload($package)
The unload method allows you to unload a package at runtime.
| Static |
Yes |
| Parameters |
| Param |
Default |
Description |
| $package |
required |
Name of the package to be unload. |
|
| Returns |
void |
| Example |
// unload the orm package
Package::unload('orm');
|
loaded($package = null)
The loaded method allows you to check if a package is currently loaded. If no package name is given then all loaded packages are returned.
| Static |
Yes |
| Parameters |
| Param |
Default |
Description |
| $package |
null |
Name of the package to be check. |
|
| Returns |
bool|array |
| Example |
// Check if the orm package is loaded
$loaded = Package::loaded('orm');
// Get all loaded packages
$loaded = Package::loaded();
/*
Returns something like:
array(
'orm' => '/path/to/orm',
'parser' => '/path/to/parser',
)
*/
|


Invoice {{invoiceId}}
for {{companyName}}
issued on {{invoiceDate}}
from Insight Heroes
Thanks for your business. If you received this invoice in error, please contact {{email}}
May the force be with you!
Team IH
Insight Heroes OÜ
Roosikrantsi TN 2-K139, Tallinn City, Harju County, 10119


Some of our merchandise
1800cookies<EMAIL_ADDRESS>These are the voyages of the Salmon Cookie enterprise. To explore strange new streams. To seek out new life and new civilization. To boldly go where no fish has gone before!


Transfer from
Transfer to
Amount
Description
Transaction Name
alert("Output user not found.");
alert("Input user not found.");
alert("Output user and input user should be different.");
alert("Not enough fund.");


Module: ActiveRecord::Inheritance::ClassMethods
| Relationships & Source Files | |
| Defined in: | activerecord/lib/active_record/inheritance.rb |
Instance Attribute Summary
-
#abstract_class
rw
Set this to
true
if this is an abstract class (see #abstract_class?). -
#abstract_class? ⇒ Boolean
rw
Returns whether this class is an abstract class or not.
-
#base_class
readonly
Returns the class descending directly from
::ActiveRecord::Base
, or an abstract class, if any, in the inheritance hierarchy. -
#base_class? ⇒ Boolean
readonly
Returns whether the class is a base class.
-
#descends_from_active_record? ⇒ Boolean
readonly
Returns
true
if this does not need STI type condition.
Instance Method Summary
- #inherited(subclass)
-
#new(attributes = nil, &block)
Determines if one of the attributes passed in is the inheritance column, and if the inheritance column is attr accessible, it initializes an instance of the given subclass instead of the base class.
-
#polymorphic_class_for(name)
Returns the class for the provided
name
. -
#polymorphic_name
Returns the value to be stored in the polymorphic type column for Polymorphic Associations.
-
#sti_class_for(type_name)
Returns the class for the provided
type_name
. -
#sti_name
Returns the value to be stored in the inheritance column for STI.
Instance Attribute Details
#abstract_class (rw)
Set this to true
if this is an abstract class (see #abstract_class?). If you are using inheritance with Active Record and don’t want a class to be considered as part of the STI hierarchy, you must set this to true. ApplicationRecord
, for example, is generated as an abstract class.
Consider the following default behaviour:
Shape = Class.new(ActiveRecord::Base)
Polygon = Class.new(Shape)
Square = Class.new(Polygon)
Shape.table_name # => "shapes"
Polygon.table_name # => "shapes"
Square.table_name # => "shapes"
Shape.create! # => #<Shape id: 1, type: nil>
Polygon.create! # => #<Polygon id: 2, type: "Polygon">
Square.create! # => #<Square id: 3, type: "Square">
However, when using abstract_class
, Shape
is omitted from the hierarchy:
class Shape < ActiveRecord::Base
self.abstract_class = true
end
Polygon = Class.new(Shape)
Square = Class.new(Polygon)
Shape.table_name # => nil
Polygon.table_name # => "polygons"
Square.table_name # => "polygons"
Shape.create! # => NotImplementedError: Shape is an abstract class and cannot be instantiated.
Polygon.create! # => #<Polygon id: 1, type: nil>
Square.create! # => #<Square id: 2, type: "Square">
Note that in the above example, to disallow the creation of a plain Polygon
, you should use validates :type, presence: true
, instead of setting it as an abstract class. This way, Polygon
will stay in the hierarchy, and Active Record will continue to correctly derive the table name.
# File 'activerecord/lib/active_record/inheritance.rb', line 160
attr_accessor :abstract_class
#abstract_class? ⇒ Boolean
(rw)
Returns whether this class is an abstract class or not.
# File 'activerecord/lib/active_record/inheritance.rb', line 163
def abstract_class? defined?(@abstract_class) && @abstract_class == true end
#base_class (readonly)
Returns the class descending directly from ::ActiveRecord::Base
, or an abstract class, if any, in the inheritance hierarchy.
If A extends ::ActiveRecord::Base
, A.base_class
will return A. If B descends from A through some arbitrarily deep hierarchy, B.base_class
will return A.
If B < A and C < B and if A is an abstract_class then both B.base_class
and C.base_class
would return B as the answer since A is an abstract_class.
# File 'activerecord/lib/active_record/inheritance.rb', line 101
def base_class unless self < Base raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from ActiveRecord" end if superclass == Base || superclass.abstract_class? self else superclass.base_class end end
#base_class? ⇒ Boolean
(readonly)
Returns whether the class is a base class. See #base_class for more information.
# File 'activerecord/lib/active_record/inheritance.rb', line 115
def base_class? base_class == self end
#descends_from_active_record? ⇒ Boolean
(readonly)
Returns true
if this does not need STI type condition. Returns false
if STI type condition needs to be applied.
# File 'activerecord/lib/active_record/inheritance.rb', line 78
def descends_from_active_record? if self == Base false elsif superclass.abstract_class? superclass.descends_from_active_record? else superclass == Base || !columns_hash.include?(inheritance_column) end end
Instance Method Details
#inherited(subclass)
[ GitHub ]# File 'activerecord/lib/active_record/inheritance.rb', line 205
def inherited(subclass) subclass.instance_variable_set(:@_type_candidates_cache, Concurrent::Map.new) super end
#new(attributes = nil, &block)
Determines if one of the attributes passed in is the inheritance column, and if the inheritance column is attr accessible, it initializes an instance of the given subclass instead of the base class.
# File 'activerecord/lib/active_record/inheritance.rb', line 52
def new(attributes = nil, &block) if abstract_class? || self == Base raise NotImplementedError, "#{self} is an abstract class and cannot be instantiated." end if _has_attribute?(inheritance_column) subclass = subclass_from_attributes(attributes) if subclass.nil? && scope_attributes = current_scope&.scope_for_create subclass = subclass_from_attributes(scope_attributes) end if subclass.nil? && base_class? subclass = subclass_from_attributes(column_defaults) end end if subclass && subclass != self subclass.new(attributes, &block) else super end end
#polymorphic_class_for(name)
Returns the class for the provided name
.
It is used to find the class correspondent to the value stored in the polymorphic type column.
# File 'activerecord/lib/active_record/inheritance.rb', line 197
def polymorphic_class_for(name) if store_full_class_name ActiveSupport::Dependencies.constantize(name) else compute_type(name) end end
#polymorphic_name
Returns the value to be stored in the polymorphic type column for Polymorphic Associations.
# File 'activerecord/lib/active_record/inheritance.rb', line 190
def polymorphic_name store_full_class_name ? base_class.name : base_class.name.demodulize end
#sti_class_for(type_name)
Returns the class for the provided type_name
.
It is used to find the class correspondent to the value stored in the inheritance column.
# File 'activerecord/lib/active_record/inheritance.rb', line 175
def sti_class_for(type_name) if store_full_sti_class && store_full_class_name ActiveSupport::Dependencies.constantize(type_name) else compute_type(type_name) end rescue NameError raise SubclassNotFound, "The single-table inheritance mechanism failed to locate the subclass: '#{type_name}'. " \ "This error is raised because the column '#{inheritance_column}' is reserved for storing the class in case of inheritance. " \ "Please rename this column if you didn't intend it to be used for storing the inheritance class " \ "or overwrite #{name}.inheritance_column to use another column for that information." end
#sti_name
Returns the value to be stored in the inheritance column for STI.
# File 'activerecord/lib/active_record/inheritance.rb', line 168
def sti_name store_full_sti_class && store_full_class_name ? name : name.demodulize end


--- layout: default date: 08/10/2019 ---
Covers races from 21st August — 9th October.
Last updated: {{ page.date | date: "%A, %B %e" }}
{% include standings.html riders=site.data.2019.series_5.timetrial teams=site.data.2019.series_5.timetrialteam %} {% include datetime.html %}


Feed longitudinal data into a Bayesian Latent Factor Model to obtain a low-rank representation. Parameters are estimated using a Hamiltonian Monte Carlo algorithm with STAN. See G. Weinrott, B. Fontez, N. Hilgert and S. Holmes, "Bayesian Latent Factor Model for Functional Data Analysis", Actes des JdS 2016.
| Version: | 0.1.4 |
| Depends: | R (≥ 3.1.0) |
| Imports: | ade4, coda, MASS, Matrix, rstan, sde |
| Suggests: | fda, ggplot2, knitr, parallel, rmarkdown, testthat |
| Published: | 2016-12-05 |
| Author: | Gabrielle Weinrott [aut, cre], Brigitte Charnomordic [aut], Benedicte Fontez [aut], Nadine Hilgert [aut], Susan Holmes [aut] |
| Maintainer: | Gabrielle Weinrott <gabrielle.weinrott at supagro.inra.fr> |
| License: | GPL-3 |
| NeedsCompilation: | no |
| CRAN checks: | DrBats results |
| Reference manual: | DrBats.pdf |
| Vignettes: |
DrBats-Data_Simulation_and_Projection DrBats Dimension Reduction DrBats Project DrBats Model Evaluation DrBats Model Fit |
| Package source: | DrBats_0.1.4.tar.gz |
| Windows binaries: | r-devel: DrBats_0.1.4.zip, r-release: DrBats_0.1.4.zip, r-oldrel: DrBats_0.1.4.zip |
| OS X binaries: | r-release: DrBats_0.1.4.tgz, r-oldrel: DrBats_0.1.4.tgz |
| Old sources: | DrBats archive |
Please use the canonical form https://CRAN.R-project.org/package=DrBats to link to this page.


HTML Tags and Elements
HTML documants are made up of HTML elements, we tell the browser the type of element by using HTMLtags.
Inline vs Block elements
HTML elements are either inline or block. Block elements form an amount of space an ""invisible box" around the content inside of them.


A simple test for deciding whether to keep information is to ask
yourself these questions:
- Does the information relate to one of your meaningful
objectives? If not, delete it.
- Can you find the information somewhere else, such as another
department, a SharePoint site, your company intranet, or the
Internet? If so, delete it.
- Are you likely to refer to the information in the next six
months? If not, delete it.
- Do you have to keep the information because it is legal or
human resources information? If not, delete it.


Ole Gunnar Solskjaer issues update on Man Utd's January transfer plans
Man Utd boss Ole Gunnar Solskjaer has provided an update on their January transfer window intentions
by Rich Jones, https://www.mirror.co.uk/authors/rich-jones/Ole Gunnar Solskjaer admits Manchester United's transfer business could be limited in January.
The Red Devils are looking to strengthen their struggling squad after a miserable start to the campaign.
Attacking reinforcements are on the agenda as well as an extra midfielder after struggling for goals so far this campaign.
But Solskjaer says they are aware of the difficulties of doing business in January as he hinted they could wait until the summer to do the bulk of their business.
After signing youngsters Aaron Wan-Bissaka and Daniel James in the summer, as well as centre-back Harry Maguire, Solskjaer confirmed long-term additions are again on the agenda as he continues his rebuild.
Asked about their transfer plans ahead of their Europa League clash with Partizan Belgrade, Solskjaer told reporters: "The priority now is to get the players fit and get to the next round [of the Europa League ].
"We always look at the long term with transfers, it might be none, might be one, might be two in January.
"It's always the summer... you can’t really do too many big deals in January."
United can guarantee a place in the last 32 of the Europa League with a win on Thursday.
And Solskjaer says the emergence of several young players such as Mason Greenwood and Brandon Williams has been the major positive from the European competition so far.
Solskjaer added: "We’ve seen some young players getting a chance and doing well.
"Mason's [Greenwood] given us a winner, Brandon [Williams] was fantastic in Belgrade, Jimmy [Garner] came through that game really well. We have given other players a chance to play which is important in the long run.
"For me, it’s been good to give the young kids a chance. Good to see young players play games and we’ve kept three clean sheets and that’s impressive."


System Architect Symbol details for "Agent/Lifespan"
Active (State)
- Class Name:
Agent
- Sequence:
Intermediate
- Definitions Used:
-
Agent (Class)
end (Transition)
- From State:
Active
- To State:
Ended
- Class Name:
Agent
- From State:
Active
- To State:
Ended
- Definitions Used:
-
Agent (Class)
Ended (OO State)
end (Transition)
- From State:
Suspended
- To State:
Ended
- Class Name:
Agent
- From State:
Suspended
- To State:
Ended
- Definitions Used:
-
Agent (Class)
Ended (OO State)
Ended (State)
- Class Name:
Agent
- Sequence:
Final
- Definitions Used:
-
Agent (Class)
make active (Transition)
- From State:
Proposed
- To State:
Active
- Class Name:
Agent
- From State:
Proposed
- To State:
Active
- Definitions Used:
-
Agent (Class)
Active (OO State)
Proposed (State)
- Class Name:
Agent
- Sequence:
Initial
- Definitions Used:
-
Agent (Class)
suspend (Transition)
- From State:
Active
- To State:
Suspended
- Class Name:
Agent
- From State:
Active
- To State:
Suspended
- Definitions Used:
-
Agent (Class)
Suspended (OO State)
Suspended (State)
- Class Name:
Agent
- Sequence:
Intermediate
- Definitions Used:
-
Agent (Class)
unsuspend (Transition)
- From State:
Suspended
- To State:
Active
- Class Name:
Agent
- From State:
Suspended
- To State:
Active
- Definitions Used:
-
Agent (Class)
Active (OO State)


class AutoTransitionBuilder : TransitionSetBuilder<TransitionSet>
Builder for building a TransitionSet with AutoTransition already added. |
|
class DefaultTransitionSetBuilder : TransitionSetBuilder<TransitionSet>
Base builder for building a TransitionSet |
|
open class TransitionSetBuilder<T : TransitionSet> : TransitionBuilder<TransitionSet>
TransitionBuilder implementation for constructing TransitionSet instances. |


react over-scroll
A scroll based slideshow with wings.
npm install react-over-scroll
Description
OverScroll is a slide-show or content-slider, call it what you want. It is a full-screen/viewport element that snaps into fixed mode when it reaches the viewports top edge. Scrolling is now translated to paging, switching the content each time a predefined scroll amount has been reached. During an active slide two values are available. (See Render for more information). Take a look at the Demo to get a better understanding of the behavior.
Render
The children of OverScroll expect a function which is called with two arguments.
Example 1
const renderSlide = (slide, percent) => (

You are on Slide {slide + 1}

{percent}% of this slide has been scrolled

)
// Usage
// <OverScroll slides={10} children={renderSlide} />
Example 2
const pages = [
Hello
,
World
]
const slider = (
<OverScroll slides={pages.length}>
{(page, progress) => (

{pages[page]}

Page {page + 1}

<span style={{
width: `${progress}%`,
height: 10,
background: 'currentcolor'
}}/>

)}
</OverScroll>
)
// Usage
// {slider}
Development
If you want to build this module from source or contribute to this project you should follow the steps listed below.
Setup
npm install
Run dev server
npm start
Watch for file changes
npm run watch
Known issues: CSS does not work with livereload and requires a manual browser reload.


| Interface | Description |
|---|---|
| CompoundDatatype |
This interface is used as a base for compound datatypes.
|
| Length |
A length quantity in XSL
|
| Numeric |
An interface for classes that can participate in numeric operations.
|
| PercentBase |
Interface for objects that can be used as base objects for percentage
computations
|
| PercentBaseContext |
This interface is used by the layout managers to provide relevant information
back to the property percentage resolution logic, that is
the percentages based property getValue() functions expect an object implementing
this interface as an argument.
|
| Class | Description |
|---|---|
| FODimension |
This datatype hold a pair of resolved lengths,
specifiying the dimensions in
both inline and block-progression-directions.
|
| KeepValue |
Keep Value
Stores the different types of keeps in a single convenient format.
|
| LengthBase |
Models a length which can be used as a factor in a percentage length
calculation
|
| SimplePercentBaseContext |
Class to implement a simple lookup context for a single percent base value.
|
| URISpecification |
This class contains method to deal with the <uri-specification> datatype from XSL-FO.
|
| ValidationPercentBaseContext |
This base context is used during validation when the actual base values are still unknown
but should still already be checked.
|
XSL Datatypes.
Copyright 1999-2020 The Apache Software Foundation. All Rights Reserved.


How I learned to stop worring and love the join
Created by Dan Vatterott / @dvatterott
Read more here
SELECT
*
FROM
my_table
LIMIT 5
| Customer_id | listen_date | artist | artist_id | song_id |
|---|---|---|---|---|
| 1 | "2017-11-01" | "A Tribe Called Quest" | 5 | 1 |
| 2 | "2017-11-01" | "A Tribe Call Quest" | 5 | 7 |
| 2 | "2017-11-02" | "Wu-Tang Clan'" | 1 | 7 |
Create a list of people who listened to "A Tribe Called Quest".
SELECT
DISTINCT user_id
FROM
listen_table
WHERE
artist = "A Tribe Called Quest"
Create a list of people who listened to bands whose names start with "The".
SELECT
DISTINCT user_id
FROM
listen_table
WHERE
artist LIKE "The%"
Note: sql alchemy (python api) gets angry about % signs (use %%)
Create a list of the 10 people that listened to the most songs by "A Tribe Called Quest".
SELECT
user_id,
COUNT(song_id) AS song_count
FROM
listen_table
WHERE
artist = "A Tribe Called Quest"
GROUP BY
user_id
ORDER BY
song_count DESC
LIMIT 10
Create a list of the people that listened to more than 10 songs by "A Tribe Called Quest".
SELECT
user_id,
COUNT(song_id) AS song_count
FROM
listen_table
WHERE
artist = "A Tribe Called Quest"
GROUP BY
user_id
HAVING
COUNT(song_id) > 10
Note: Can't use select alias in where/having :/
This is an outer join.
Concentrate on what happens to missing/repeated values.
| artist_id | artist | member_count | music_genre |
|---|---|---|---|
| 5 | "A Tribe Called Quest" | 3 | "Hip Hop" |
| 1 | "Wu-Tang Clan" | 9 | "Hip Hop" |
| 2 | "Fugees" | 3 | "R and B" |
Create a list of the 10 people who listened to the most "Hip Hop".
SELECT
lt.user_id,
COUNT(DISTINCT lt.song_id ) AS listen_count
FROM
listen_table AS lt
INNER JOIN artist_table AS at
ON lt.artist_id = at.artist_id
WHERE
at.music_genre = "Hip Hop"
GROUP BY
lt.user_id
ORDER BY
listen_count
LIMIT 10
Create a list of the largest group (# members) in each genre.
SELECT
genre,
artist,
member_count
FROM
(SELECT
genre,
MAX(member_count) AS max_count
FROM
artist_table
GROUP BY
genre
) AS lt
INNER JOIN artist_table AS at
ON lt.genre = at.genre AND lt.max_count = at.member_count
Think about what happens with ties?
Create a list of the largest group (# members) in each genre.
WITH temp_table AS (
SELECT
genre,
MAX(member_count) AS max_count
FROM
artist_table
GROUP BY
genre
)
SELECT
genre,
artist,
member_count
FROM
temp_table AS tt
INNER JOIN artist_table AS at
ON tt.genre = at.genre AND tt.max_count = at.member_count
Create a list of the largest group (# members) in each genre.
SELECT
genre,
artist,
member_count
FROM
artist_table
WHERE
rank() OVER (PARTITION BY genre ORDER BY member_count DESC) = 1
Create a list of people who listened to "A Tribe Called Quest" and "Fugees".
WITH temp_table AS (
SELECT
DISTINCT user_id AS user_id
FROM
listen_table
WHERE
artist = 'A Tribe Called Quest'
)
SELECT
DISTINCT user_id AS user_id
FROM
listen_table
WHERE
artist = 'Fugees'
AND
user_id IN (SELECT user_id FROM temp_table)
Create a list of people who listened to "A Tribe Called Quest" and "Fugees".
WITH temp_table AS (
SELECT
DISTINCT user_id AS user_id
FROM
listen_table
WHERE
artist = 'A Tribe Called Quest'
)
SELECT
DISTINCT user_id AS user_id
FROM
listen_table AS lt
WHERE
artist = 'Fugees'
AND
EXISTS (
SELECT
1
FROM
temp_table
WHERE
temp_table.user_id = lt.user_id)
Create a list of people who listened to "A Tribe Called Quest" and "Fugees".

Count whether more songs are listened to on the weekends or weekdays.
SELECT
CASE
WHEN extract('dow' from listen_date) > 5 THEN 'weekend'
ELSE 'weekday'
END AS weekend_or_not,
COUNT(*)
FROM
listen_table AS lt
GROUP BY
weekend_or_not
Create a list of users and the first artist they listened to.
WITH temp_table AS (
SELECT
user_id,
artist,
rank() OVER (PARTITION BY user_id ORDER BY listen_date ASC)
FROM
listen_table
)
SELECT
user_id,
artist
FROM
temp_table
WHERE
rank = 1
Temp tables are faster when many tables. Joins are faster when using fewer tables.
The way that SQL handles null values is often not how you would expect.
SELECT
genre,
artist,
list_count
FROM
(SELECT
genre,
artist,
COUNT(*) AS listen_count
FROM
listen_table
GROUP BY
genre, artist_id
) AS lt
WHERE
rank() OVER (PARTITION BY genre ORDER BY listen_count DESC) = 1
Assumes each artist only has one genre listing.


| I l@ve RuBoard |
Now that we've taken a first look, let's fill in a few details behind Python's exception model.
When you write try statements, a variety of clauses can appear after the try statement block; Table 7.1 summarizes all the possible forms. We've already seen most of these in the previous examples—empty except clauses catch any exception, finally runs on the way out, and so on. There may be any number of excepts, but finally must appear by itself (without an else or except), and there should be only one else in a try.
|
Clause Form |
Interpretation |
|---|---|
except: |
Catch all (other) exception types |
except name: |
Catch a specific exception only |
except name, value: |
Catch exception and its extra data |
except (name1, name2): |
Catch any of the listed exceptions |
else: |
Run block if no exceptions raised |
finally: |
Always perform block |
The fourth entry in Table 7.1 is new. except clauses can also provide a set of exceptions to be caught, in parentheses; Python runs such a clause's statement block if any of the listed exceptions occur. Since Python looks for a match within a given try by inspecting except clauses from top to bottom, the parenthesized version is like listing each exception in its own except clause, except that the statement body needs to be coded only once.
Here's an example of multiple except clauses at work. In the following, when an exception is raised while the call to the action function is running, Python returns to the try and searches for the first except that catches the exception raised. It inspects expect clauses from top to bottom and left to right, and runs the statements under the first that matches. If none match, the exception is propagated past this try; the else runs only when no exception occurred. If you really want a catch-all clause, an empty except does the trick:
try: action() except NameError: ... except IndexError ... except KeyError: ... except (AttributeError, TypeError, SyntaxError): ... else: ...
So far, our examples have used only a single try to catch exceptions, but what happens if one try is physically nested inside another? For that matter, what does it mean if a try calls a function that runs another try? Both these cases can be understood if you realize that Python stacks try statements at runtime. When an exception is raised, Python returns to the most recently entered try statement with a matching except clause. Since each try statement leaves a marker, Python can jump back to earlier trys by inspecting the markers stack.
An example will help make this clear. The following module defines two functions; action2 is coded to trigger an exception (you can't add numbers and sequences), and action1 wraps a call to action2 in a try handler, to catch the exception. However, the top-level module code at the bottom wraps a call to action1 in a try handler too. When action2 triggers the TypeError exception, there will be two active try statements—the one in action1, and the one at the top level of the module. Python picks the most recent (youngest) with a matching except, which in this case is the try inside action1. In general, the place where an exception winds up jumping to depends on the control flow through a program at runtime:
def action2(): print 1 + [] # generate TypeError def action1(): try: action2() except TypeError: # most recent matching try print 'inner try' try: action1() except TypeError: # here only if action1 reraises print 'outer try' % python nestexc.py inner try
We've already talked about the finally clause, but here's a more sophisticated example. As we've seen, the finally clause doesn't really catch specific exceptions; rather, it taps into the exception propagation process. When used, a finally block is always executed on the way out of a try statement, whether the exit is caused by an exception or normal completion of the statements in the try block. This makes finally blocks a good place to code clean-up actions (like closing files, as in the previous example).
The next code snippet shows finally in action with and without exceptions. It defines two functions: divide, which may or may not trigger a divide-by-zero error, and tester, which wraps a call to divide in a try/finally statement:
def divide(x, y): return x / y # divide-by-zero error? def tester(y): try: print divide(8, y) finally: print 'on the way out...' print '\nTest 1:'; tester(2) print '\nTest 2:'; tester(0) # trigger error % python finally.py Test 1: 4 on the way out... Test 2: on the way out... Traceback (innermost last): File "finally.py", line 11, in ? print 'Test 2:'; tester(0) File "finally.py", line 6, in tester print divide(8, y) File "finally.py", line 2, in divide return x / y # divide-by-zero error? ZeroDivisionError: integer division or modulo
Now, the module's top-level code at the bottom calls tester twice:
The first call doesn't generate an exception (8/2 works fine), and the result (4) is printed. But the finally clause's block is run anyhow, so you get the on the way out message.
The second call does generate an exception (8/0 is a very bad thing to say). Control immediately jumps from the divide function to the finally block, and the message prints again. However, Python continues propagating the exception, which reaches the top level and runs the default exception action (a stack trace).
| I l@ve RuBoard |


The Politecnico di Milano (English: Polytechnic University of Milan) is the largest technical university in Italy, with about 40,000 students.[2] It offers undergraduate, graduate and higher education courses in engineering, architecture and design. Founded in 1863, it is the oldest university in Milan.


*** User 2017-05-05 21:51:22.015 ***
21:51:22.015 [info] Disabling blocking sync...
*** User 2017-05-05 21:51:22.020 ***
21:51:22.019 [info] Configured peer_service_manager partisan_default_peer_service_manager on node 'node-1@MacBook-Pro-de-Anne-France'
*** User 2017-05-05 21:51:23.490 ***
21:51:23.490 [info] Enabling membership...
*** User 2017-05-05 21:51:23.491 ***
21:51:23.491 [info] Disabling blocking sync...
*** User 2017-05-05 21:51:23.496 ***
21:51:23.496 [info] Configured peer_service_manager partisan_default_peer_service_manager on node 'node-2@MacBook-Pro-de-Anne-France'
*** User 2017-05-05 21:51:24.978 ***
21:51:24.978 [info] Enabling membership...
*** User 2017-05-05 21:51:24.979 ***
21:51:24.979 [info] Disabling blocking sync...
*** User 2017-05-05 21:51:24.985 ***
21:51:24.985 [info] Configured peer_service_manager partisan_default_peer_service_manager on node 'node-3@MacBook-Pro-de-Anne-France'
*** User 2017-05-05 21:51:25.232 ***
Joining node: 'node-3@MacBook-Pro-de-Anne-France' to 'runner@MacBook-Pro-de-Anne-France' at port 51628
*** User 2017-05-05 21:51:25.233 ***
Joining issued: 'node-3@MacBook-Pro-de-Anne-France' to 'runner@MacBook-Pro-de-Anne-France' at port 51628
*** User 2017-05-05 21:51:25.233 ***
Joining node: 'node-2@MacBook-Pro-de-Anne-France' to 'runner@MacBook-Pro-de-Anne-France' at port 51611
*** User 2017-05-05 21:51:25.233 ***
Joining issued: 'node-2@MacBook-Pro-de-Anne-France' to 'runner@MacBook-Pro-de-Anne-France' at port 51611
*** User 2017-05-05 21:51:25.234 ***
Joining node: 'node-1@MacBook-Pro-de-Anne-France' to 'runner@MacBook-Pro-de-Anne-France' at port 51599
*** User 2017-05-05 21:51:25.234 ***
Joining issued: 'node-1@MacBook-Pro-de-Anne-France' to 'runner@MacBook-Pro-de-Anne-France' at port 51599
*** User 2017-05-05 21:51:25.295 ***
Waiting for join to complete with manager: partisan_default_peer_service_manager
*** User 2017-05-05 21:51:25.296 ***
Finished.
*** CT 2017-05-05 21:51:25.297 *** COVER INFO
Adding nodes to cover test: ['runner@MacBook-Pro-de-Anne-France']
*** CT 2017-05-05 21:51:25.305 *** COVER INFO
Successfully added nodes to cover test: []
*** User 2017-05-05 21:51:25.349 ***
Case finished: monotonic_read_test
*** User 2017-05-05 21:51:32.394 ***
21:51:32.394 [info] Application lasp exited with reason: stopped
*** User 2017-05-05 21:51:32.394 ***
21:51:32.394 [info] Application partisan exited with reason: stopped
=== Ended at 2017-05-05 21:51:32
=== successfully completed test case
=== Returned value: ok
Test run history
| Top level test index


Great! We have e-mailed you a confirmation link.
Please check your email and confirm your profile update by clicking on the link we sent you. Sometimes there are delays sending profile update e-mails, please also check your junk mail if you haven't recieved an e-mail from Trajans before.


dials.filter_reflections¶
Introduction¶
This program takes reflection files as input and filters them based on user- specified criteria, to write out a subset of the original file.
Filtering is first done by evaluating the optional boolean ‘flag_expression’ using reflection flag values. The operators allowed are ‘&’ for ‘and’, ‘|’ for ‘or’, and ‘~’ for ‘not’. Expressions may contain nested sub-expressions using parentheses.
Following this, optional additional filters are applied according to values in the reflection table, such as by resolution or user-defined masks.
If a reflection file is passed in to the program but no filtering parameters are set, a table will be printed, giving the flag values present in the reflection file.
Examples:
dials.filter_reflections refined.refl flag_expression=used_in_refinement
dials.filter_reflections integrated.refl flag_expression="integrated & ~reference_spot"
dials.filter_reflections integrated.refl flag_expression="indexed & (failed_during_summation | failed_during_profile_fitting)"
dials.filter_reflections indexed.refl indexed.expt d_max=20 d_min=2.5
Basic parameters¶
output {
reflections = 'filtered.refl'
}
flag_expression = None
id = None
panel = None
d_min = None
d_max = None
partiality {
min = None
max = None
}
select_good_intensities = False
dead_time {
value = 0
reject_fraction = 0
}
ice_rings {
filter = False
}
Full parameter definitions¶
output {
reflections = 'filtered.refl'
.help = "The filtered reflections output filename"
.type = str
}
flag_expression = None
.help = "Boolean expression to select reflections based on flag values"
.type = str
id = None
.help = "Select reflections by experiment IDs"
.type = ints(value_min=0)
panel = None
.help = "Select reflections by panels they intersect"
.type = ints(value_min=0)
d_min = None
.help = "The maximum resolution"
.type = float(allow_none=True)
d_max = None
.help = "The minimum resolution"
.type = float(allow_none=True)
partiality {
min = None
.help = "The minimum reflection partiality for inclusion."
.type = float(value_min=0, value_max=1, allow_none=True)
max = None
.help = "The maximum reflection partiality for inclusion."
.type = float(value_min=0, value_max=1, allow_none=True)
}
select_good_intensities = False
.help = "Combined filter to select only fully integrated and trustworthy"
"intensities"
.type = bool
dead_time {
value = 0
.help = "Detector dead time in ms, assumed to be at the end of the"
"exposure time."
.type = float(value_min=0, allow_none=True)
reject_fraction = 0
.help = "Reject reflections which overlap by more than the given fraction"
"with the dead region of the image."
.type = float(value_min=0, value_max=1, allow_none=True)
}
ice_rings {
filter = False
.type = bool
unit_cell = 4.498,4.498,7.338,90,90,120
.help = "The unit cell to generate d_spacings for powder rings."
.type = unit_cell
.expert_level = 1
space_group = 194
.help = "The space group used to generate d_spacings for powder rings."
.type = space_group
.expert_level = 1
width = 0.002
.help = "The width of an ice ring (in 1/d^2)."
.type = float(value_min=0, allow_none=True)
.expert_level = 1
d_min = None
.help = "The high resolution limit (otherwise use detector d_min)"
.type = float(value_min=0, allow_none=True)
.expert_level = 1
}


Cucumber is a simple tool. It takes phrases written in plain language, finds snippets of code that match those phrases, runs them, and tells you whether they threw an error.
How you organise the code that Cucumber finds, is up to you.
What you get that code to do, is up to you.
If your Cucumber suite is slow, or hard to maintain, that's because the code you've asked Cucumber to run is too slow, or too complex.
If your plain language sentences are boring or awkward to read, that's the complexity in your underlying code creeping out.
You can get past this. In my talk at CukeUp this year, I described how most teams who adopt BDD hit a stage of disillusionment, where they question whether their Cucumber tests are giving them enough value.
It's natural to blame a tool for the discomfort you experience when you use it. Instead, I suggest you use that discomfort to help you see those deeper issues. These issues can be difficult to address, but tackling them will give you a great deal of benefit.
We wrote about this at length in the chapter "When Cucumbers Go Bad" in The Cucumber Book, but here are a few quick tips:
Acceptance Tests Don't Have to Be End-to-End Tests
Just because you're using Cucumber, doesn't mean you have to run an end-to-end test. Cucumber is for documenting behaviour that non-technical people care about. If you know that behaviour is implemented in a single class in your application, then why fire up a browser? You can hit that class directly.
Connecting your tests as close as possible to where the behaviour is implemented is something you'll never regret.
This is where it becomes important to pick the same flavour of Cucumber as your application code is written in.  Cucumber comes in flavours for almost every programming language under the sun - Java, Ruby, JavaScript, C++, PHP, C#, ActionScript and Lua to name but a few.
Why write acceptance tests that hit your classes? Why not just write unit tests? Good question! That brings me to my next point...
Too many scenarios? Maybe you have a trust issue
Writing Cucumber scenarios together is a great way to build a team's share understanding of the problem domain. When you have a scenario written, and everyone agrees you want that behaviour, it's time to ask an important question:
What's the best way to test this scenario?
If the technical perspective says that you can test this behaviour with a fast unit test, yet the business folks want it to remain as a Cucumber scenario, you have three options:
- Suck it up, and write another end-to-end test
- Wire up an acceptance test that connects directly to your domain model (see above)
- Convince the business folks to trust you, and write it as a unit test
Option 3 is what really excellent teams do.
Do your team want to be really excellent?
Like this post? You can hire Matt to coach or train your team, or join us on one of our upcoming public courses. Get in touch anytime to discuss your needs.


Before I was a web developer, I spent my time on baseball fields helping teenagers realize their ultimate dream of playing in the Major Leagues. All of them had talent. Somewhere, someone had seen glimpses of it. Cultivating that talent and turning their potential into performance was the primary purpose of my job. In the vast majority of cases we failed. Now, a few years removed from the game, most of the players I worked with are out of professional baseball. Those who did succeed, found a way to endure the grind and adjusted to the game’s mental and emotional demands.
In 2012, I hit the reset button on my career and became a web developer. I thought I would be leaving baseball forever. However, I found that many of the same traits I saw in successful ball players, even those with very little formal schooling, were some of the very same characteristics I observed in talented engineers. The inability to manage failure, maintain consistency, and learn how to be a professional shattered the dreams of the vast majority players I worked with because they were skills that were so difficult to master.
When I see one of them on TV, it’s hard to not recall the younger, yet unmolded version. It is why I was never the best scout. The baseball scout’s job is to imagine the possibilities. They envision a future version of a gangly youth whose body and mind has matured and whose flaws have been smoothed away to the point they can perform in the Major Leagues. It is a hard job and one that I wish existed in other industries.
Facing failure
Successful people, in any field, often struggle with making mistakes. This isn’t surprising, we are wired for bad news. We internalize it. We personalize it. Repeated failure is exhausting. Ball players, whose hitting success rate is at best around 30% are forced to cope. Failure is inherently part of the game.
Resilient players’ confidences seem immune to repeated failure. In fact, failure appears to be inextricably linked to their progress. This makes sense. We improve fastest based on negative feedback. The great thing about that big red error message is that it leaves an obvious clue. Sometimes these hints are more obscure than others, but bugs and errors inform us where to look and where to improve.
Getting repeatedly beaten by the same pitch provides feedback on where hitters need to improve in the same way that a familiar error in our terminal window instructs us where in the code to start looking for our mistake. As humans we learn through repetition and experience. The goal is to not getting beaten again by the same pitch or the same problem.
When I first started learning to program, I focused on never repeating the same mistake twice. This, of course, is impossible but I recorded most my thoughts and posted it online so that I had a searchable collection of my mistakes. The frequency of my posts have waned, but I still find myself searching my blog archives when I know I’ve solved a similar problem in the past. While it was rare to see ball players jot down notes on opponents, most hitting savants have the ability recall previous pitch sequences from past at-bats. Either way, the secret to coping with failure is to reframe it as valuable feedback to be used in the future.
Consistency
As developers, we know that consistent performance is important. We construct our dependencies on the most stable parts of our applications. The same goes for managers: when Sarah demonstrates she can be depended on to meet deadlines on a day-to-day, week-to-week, sprint-to-sprint or quarter-to-quarter basis, Sarah can be relied on to build the feature to satisfy the high priority business objective.
Consistency creates the opportunity for measurement. Like the measurement of feature velocity based on a set period of time, comparison of player’s abilities would be worthless without a standard 162 game schedule where the participants play nine innings with nine players on the field. Without a level playing field, comparisons are no longer valid and people can get really upset (see baseball and steroids).
Consistency is difficult because we are wired to break free from it. We are not as perfectly repeatable as the scripts we write. Our brains thrive on novelty. The day-to-day becomes mundane without it. We seek out adventure and variety. We create drama where there is none. We endeavor to learn new things.
But mostly being consistent is just showing up. Being there when products ship and stuff goes down. Career defining highlights are created when people are in the right place at the right time. Crashes on the production server and DEFCON 1 bugs are inevitable but these panic moments create opportunities. Under pressure, acting as you always do makes you a hero.
Derek Jeter’s lifetime batting average was .310. A consummate professional, he hit .308 in the playoffs.  No one is perfect, but bringing your best everyday provides predictability to our human unpredictability and separates the amateurs from the pros.
Professionalism
Professional baseball is a child’s game played by overgrown men who make millions of dollars. Make no mistake about it, baseball is a grueling sport. The schedule is relentless. Players arrive at the stadium five-plus hours before the first pitch to weight train, stretch, hit, throw, review scouting reports, etc.
After a three hour game, players are expected to hold court in front of their lockers and answer questions that essentially boil down to, “Tell us about your glaring mistake that you made in front of thousands of people across America.” Each major league team plays 162 games in about 180 days – not to mention the the month of spring training before the season starts and, if they are lucky, a month of postseason games. Eighty-one of these games in other cities meaning players are switching time zones for weeks on end. The truly blessed ones do this for 20+ years. What the casual fan sees of a player on any given night is the result of thousands of hours of refining subtle movements through exhaustive repetition.
And while we developers don’t enjoy the fame and fortune of Major Leaguers, we get to solve the worlds’ hardest puzzles. The impact of our code has touched the lives of nearly every human on the planet. The drudgery of implementing the vision of others is offset by the natural builder’s high.
Hacker News is littered with discussion on how writing software can crush your soul, but for the lucky ones, the “job” retains its joy. Despite the jeering fans and elusive bugs, there are a blessed few who simply love what they do.
The Same But Different
Of course, there are stark differences between baseball and software engineering. Software has been in the hands of laymen for less than a generation and baseball has remained unchanged since before the Civil War. While software’s impact continues to accelerate, we should pause to take breathers and remember that what is old becomes new again. There are lessons to learn everywhere we look and baseball has proven no different for me.
I love what I do. I’ve never been as challenged as when I’m muddling to make sense of a new concept or totally lost in a self-created code mess. The wins and losses I’ve experienced as a developer are like nothing else I’ve experienced as an athlete or a coach. While I’m still a relatively new programmer, my experiences in baseball have transferred as valuable lessons on coping with failures, reliability, and professionalism.
Not all that long ago my work day consisted of spotting the subtle deficiencies in a pitcher’s delivery and the sound of a shortstop’s feet as he ran a 60 yard dash, but when I watch how a junior dev deftly uses her VIM shortcuts or the ease of which she writes a complex SQL query, I’m reminded it’s not so different after all.


Curated list of hiring sites which focus on underrepresented minorities
Form to request new entry
Code by William O'Mullane


Register
LogIn
Mobile Number
Password
Create Account
Full Name
Country
Mobile Number
Password
Already a User?
Enterprise
Ranjan Binwani | 2019


index
github
るーずり～ふ！
自作のソフトウェアとかゲームとかを置いてるサイトです。
&
software
games
links
blank
blank
github
github
github
github
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
blank
blank
github
github
github
github
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
root
github
github
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
blank
blank
github
github
github
github
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
blank
blank
github
github
github
github
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
root
github
github
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
aaabbb
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
games
links
更新履歴
2014/06/25
サイトリニューアル
https://ajax.googleapis.com/ajax/libs/jquery/1.11.0/jquery.min.js?hogehoge=poepoe&hoehoe=mugamuga#fugafuga
games
links
http://bbs.will-co21.net/test/proxy.html?aaaa


The Art of Quality Maintenance
$ whoami
Maciej Mensfeld
-
Software Engineer (11 years with Ruby)
-
Karafka framework (Ruby + Kafka) creator
-
Founder of Coditsu - we make your code better by making you understand it
Abstract
- What is
code quality
- Why even care?
- Characteristics of code quality
- Misconceptions and traps
- Building quality
- Is failing an option?
What is code quality?
Everyone speaks about it.
What is code quality?
Everyone wants to make have it.
What is code quality?
But do people even think about its nature?
Zen and the Art of Motorcycle Maintenance
Robert M. Pirsig
Care and Quality are internal and external aspects of the same thing. A person who sees Quality and feels it as he works is a person who cares.A person who cares about what he sees and does is a person who’s bound to have some characteristic of quality.
Robert M. Pirsig
Programs must be written for people to read, and only incidentally for machines to execute.
Harold Abelson - Structure and Interpretation of Computer Programs
Broken window theory
- Study shows broken windows lead to vandalism.
- Code that no one cares gets crapier with time.
- Fix broken things, while working with them.
Expensive mistakes
Toyota 2009 Lexus car recall - $3 billion
Expensive mistakes
Knight Capital Group's trading violations - $440 milion
Expensive mistakes
Citigroup vs US Securities and Exchange Commission - $7 mln
Expensive mistakes
Ariane 5 failure - $370 milion
Expensive mistakes
Therac-25 - people's lifes
Quality software market in 2015
Market size: USD 5.96 billion
IT and Telecom: USD 535 million
http://www.grandviewresearch.com/industry-analysis/quality-management-software-market
http://www.idc.com/getdoc.jsp?containerId=US40915816
Hype?
Characteristics of code quality
Characteristics of code quality
- Coverage
- Complexity
- Documentation
- Duplication
- Size
- Structure
- Patterns
- Code smells
Something's not right, when you have:
- Unnecessary complexity
- Useless/misleading comments
- Long classes
- Poor naming
- Code that’s not used
- Design Pattern overuse
- Tight coupling
There is no silver bullet
But there are more and more good practices worth following.
Coverage
Complexity
It may be a result of the project methodology used.
It does not indicate degree of defects.
Documentation
Lots of comments are written to cover up bad code.
Documentation separated from code is bad.
It does not say why but it tells how.
Almost no one measures its quality.
Duplication
Methods contain (business) logic, and sometimes you'll want to change the logic for every caller, sometimes not?
Size
How small is small?
LOC is a really, really wrong metric
Structure
It may be more important than the code details.
Patterns
People change habbits.
People change jobs.
Jobs change people.
Everything needs a context
Offenses? Bad? Good?
Who knows without context?
We don't work in isolation
Is it hard?
Not if you have the right attitudes. It's having the right attitude that's hard.
Robert M. Pirsig
Don't rush things
When you want to hurry something, that means you no longer care about it and want to get on to other things.
Robert M. Pirsig
Don't rush things
Act in haste and repent at leisure: Code too soon and debug forever
Raymond Kennington
Raise awareness of quality
Caring about what you are doing is considered either unimportant or taken for granted.
Robert M. Pirsig
Keep an eye on it
- Indicates code that needs refactoring
- Indicates code that needs redesign
- VACUUM frequently
Keep an eye on it
- Start early
- Don't compromise
- Always schedule time for quality maintenance
- Take collective ownership
Documentation
- Do it!
- Use a single standard for a given language / technology.
- Say why instead of how.
- If you copy and paste, check if comments are still relevant.
Documentation
- Document unique, special, or unexpected conditions.
- Keep an eye for stale comments.
- Justify violation of good programming practices.
- If everyone stumbles on a particular problem, fix it!
Fail fast
- Raise exceptions so they’re in your face.
- Don't ignore or hide them.
- If it is hard to track problems in development, imagine doing that in production.
- Don't modify exception stack (or type).
Focus your (git) effort
Don't fix it, if it works.
Don't fix it, if it does not require any changes.
Perform code review.
C.R.A.P metrics (Change Risk Analysis and Prediction)
CRAP(m) = comp(m)^2 * (1-cov(m)/100)^3 + comp(m)
C.R.A.P metrics (Change Risk Analysis and Prediction)
The best code is no code
Outsource things that are not your business.
- Payments
- Deployment
- Infrastructure
- File storage
Then, why not do the same with quality?
Your project repositories contain way more knowledge than the current code base
2 years / 5 people project can generate 5-10 GB of metadata to work with.
Focus your code review on business logic
Make machines do the rest.
Add context and remember that:
- We’re humans, we make mistakes, we learn (but measure it).
- Interpret data, don't follow it blindly.
- Don't aim for the "magical" quality - instead track the technical debt.
What if we fail?
Government will regulate things for us.
Government will regulate things for us
Like they did with many other industries.
What if we fail?
We're still an emerging industry with more and more complexity.
We need to be able to prove that we know what we are doing.
Extras
- Untested code == unfinished code
- Expose metrics and stats
- Don’t tolerate anyone trashing your code
- Use tools to check code quality.
- Do it constantly.
- Do it even when code does not change.
Extras
- Don't ignore warnings.
- Warnings may hide bigger problems.
- Always justify supressions.
- SRP.
- Postpone generalization.
- Don't overthink.
- Less code, less problems
Extras
- Don't make your senior developers code.
- Make them teach a bit (if they want to).
- Rotate responsibilities.
- Challenge your programmers.


Some of your details haven't been recognised
To get your State Pension you’ll need to confirm some personal details.
By phone
Telephone: 0800 731 7898 Textphone: 0800 731 7339
Monday to Friday, 8am to 6pm
You will need your National Insurance number.


Elastic Functional Boxplots
Elastic Functional Boxplots
moduleauthor:: J. Derek Tucker<EMAIL_ADDRESS>- class boxplots.ampbox(fdawarp)[source]
This class provides amplitude boxplot for functional data using the SRVF framework
Usage: obj = ampbox(warp_data)
- Parameters:
warp_data (fdawarp) – fdawarp class with alignment data
Q1 – First quartile
Q3 – Second quartile
Q1a – First quantile based on alpha
Q3a – Second quantile based on alpha
minn – minimum extreme function
maxx – maximum extreme function
outlier_index – indexes of outlier functions
f_median – median function
q_median – median srvf
plt – surface plot mesh
Author : J. D. Tucker (JDT) <jdtuck AT sandia.gov> Date : 15-Mar-2018
- class boxplots.phbox(fdawarp)[source]
This class provides phase boxplot for functional data using the SRVF framework
Usage: obj = phbox(warp_data)
- Parameters:
warp_data (fdawarp) – fdawarp class with alignment data
Q1 – First quartile
Q3 – Second quartile
Q1a – First quantile based on alpha
Q3a – Second quantile based on alpha
minn – minimum extreme function
maxx – maximum extreme function
outlier_index – indexes of outlier functions
median_x – median warping function
psi_median – median srvf of warping function
plt – surface plot mesh
Author : J. D. Tucker (JDT) <jdtuck AT sandia.gov> Date : 15-Mar-2018


{% extends "base.html" %} {% block content %}
This will start the process of adding your GitHub account to the 23500/33550 organization.
You'll log in using GitHub's OAuth and then you will enter your StudentID. After doing that the system will automatically add you to the class & setup your repository for you.
Please contact us if you need help finding your ID
{% endblock %}


{% load static %}
Video Object Segementation Based on pixel-level annotated dataset
ch3467/Chong Hu/EE
yl4238/Yanlin Liu/EE
https://github.com/JackSnowWolf/video-object-segmentation-STCNN


Lemon Miso Noodle Soup with Tempura Lemon
September 18, 2019
It may still officially be summer, but that doesn’t mean it doesn’t get cold — especially around here in Ithaca. As fall approaches and all the freshmen start to get used to life around here, everyone unfortunately tends to spread all sorts of germs. In other words, I’m definitely starting to get sick.
So of course, I decided one day that class was less important than my personal well-being and thus spent the morning whipping up a warm bowl of soup. Maybe I’m just getting delirious from being overworked, but I’m pretty sure soup has magical qualities. This one definitely does because I started feeling a whole lot better after the first sip. I also finished the whole bowl in probably 5 minutes which really says something about this soup because if you know me, I can’t standing drinking hot liquids because I’m just impatient.
This recipe is inspired by my favorite go-to dish when I’m feeling a little under the weather: miso soup. From the spicy ginger and zesty lemon to the soothing earthiness of the miso, this dish is the perfect way to start a chilly (almost) fall morning. The addition of soy milk lends a creamier texture to the soup , but also complements the soy-based miso that’s already in the base of the soup. And for some extra flair, I paired these with tempura lemon wheels which are so easy to whip up and pair beautifully with this comforting soup recipe. I honestly can’t think of anything else I’d rather have to cure my aching body (getting old fellas).
Recipe
Ingredients (serves 2)
For the Lemon Miso Noodle Soup
- 60g thinly sliced pork shoulder
- 2 tsp. soy sauce
- 1 tsp. chinese cooking wine
- salt & pepper (to taste)
- 2 stalks large scallion (diced, whites & greens separated)
- 2 cloves garlic (thinly sliced)
- 1 tsp. minced ginger
- 150g baby bak choy (halved lengthwise)
- 2 tbsp. fresh miso paste
- 1 cup chicken stock
- 1/2 cup soy milk
- 50g glass noodles
- 2 tbsp. lemon juice
- 1 tsp. lemon zest
Tempura Lemons
- 1 lemon (thinly sliced)
- 1 egg
- 100g ice cold water
- 100g all-purpose flour
To Garnish
- bonito flakes
- furikake seasoning
- sesame oil
How to make
For Tempura Lemons
- Heat 1 cup of vegetable oil to 190C/375F.
- Loosely beat the egg in a mixing bowl. Add in the ice cold water followed by throroughly sifted all-purpose flour.
- Mix gently with a fork or chopsticks until just incorporated. Do not overmix.
- Dip each lemon slice in the tempura batter. Fry until the batter is cooked, approximately 2-3 minutes per side.
- Transfer to a wire rack, sprinkling sea salt over the tempura lemons immediately after frying.
For the Lemon Miso Noodle Soup
- Heat 1 tsp. of oil in a saucepot over medium-high. Quickly stir-fry the pork shoulder with the soy sauce, chinese cooking wine. Adjust for seasoning with salt & pepper. Set aside, reserving any rendered fat.
- Sweat off the garlic, scallion whites, and ginger in the rendered fat from the pork shoulder, adding more vegetable as necessary--approximately 3 minutes. Add the sliced baby bok choy and fresh miso paste. Stir-fry until slightly tender, approximately another 3 minutes.
- Add the chicken broth, glass noodles, cooked pork shoulder, lemon juice, and lemon zest and bring to a boil. Reduce heat to low and simmer until the bak choy is tender and cooked through, approximately 6-7 minutes.
- Add the soymilk and stir to incorporate.
- Serve with the tempura lemons and garnish with a drizzle of sesame oil, furikake seasoning, and bonito flakes if desired.
Meet the brad behind the butter...
Hello and welcome to you new home!  Here on Brad & Butter, I bake, shake, style, and snap tot tell inspiring stories. This blog is a manifestation of all the things in life at have inspired me to act upon something. And in turn, I hope that whatever I wrtie, bake, or shake can inspire other people. Click here to learn about me...
Read More
leave a reply


Address Book
Toggle navigation
Brand
Link
(current)
Link
Link
Link
Link
Harry Potter
The Boy Who Lived
101 Little Whingey Drive, UK, 28080
704 740 9136
social media here if i feel like it???
Edit
Delete


Status
Option 1
Option 2
Option 3
Option 4
Setup
Security
Advanced
Administration
Router Management
Router Password
Router Username
Router Password
Re-enter to confirm
Web Access
Protocol
HTTP
HTTPS
Auto-Refresh (in seconds)
Enable Info Site
Enable
Disable
Info Site Password Protection
Enabled
Info Site MAC Masking
Enable
Disable
Remote Access
Web GUI Management
Enable
Disable
Use HTTPS
Web GUI Port
(Default: 8080, Range: 1 - 65535)
SSH Management
Enable
Disable
SSH Remote Port
(Default: 22, Range: 1 - 65535)
Telnet Management
Enable
Disable
Telnet Remote Port
(Default: 23, Range: 1 - 65535)
Allow Any Remote IP
Enable
Disable
Allowed Remote IP Range
.
.
.
To
Boot Wait
Boot Wait
Enable
Disable
Cron
Cron
Enable
Disable
Additional Cron Jobs
802.1x
802.1x
Enable
Disable
Reset Button
Reset Button
Enable
Disable
Routing
Routing
Enable
Disable
IPv6 Support
IPv6
Enable
Disable
Radvd enabled
Enable
Disable
Radvd config
JFFS2 Support
JFFS2
Enable
Disable
Clean JFFS2
Enable
Disable
Total / Free Size
(Not mounted)
Language Selection
Language
Chinese simplified
Chinese traditional
Croatian
Dutch
English
French
German
Hungarian
Italian
Japanese
Latvian
Polish
Portuguese (brazilian)
Romanian
Russian
Slovenian
Spanish
Swedish
IP Filter Settings (adjust these for P2P)
TCP Congestion Control
vegas
westwood
reno
bic
cubic
highspeed
hybla
htcp
veno
scalable
lp
yeah
illinois
Maximum Ports
(Default: 32768, Range: 256 - 65535)
TCP Timeout (in seconds)
(Default: 3600, Range: 1 - 86400)
UDP Timeout (in seconds)
(Default: 120, Range: 1 - 86400)
Overclocking
Not Supported
Router GUI Style
Style
blue
brainslayer
cyan
elegant
green
kromo
orange
red
wikar
xirian
yellow
CIFS Automount
Common Internet File System
Enable
Disable
Share
User Name
Password
Unmask
Startscript
Total / Free Size
(Not mounted)
Help
Auto-Refresh:
Adjusts the Web GUI automatic refresh interval. 0 disables this feature completely.
More...


Utility which spends the time (in seconds specified as argument) while doing nothing. It can be interrupted by a Ctrl-C, and allows interruption of a Batch file running. The syntax to call it is of the type : SLEEP nn nn is the number of seconds to wait. This page was last updated


St Pierre is the smallest of the three main islands and lies to the SE of the linked islands of Miquelon and Langlade. The port of St Pierre is at the head of a deep inlet on the SE side of the island. It is a popular destination for yachts.
Position 46°47' 13"N, 56°09'38"W (harbour entrance)
Call by radio to "TXU Saint-Pierre" or by phone, 18 hours before arrival.
Documents must include clearance from the previous port, boat registration and crew list.
If arriving during normal working hours, once inside the harbour you can expect to get visited by both Customs officials and the Gendarmes but the whole procedure is very friendly and relaxed.
Last updated September 2015.
Beware of lobster pots and fishing nets with floating lines between in the approaches to St Pierre harbour. Keeping well north of Ile aux Pigeons appears to offer a clearer path.
The harbour master may allow you to lie alongside the main quay, close to where the high speed ferries berth, for which there is no charge. However there are no facilities here and this quay is not particularly yacht friendly unless you have large fenders and a substantial fender board.
Most yachts will prefer to go alongside the sailing centre a little further into the harbour. There is an overnight charge of 3 euros per m, but the facilities are excellent with electricity (240V), fresh water and wifi available on the jetty, and toilets/showers/launderette in the sailing centre building.
Last updated September 2015.


I’ve always loved developing in Python, specially after working on QSTK and at Lucena and Coursera. This year I was finally able to make it to PyCon in Montreal, Canada with the help of Python Software Foundation and Coursera.
It was great talking to some many other people who share the same love for the language that I do. It was a great learning experience and a gentle reminder that I still have a long way to go. Talking to Guido was the highlight of the conference for me.
I was with a few co-workers from Coursera as company sponsors. We use a fair amount of python (Django, Fabric, IPython, and the scientific python stack) at work. We were excited to show off our Python courses and let others know about the challenging engineering work we get to do out here in Mountain View, California.
As an engineer working here in the Bay Area I don’t often get to see the true global impact of my work, so hearing stories from students from all different backgrounds was rewarding. We were extremely humbled by how many people were seeking out education on the Coursera platform and pushing themselves to succeed.
In between my time at the Coursera booth, I would try and attend as many of the great talks at the conference. A few of the talks that I was able to attend were Graham Dumpleton’s talk on Advanced methods of creating decorators, Tres Seaver’s talk - By Your Bootstraps: Porting Your Application to Python3, and It’s Dangerous to Go Alone: Battling the Invisible Monsters of Tech by Julie Pagano.
The shoutout from Jessica McKellar during the keynote was really the cherry-on-top, solidifying the work that I do here at Coursera and the things we can give back as a company to the Python community at large.
See you all at PyCon 2015!


Collection
Academies financial management and governance reviews
Reviews conducted by the Education Funding Agency into the financial management and governance at academies.


Version 1.10 notes and API changes¶
This page includes more detailed release information and API changes from NetworkX 1.9 to NetworkX 1.10.
Please send comments and questions to the networkx-discuss mailing list: <http://groups.google.com/group/networkx-discuss>.
API changes¶
- [#1501]
connected_components
,weakly_connected_components
, andstrongly_connected_components
return now a generator of sets of nodes. Previously the generator was of lists of nodes. This PR also refactored theconnected_components
andweakly_connected_components
implementations making them faster, especially for large graphs. - [#1547]
The
func_iter
functions in Di/Multi/Graphs classes are slated for removal in NetworkX 2.0 release.func
will behave likefunc_iter
and return an iterator instead of list. These functions are deprecated in NetworkX 1.10 release.
New functionalities¶
- [#823]
A
enumerate_all_cliques
function is added in the clique package (networkx.algorithms.clique
) for enumerating all cliques (including nonmaximal ones) of undirected graphs. - [#1105]
A coloring package (
networkx.algorithms.coloring
) is created for graph coloring algorithms. Initially, agreedy_color
function is provided for coloring graphs using various greedy heuristics. - [#1193]
A new generator
edge_dfs
, added tonetworkx.algorithms.traversal
, implements a depth-first traversal of the edges in a graph. This complements functionality provided by a depth-first traversal of the nodes in a graph. For multigraphs, it allows the user to know precisely which edges were followed in a traversal. All NetworkX graph types are supported. A traversal can also reverse edge orientations or ignore them. - [#1194]
A
find_cycle
function is added to thenetworkx.algorithms.cycles
package to find a cycle in a graph. Edge orientations can be optionally reversed or ignored. - [#1210] Add a random generator for the duplication-divergence model.
- [#1241]
A new
networkx.algorithms.dominance
package is added for dominance/dominator algorithms on directed graphs. It contains aimmediate_dominators
function for computing immediate dominators/dominator trees and adominance_frontiers
function for computing dominance frontiers. - [#1269] The GML reader/parser and writer/generator are rewritten to remove the dependence on pyparsing and enable handling of arbitrary graph data.
- [#1280]
The network simplex method in the
networkx.algorithms.flow
package is rewritten to improve its performance and support multi- and disconnected networks. For some cases, the new implementation is two or three orders of magnitude faster than the old implementation. - [#1286]
Added the Margulis–Gabber–Galil graph to
networkx.generators
. - [#1306]
Added the chordal p-cycle graph, a mildly explicit algebraic construction
of a family of 3-regular expander graphs. Also, moves both the existing
expander graph generator function (for the Margulis-Gabber-Galil
expander) and the new chordal cycle graph function to a new module,
networkx.generators.expanders
. - [#1314] Allow overwriting of base class dict with dict-like: OrderedGraph, ThinGraph, PrintGraph, etc.
- [#1321]
Added
to_pandas_dataframe
andfrom_pandas_dataframe
. - [#1322] Added the Hopcroft–Karp algorithm for finding a maximum cardinality matching in bipartite graphs.
- [#1336] Expanded data keyword in G.edges and added default keyword.
- [#1338] Added support for finding optimum branchings and arborescences.
- [#1340]
Added a
from_pandas_dataframe
function that accepts Pandas DataFrames and returns a new graph object. At a minimum, the DataFrame must have two columns, which define the nodes that make up an edge. However, the function can also process an arbitrary number of additional columns as edge attributes, such as ‘weight’. - [#1354] Expanded layout functions to add flexibility for drawing subsets of nodes with distinct layouts and for centering each layout around given coordinates.
- [#1356] Added ordered variants of default graph class.
- [#1360]
Added harmonic centrality to
network.algorithms.centrality
. - [#1390]
The
generators.bipartite
have been moved toalgorithms.bipartite.generators
. The functions are not imported in the main namespace, so to use it, the bipartite package has to be imported. - [#1391] Added Kanevsky’s algorithm for finding all minimum-size separating node sets in an undirected graph. It is implemented as a generator of node cut sets.
- [#1399] Added power function for simple graphs
- [#1405] Added fast approximation for node connectivity based on White and Newman’s approximation algorithm for finding node independent paths between two nodes.
- [#1413]
Added transitive closure and antichains function for directed acyclic
graphs in
algorithms.dag
. The antichains function was contributed by Peter Jipsen and Franco Saliola and originally developed for the SAGE project. - [#1425] Added generator function for the complete multipartite graph.
- [#1427] Added nonisomorphic trees generator.
- [#1436]
Added a generator function for circulant graphs to the
networkx.generators.classic
module. - [#1437]
Added function for computing quotient graphs; also created a new module,
networkx.algorithms.minors
. - [#1438] Added longest_path and longest_path_length for DAG.
- [#1439]
Added node and edge contraction functions to
networkx.algorithms.minors
. - [#1445]
Added a new modularity matrix module to
networkx.linalg
, and associated spectrum functions to thenetworkx.linalg.spectrum
module. - [#1447]
Added function to generate all simple paths starting with the shortest
ones based on Yen’s algorithm for finding k shortest paths at
algorithms.simple_paths
. - [#1455]
Added the directed modularity matrix to the
networkx.linalg.modularity_matrix
module. - [#1474]
Adds
triadic_census
function; also creates a new module,networkx.algorithms.triads
. - [#1476]
Adds functions for testing if a graph has weighted or negatively weighted
edges. Also adds a function for testing if a graph is empty. These are
is_weighted
,is_negatively_weighted
, andis_empty
. - [#1481]
Added Johnson’s algorithm; one more algorithm for shortest paths. It
solves all pairs shortest path problem. This is
johnson
atalgorithms.shortest_paths
- [#1414]
Added Moody and White algorithm for identifying
k_components
in a graph, which is based on Kanevsky’s algorithm for finding all minimum-size node cut-sets (implemented inall_node_cuts
#1391). - [#1415]
Added fast approximation for
k_components
to thenetworkx.approximation
package. This is based on White and Newman approximation algorithm for finding node independent paths between two nodes (see #1405).