--- layout: post title: Titanic Survival subtitle: A way to evaluate the model. published: false categories: others gh-repo: Ruthwik/StockPrediction tags: [machine learning, cross validation, python, scikit] bigimg: - /img/kaggleimages/titanicsurvival.jpg ---
When solving a machine learning problem we follow a consistent series of sets.
First, partitioning the data set into training and test sets using the train_test_split
function. Then fitting the model with the training set.
And finally, applying the model on the test set to evaluate the trained model's performance.Let's recall the reason why to divide the original data into training and test sets. The test set is a way to estimate how well the model trained on the training data would perform on the new previously
unseen data. The test must have same general attributes as the original data set.
Cross-validation is a way to predict the fit of a model to a hypothetical validation set when an explicit validation set is not available.
This is a method that goes beyond evaluating a single model using a single Train/Test split of the data.
We may have noticed that when choosing different values for the random state seed parameter in the train_test_split
function, that the accuracy score we get from running a classifier can vary quite a bit just by chance depending on the specific samples that happen to end up in the training set.
Cross-validation runs multiple different training test splits and then averaging the results which gives more stable and reliable estimates of how the classifiers likely to perform. The figure below shows how Cross-validation works on the data.The most common type of cross-validation is k-fold cross-validation most commonly with K set to 5 or 10.
Let's take an example of five-fold cross-validation, the original dataset is ramdomly partitioned into five parts or close to equal size. Each of these parts is called a "fold". Then a total of five models are trained. The first model Model 1, is trained using folds 2 through 5 as the training set and tested using fold 1 as test set. The second model Model 2, is trained using Folds 1, 3, 4, and 5 as the training set, leaving Fold 2 as test set for evaluation , and so on. When all five models have five accuracy values, the values are averaged to find the model accuracy.
In scikit-learn, we can use the cross_val_score
function from the model selection module to do cross-validation. The parameters for this function are: the model we want to evaluate, and then the data set , and then the corresponding target values. By default, cross_val_score does threefold cross-validation. So it returns three accuracy scores, one for each of the three folds. In order to change the number of folds, we can set the CV parameter. For example, CV equals 5 will perform five-fold cross-validation. Then we compute the mean of all the accuracy scores across the folds and report the mean cross-validation score as a measure of how accurate we can expect the model to be on average. One benefit of computing the accuracy of a model on multiple splits instead of a single split, is that it gives us potentially useful information about how sensitive the model is to the nature of the specific training set.
It does take more time and computation to do cross-validation.
So for example, if we perform k-fold cross-validation and we don't compute the fold results in parallel,
it'll take about k times as long to get the accuracy scores as it would with just one Train/Test split.
However, the gain in our knowledge of how the model is likely to perform on future data is usually well worth this cost
Some problems can exhibit a large imbalance in the distribution of the target classes: for instance there could be several times more negative samples Dataset sometimes might have been created in such a way that the records are sorted or show bias in ordering by class label. For example, if a dataset contains same target label (class) in fold 1 and missing other target labels or classes which is our test set to evaluate our Model. So problems of imbalance in distribution may reduce the informativeness of the evaluation.
In the example below, we can see that in fold 1 only Iris-setosa class is considered.Therefore
In such cases Stratified Cross-validation is used to ensure that relative class frequencies is approximately preserved in each train and validation fold.
In Stratified Cross-validation, each fold contains a proportion of classes that matches overall dataset. This helps to represent all classes fairly in the test set.
The Scikit-learn documentation says that LeaveOneGroupOut is a cross-validation scheme which holds out the samples according to a third-party provided array of integer groups. This group information can be used to encode arbitrary domain specific pre-defined cross-validation folds.Each training set is thus constituted by all the samples except the ones related to a specific group The image below shows how the dataset is split.
Sometimes we want to evaluate the effect that an important parameter of a model has on the cross-validation scores. The useful function validation_curve
makes it easy to run this type of experiment. This fucation will do threefold cross-validation by default but can be changed to different fold with the CV parameter. The other parameters are a classifier, parameter name, and set of parameter values, we want to sweep across.
The below code shown here as an example will fit four Lasso Regression models with different alpha parameters and with five different folds. So each model will fit five different fold and a total of 20 train and test scores each is returned. The returned values is displayed in four-by-five arrays.
We can plot these results from validation curve as shown here to get an idea of how sensitive the performance of the model is to changes in the given parameter.The x axis corresponds to values of the parameter (here alpha) and the y axis gives the evaluation score
Before concluding let's remind that Cross Validation is used to evaluate the model and not learn or tune a new model.
I hope you liked this tutorial. You can find the complete code as a jupyter notebook on my github page. Useful resources to read:
If you have any question or feedback, please do reach out to me by commenting below.


as3flobile extension: as3flobile-android
2010 October 20th by todd anderson
I just made an initial commit to github with an as3flobile library extension named as3flobile-android.
The intent of as3flobile-android is to provide custom skins and controls that target the look-and-feel of the Android platform. Currently within the library are graphic assets, custom skins and a few convenience controls which are composite controls that extend their as3flobile counterpart with the skinning already wired up (take for instance the AndroidScrollList which extends ScrollList to provide custom item renderers and skins that have the look-and-feel of the Android list – also has the precense of scrollbars on scroll behaviour!).
Now, it should be said, i didn’t go all out and study/push every pixel to make the skins look exactly like Android. I just cut some graphics from a PSD and applied them in the skins. This is a project (of many) that i do on my spare time and if/when i do need to have themed rolled in for a paying client, i am sure a designer wold be breathing down my neck That said, If at the very least, it will provide an example to anyone who is interested applying custom skins to as3flobile components.
It should be noted (as it also is in the README markdown for the as3flobile-android repository) that I cut the graphics from a PSD made available by Pavel Macek. That PSD can be found at http://www.matcheck.cz/androidguipsd/ so check it out. The library also includes the ScaleBitmap from bytearray.org, available at http://www.bytearray.org/?p=118 and is pretty awesome. I made a slight modification to the source in order to re-use graphics in the skins (details can be found in the CHANGES document) so i could not have it external and compiles against.
There are a few more custom controls targeting the Android platform that i have yet to check in as i would like to drum up some examples before then. These include things like a ContextMenu, AlertDialog, TitleBar, etc. And most likely the Menu control from as3flobile will be moved to as3flobile-android as it really is Android specific… so look out for that.
Criticism and feedback is always welcome.
Posted in Android, Flash, as3flobile, as3flobile-android.


| Compose | u&v mv mv mv |
|
u&v y ↔ u v y .
Thus +:&- 7 is _14
(double the negation). Moreover, the monads u&v
and u@v are equivalent.
|
x u&v y ↔ (v x) u (v y) .
For example, 3 +&! 4
is 30, the sum of factorials.
|
3 +&^. 4 NB. Sum of natural logarithms 2.48491 ^ 3 +&^. 4 NB. Multiplication using natural logs 12 3 +&(10&^.) 4 NB. Sum of base ten logarithms 1.07918 10 ^ 3 +&(10&^.) 4 NB. Multiplication using base ten logs 12 3 +&.^. 4 NB. See the related conjunction Under (&.) 12 3 +&.(10&^.) 4 12Compare the behaviour of & with that of &: . They differ only in the ranks of the verbs that they produce.


--- title: first post slug: haha excerpt: first post date: 2020-3-30 ---
Tokyo Olympic and Paralympic Games |
PARA-TABLE TENNIS SQUAD’S TOKYO BUILD-UP A ‘BRILLIANT EXAMPLE OF TEAMWORK’The addition of three multiple gold medal-winning former China representatives in Australia’s Para-table tennis squad for the Tokyo 2020 Paralympic Games has helped lift the standard of the whole team as it attempts to secure our nation’s first gold medal in the sport in nearly 40 years (read more). |
| Meet the Olympic team | Meet the Paralympic Team | Table Tennis at the Games |
| Olympic Schedule | How to Watch | Paralympic Schedule |
| The Venue | Find a club and have a go! | Olympics Live Sites |


This document defines EPICS v4 communication protocol called pvAccess.
For more information about the EPICS, please refer to the home page of the Experimental Physics and Industrial Control System.
This is the 23 September 2011 version of the pvAccess Protocol Specification. This version was approved by the EPICS V4 Working group to be published as the First Public Working Draft of the specification, in its 22-nd September 2011 meeting. This public working draft is intended for the EPICS community to review and comment. Resulting comments will drive subsequent drafts.
The present implementation of pvAccess largely reflects the specification as written here, though a second document will soon be written to distinguish what is in the specification that is not yet implemented.
The terms MUST, MUST NOT, SHOULD, SHOULD NOT, REQUIRED, and MAY when highlighted (through style sheets, and in uppercase in the source) are used in accordance with RFC 2119 [RFC2119]. The term NOT REQUIRED (not defined in RFC 2119) indicates exemption.
pvAccess is a high-performance network communication protocol for designed signal monitoring and also for high-level applications. It is a successor of of EPICS Channel Access.
TCP/IP is used for data transmission, UDP/IP for discovery (discovery over TCP/IP is also allowed). The procotol itself supports IPv6, i.e. all addresses are IPv6 encoded.
pvAccess heavily depends on pvData [pvData homepage] – all the data is sent as pvData objects. Protocol is optimized to send minimum amount of data. It supports segmented messages and allows sending huge amount of data using small buffers (there is no limitation on maximum message size limited by send/receive buffer).
The pvAccess protocol definition consists of three major parts:
The key goals of the pvData data encoding are simplicity and efficiency. In keeping with these principles, the encoding does not align primitive types on word boundaries and therefore eliminates the wasted space and additional complexity that alignment requires. The pvAccess data encoding simply produces a stream of contiguous bytes; data contains no padding bytes and need not be aligned on word boundaries.
However, the exception are arrays. All the arrays needs to be aligned to 64-bit. This requires message header is also 64-bit aligned.
For connection-oriented communication (TCP/IP) byte-order is negotiated between client and server - server wins. In order to allow all the intermediates to forward the data without requiring it to be unmarshaled (the intermediates can forward requests by simply copying blocks of binary data) and not to require specific byte-order for connection-less protocols (UDP), each message indicates endiannes.
Many of the types involved in the data encoding, as well as several protocol message components, have an associated size or count. A size is a non-negative number. Sizes and counts are encoded in one of two ways:
The basic types are encoded as shown in. Integer types (byte, short, int, long) are represented as two’s complement numbers, and floating point types (float, double) use the IEEE-754 standard formats [IEEE_754-1985 Wiki].
| Type | Encoding |
|---|---|
| boolean | A single byte with value non-zero value for true, 0 for false. |
| byte | Signed 8-bit integer. |
| short | Signed 16-bit integer. |
| int | Signed 32-bit integer. |
| long | Signed 64-bit integer. |
| float | 32-bit float (IEEE-754 single-precision float). |
| double | 64-bit float (IEEE-754 double-precision float). |
Strings are encoded as a size, followed by the string contents in UTF-8 format array of bytes. Strings are not NULL-terminated. An empty string is encoded with a size of zero.
On the wire, pvAccess transmits all strings as Unicode strings in UTF-8 encoding. Non-C++ bindings of the pv normative implementations (pvAccess and pvData in particular) will use strings in their language-native Unicode representation and convert automatically to and from UTF-8 for transmission, so applications can transparently use characters from non-English alphabets. However, for C++, how strings are represented inside a process depends on the platform as well as the mapping that is chosen for a particular string: the default mapping to std::string.
Arrays are encoded as a size representing the number of elements in the array, followed by the elements encoded as specified for their type.
BitSet is a pvData internal data type that represents bits. It is serialized as a byte array.
Each pvData data instance (i.e. PVField) has introspection description (i.e. Field). PVField is encoded as raw values (no other overhead), Field encodes information of what data-type(s) PVField is. Since many different PVField instances share same introspection description it can be cached to avoid sending it over-and-over over the wire. Thus, Field encoding starts with a byte describing the following encoding: it can be NULL, ID only and ID with actual Field serialization. ID, encoded as short, is a key used to cache Field descriptions.
| Field Encoding | Type | Description |
|---|---|---|
| 0xFF | NULL_TYPE_CODE | No introspection data. |
| 0xFE + ID | ONLY_ID_TYPE_CODE | Serialization contains only an ID (that was assigned by one of the previous FULL_WITH_ID descriptions). |
| 0xFD + ID + FieldDesc | FULL_WITH_ID_TYPE_CODE | Serialization contains an ID (that can be used later, if cached) and full interface description. |
Actual Field introspection description (FieldDesc) is encoded as a byte that consists of 2 nibbles (4-bits). Upper nibble (MSBs) defines Field type (i.e. Type), low nibble (LSBs) defines data type (i.e. ScalarType) for scalar and scalarArray types. The byte is then followed by Field instance name (encoded as string). Moreover, structure and structureArray types require more data: structure requires array of Field-s (size followed by Field-s as described above), structureArray is similar just that it in addition requires name of the structure.
| FieldDesc Encoding | Type | Description |
|---|---|---|
| 0x00 | ScalarType (0b0000xxxx) + name | scalar | Scalar. |
| 0x10 | ScalarType (0b0000xxxx) + name | scalarArray | Array of scalars. |
| 0x20 (0b00100000) + name + Field[] | structure | Structure. |
| 0x30 (0b00110000) + name + (structure name + Field[]) | structureArray | Array of structures. |
| Encoding | ScalarType |
|---|---|
| 0 (0b0000) | boolean |
| 1 (0b0001) | byte |
| 2 (0b0010) | short |
| 3 (0b0011) | int |
| 4 (0b0100) | long |
| 5 (0b0101) | float |
| 6 (0b0110) | double |
| 7 (0b0111) | string |
Introspection description of the following structure
structure test1 structure timeStamp long secondsPastEpoch int nanoSeconds structure[] value structure org.epics.ioc.test.testStructure double value structure location double x double y string factoryRPC structure arguments int size structure element double value structure alarm int severity string message structure timeStamp long secondsPastEpoch int nanoSeconds
is encoded as
FD 00 01 20 05 74 65 73 74 31 05 FD 00 02 20 09 .... .tes t1.. .... 74 69 6D 65 53 74 61 6D 70 02 04 10 73 65 63 6F time Stam p... seco 6E 64 73 50 61 73 74 45 70 6F 63 68 03 0B 6E 61 ndsP astE poch ..na 6E 6F 53 65 63 6F 6E 64 73 FD 00 03 30 05 76 61 noSe cond s... 0.va 6C 75 65 20 6F 72 67 2E 65 70 69 63 73 2E 69 6F lue org. epic s.io 63 2E 74 65 73 74 2E 74 65 73 74 53 74 72 75 63 c.te st.t estS truc 74 75 72 65 02 06 05 76 61 6C 75 65 FD 00 04 20 ture ...v alue ... 08 6C 6F 63 61 74 69 6F 6E 02 06 01 78 06 01 79 .loc atio n... x..y 07 0A 66 61 63 74 6F 72 79 52 50 43 FD 00 05 20 ..fa ctor yRPC ... 09 61 72 67 75 6D 65 6E 74 73 01 03 04 73 69 7A .arg umen ts.. .siz 65 FD 00 06 20 07 65 6C 65 6D 65 6E 74 03 06 05 e... .el emen t... 76 61 6C 75 65 FD 00 07 20 05 61 6C 61 72 6D 02 valu e... .al arm. 03 08 73 65 76 65 72 69 74 79 07 07 6D 65 73 73 ..se veri ty.. mess 61 67 65 FE 00 02 age. ..
Data (i.e. PVField) basically encodes only its data. The only exception is structureArray. Before each structure of an array there is a boolean flag indicating whether structure is null or not.
Each structure can have a BitSet instance defining what subset of that structure's fields have been serialized. This allows partial serialization of structures, e.g. sending only fields that have changed and not entire structure. Each node of a structure corresponds to one bit; if a bit is set its corresponding field has been serialized, otherwise not. BitSet does not apply to array elements.
bit# field 0 structure 1 structure timeStamp 2 long secondsPastEpoch<PHONE_NUMBER> 3 int nanoSeconds 819000000 4 structure[] value structure org.epics.ioc.test.testStructure double value 100 structure location double x 0 double y 0 structure org.epics.ioc.test.testStructure double value 200 structure location double x 5 double y 10 5 string factoryRPC org.epics.ioc.support.rpc.ExampleChannelRPCFactory 6 structure arguments 7 int size 2 8 structure element 9 double value 0 10 structure alarm 11 int severity 0 12 string message 13 structure timeStamp 14 long secondsPastEpoch 0 15 int nanoSeconds 0
The structure above requires 16 bits, i.e. 2 bytes.
Remark: for performance reasons BitSet implementation stores bits as longs, however serialization is optimized to send only least possible number of bytes (LSB part that covers all the bits set).
If bit on a structure node is set then all its fields have to be de-/serialized.
The example below is a simple example where entire structure is sent, i.e. bit 0 is set.
NOTE: first six bytes are erased since they are not part of structure serialization.
01 01 00 00 00 00 4D 48 00 48 .. .... MH.H 30 D0 F2 C0 02 01 40 59 00 00 00 00 00 00 00 00 0... ..@
The pvAccess protocol uses two protocol message types:
Each message consists of a message header and (optionally) a message payload that immediately follows the header. Message needs to aligned to 64-bits.
Each protocol message has a fixed 8-byte header that is encoded as if it were the following structure:
struct pvAccessHeader { byte magic; byte version; byte flags; byte messageType; int payloadSize; };
| Member | Description |
|---|---|
| magic | pvAccess protocol magic code, 0xCA. |
| version | Protocol version, 2 nibbles (major, minor). |
| flags | Message flags. |
| messageType | Message type (i.e. create, get, put, process, etc.). |
| payloadSize | Message payload size (non-aligned, in bytes). |
| bit | Description |
|---|---|
| 0 | Application/Control [0/1] message. |
| 1,2,3 | Unused |
| 4 | First message (of set of segmented messages). |
| 5 | Last message (of set of segmented messages). |
| 6 | Unused. |
| 7 | Little/Big [0/1] endian byte order. |
NOTE: If bits 4 and 5 are both set this indicates message between first and last message of a set of segmented messages. If none set then message is not segmented.
This section describes all the application messages (0-th bit of pvAccessHeader.flags is not set) for different pvAccessHeader.messageType values.
Send over UDP to clients. Beacons are only used to detect new servers and server restarts.
struct beaconMessage { short beaconSequenceId; long startupTimeSeconds; int startupTimeNanos; byte[16] serverAddressIPv6; short serverPort; FieldDesc serverStatusIF; [if serverStatusIF != null] PVField serverStatus; };
| Member | Description |
|---|---|
| beaconSequenceId | Beacon sequence ID (counter w/ rollover). Can be used to detect UDP routing problems. |
| startupTimeSeconds | Server startup time (seconds past 1.1.1970). |
| startupTimeNanos | Server startup time (nanoseconds part). |
| serverAddressIPv6 | Server IPv6 address (or IPv6 encoded IPv4 address). |
| serverPort | Server port (where server TCP/IP is listening). |
| serverStatusIF | Optional server status Field description. |
| serverStatus | Optional server data. |
A beacon from yet unknown serverAdddressIPv6:serverPort means new server. A beacon with the same serverAdddressIPv6:serverPort address and different startupTime{Seconds,Nanos} means that server was restarted.
NOTE: it was agreed that servers would have time set on every restart (via NTP).
NOTE: beacons are no longer used to report server-alive status (this is done by monitoring TCP/IP traffic – if there is traffic from server, then server is alive). This reduces UDP traffic. Server must at least send a couple of beacons to notify that it is alive (e.g. 1Hz). After this it can stop sending them, or does it with a low rate (one per every couple of minutes) to report serverStatus.
The first application message sent from the server to a client when TCP/IP connection is established. The message indicates that the server is ready to receive requests; the client must not send any messages on the connection until it has received the validate connection message from the server.
The purpose of the validate connection message is two-fold:
struct connectionValidationRequestToClient { int serverReceiveBufferSize; int serverReceiveSocketBufferSize; }; struct connectionValidationResponseFromClient { int clientReceiveBufferSize; int clientReceiveSocketBufferSize; //TODO short priority; };
Echo diagnostic message. Usually sent when there is a suspicion that server is no longer functional (no TCP/IP traffic). Can also be sent over UDP/IP (to get list of all servers).
struct echoRequest { byte[] somePayload; }; struct echoResponse { byte[] samePayloadAsInRequest; };
Channel search message. Can be sent over UDP/IP, however UDP congestion control is highly recommended to implemented in this case.
struct searchRequest { int searchSequenceId; byte qosCode; // == boolean for “response required” (if none found) struct { // not serialized as pvData int clientChannelID; string channelName; } channels[]; };
Response is sent as messageType 0x04 (to avoid self-searching).
Response to Search request (0x03) message.
struct searchResponse { int searchSequenceId; boolean found; byte[16] serverAddressIPv6; short serverPort; int[] clientChannelIDs; };
struct createChannelRequest { struct { // not serialized as pvData int clientChannelID; string channelName; } channels[]; }; struct createChannelResponse { // per channel int clientChannelID; int serverChannelID; Status status; //TODO short accessRights; };
struct destroyChannelRequest { struct { // not serialized as pvData int clientChannelID; int serverChannelID; } channels[]; };
struct channelGetRequestInit { int serverChannelID; int requestID; byte subcommand = 0x08; FieldDesc pvRequestIF; PVField pvRequest; }; struct channelGetResponseInit { int requestID; byte subcommand; // same as in request Status status; FieldDesc pvStructureIF; };
struct channelGetRequest { int serverChannelID; int requestID; byte subcommand = 0x40 mask for GET; 0x10 mask for DESTROY; }; struct channelGetResponse { int requestID; byte subcommand; // same as in request Status status; BitSet changedBitSet; PVField pvStructureData; };
struct channelPutRequestInit { int serverChannelID; int requestID; byte subcommand = 0x08; FieldDesc pvRequestIF; PVField pvRequest; }; struct channelPutResponseInit { int requestID; byte subcommand; // same as in request Status status; FieldDesc pvPutStructureIF; };
struct channelPutRequest { int serverChannelID; int requestID; byte subcommand = 0x00 mask for PUT; 0x10 mask for DESTROY; BitSet toPutBitSet; PVField pvPutStructureData; }; struct channelPutResponse { int requestID; byte subcommand; // same as in request Status status; };
struct channelGetPutRequest { int serverChannelID; int requestID; byte subcommand = 0x40; }; struct channelGetPutResponse { int requestID; byte subcommand; // same as in request Status status; PVField pvPutStructureData; };
struct channelPutGetRequestInit { int serverChannelID; int requestID; byte subcommand = 0x08; FieldDesc pvRequestIF; PVField pvRequest; }; struct channelPutGetResponseInit { int requestID; byte subcommand; // same as in request Status status; FieldDesc pvPutStructureIF; FieldDesc pvGetStructureIF; };
struct channelPutGetRequest { int serverChannelID; int requestID; byte subcommand = 0x00 mask for PUT_GET; 0x10 mask for DESTROY; BitSet toPutBitSet; PVField pvPutStructureData; }; struct channelPutGetResponse { int requestID; byte subcommand; // same as in request Status status; PVField pvGetStructureData; };
// get remote put structure data struct channelGetPutRequest { int serverChannelID; int requestID; byte subcommand = 0x80; }; struct channelGetPutResponse { int requestID; byte subcommand; // same as in request Status status; PVField pvPutStructureData; };
// get remote get structure data struct channelGetGetRequest { int serverChannelID; int requestID; byte subcommand = 0x40; }; struct channelGetGetResponse { int requestID; byte subcommand; // same as in request Status status; PVField pvGetStructureData; };
struct channelMonitorRequestInit { int serverChannelID; int requestID; byte subcommand = 0x08; FieldDesc pvRequestIF; PVField pvRequest; }; struct channelMonitorResponseInit { int requestID; byte subcommand; // same as in request Status status; FieldDesc pvStructureIF; };
struct channelStartMonitorRequest { int serverChannelID; int requestID; byte subcommand = 0x44; }; struct channelStopMonitorRequest { int serverChannelID; int requestID; byte subcommand = 0x04; }; struct channelDestroyMonitorRequest { int serverChannelID; int requestID; byte subcommand = 0x10; };
struct channelMonitorResponse { int requestID; byte subcommand; // same as in request BitSet changedBitSet; PVField pvStructureData; BitSet overrunBitSet; };
struct channelArrayRequestInit { int serverChannelID; int requestID; byte subcommand = 0x08; FieldDesc pvRequestIF; PVField pvRequest; }; struct channelArrayResponseInit { int requestID; byte subcommand; // same as in request Status status; FieldDesc pvArrayIF; };
struct channelGetArrayRequest { int serverChannelID; int requestID; byte subcommand = 0x40 mask for GET; 0x10 mask for DESTROY; size offset; // -1 == unspecified size count; // -1 == unspecified }; struct channelGetArrayResponse { int requestID; byte subcommand; // same as in request Status status; PVField pvArrayData; };
struct channelPutArrayRequest { int serverChannelID; int requestID; byte subcommand = 0x00 mask for PUT; 0x10 mask for DESTROY; size offset; // -1 == unspecified PVField pvArrayData; }; struct channelPutArrayResponse { int requestID; byte subcommand; // same as in request Status status; };
struct channelSetLengthRequest { int serverChannelID; int requestID; byte subcommand = 0x80 mask for SET_LENGTH; 0x10 mask for DESTROY; size offset; // -1 == unspecified size count; // -1 == unspecified }; struct channelSetLengthResponse { int requestID; byte subcommand; // same as in request Status status; };
// destroys any request with given requestID struct channelDestroyRequestInit { int serverChannelID; int requestID; };
struct channelProcessRequestInit { int serverChannelID; int requestID; byte subcommand = 0x08; FieldDesc pvRequestIF; PVField pvRequest; }; struct channelProcessResponseInit { int requestID; byte subcommand; // same as in request Status status; };
struct channelProcessRequest { int serverChannelID; int requestID; byte subcommand = 0x00 mask for PROCESS; 0x10 mask for DESTROY; }; struct channelProcessResponse { int requestID; byte subcommand; // same as in request Status status; };
struct channelGetFieldRequest { int serverChannelID; int requestID; string subFieldName; // entire record if empty }; struct channelGetFieldResponse { int requestID; Status status; [if status is success] FieldDesc subFieldIF; };
struct message { int requestID; byte messageType; // info = 0, warning = 1, error = 2, fatalError = 3 string message; };
struct channelRPCRequestInit { int serverChannelID; int requestID; byte subcommand = 0x08; FieldDesc pvRequestIF; PVField pvRequest; }; struct channelRPCResponseInit { int requestID; byte subcommand; // same as in request Status status; FieldDesc pvStructureIF; };
struct channelRPCRequest { int serverChannelID; int requestID; byte subcommand = 0x00 mask for RPC; 0x10 mask for DESTROY; BitSet toPutBitSet; PVField pvStructureData; }; struct channelRPCResponse { int requestID; byte subcommand; // same as in request Status status; FieldDesc pvResponseIF; PVField pvResponseData; };
Each TCP connection has an associated priority, which can be used by a server to prioritize requests. Regardless of how many channels are handled by either client or server, each client-server pair will be connected with exactly one TCP connection for each priority level. The priority is specified when TCP connection is being established.
When establishing a TCP connection, a simple handshake is performed. Client opens a TCP connection to the server and waits until Connection Validation message is received. Server initially sends a Set byte-order control message to notify client about byte-order to be used for this TCP connection. After this server sends Connection Validation message. If client correctly decodes the message it responds with Connection Validation response message. After that, client may start sending requests. The connection remains active as long as there is at least one channel active.
Both parties monitor incoming connection traffic. As long there is an incoming traffic TCP connection is considered as healty. If there is no incoming traffic detected within a predetermined period of time, an echo message is sent to the order party to trigger incomming traffic to appear. If there no response in a predetermined period of time, the connection is marked as unresponsive.
The connection is reported to be responsive when an incomming traffic is detected.
Usually flow control algorithms wait for congestion to occur before they are triggered. They are causal. Due to isolated nature of TCP connection, i.e. there are always only two parties involved, it is possible to predict congestions using the following algorithm:
NOTE: this part of the specification is still in progress.
In principle pvAccess uses the same channel disocvery mechanism as Channel Access; search messages are usually sent to a broadcast addresses and servers hosting searched channels respond with a message containing their TCP address and port.
In addition pvAccess transparently supports multicast, if an address is a multicast address the implementation should transparently handle it.
Proper UDP congestion control needs to be implemented to prevent flooding the network with UDP search messages. Currently variant of TCP Reno algoritmh is suggested (as in CA), but some more clever, simpler and robust algorithm needs to be specified.
This section describes all the control messages (0-th bit of pvAccessHeader.flags is set) for different pvAccessHeader.messageType values.
Payload size field holds the value of total bytes sent.
Payload size field holds the acknowledge value of total bytes received (must match previously received marked value).
7-th bit of header flags field indicated selected byte-order. Payload equals 0.


--- layout: default --- {% assign digital_toolbelt_your_growth = site.content_blocks | where: 'slug', 'digital-toolbelt-your-growth' | first %} {% assign digital_toolbelt_being_a_guide = site.content_blocks | where: 'slug', 'digital-toolbelt-being-a-guide' | first %} {% assign digital_toolbelt_destinations = site.content_blocks | where: 'slug', 'digital-toolbelt-destinations' | first %}
Version 1.0
How to use this resource:
This document is loaded with resources and links to tools that will help you as you guide.
Why Guides/Spiritual Outfitting?
What is a guide?
You Have Authority to Guide
Overcoming Guiding Barriers
How does this all fit together in the growth journey?
Guiding Resources
Making the Connection
Crossroads’ mission is to connect seekers to a community of growing Christ followers who change the world. We’re doing that as a spiritual outfitter, so that anyone in our community has the opportunity to get connected to a deeper relationship with Jesus. We will inspire, equip & mobilize staff and volunteer leaders throughout Crossroads to more fully engage as GUIDES for others in our community.
We Guide so that people become more like Christ.
Our goal is to develop Christ-like leaders, personally and practically living out our mission to help more people come into relationship with Jesus and to mature as Christ-followers:
A guide is someone who can hear someone’s story and help them take a next step in their relationship
with God.
They do this by:
Knowing their People
Touch base monthly. Listen to how things are going. Be available for them as they need.
Pray for them regularly Weekly, intentionally pray for what they’ve shared with you, or ask God for insight on how to guide them well.
Knowing Jesus and Crossroads
You have experience walking with Jesus.  And
remember, you’re not alone. It takes a village.
You’re aware of available resources. Or you know where to find them.
Helping them take a Next Step
You don’t have to have the answer for everything. But these tools will help you know where to look.
And you’re on a team who can help.
Follow up. What makes this different than anything we’ve tried before is relationship. It’s not a one-and-done hand-off or connection. You’re going to walk with someone over time and get to see God change their life. Now that’s an adventure.
Whether it’s your first time guiding someone or you’ve got too many people in your life you don’t know where to start, keep these things in mind.
You were made to guide.
It’s the last thing Jesus told us to do, and we have the Holy Spirit guiding us. It might get rocky at
times, but you’re also growing in the process.
You have something to offer.
Just because someone might be more mature, in a different life stage, or has completely different
experiences than you, doesn’t mean you can’t still be a good guide. Even if you simply connect,
listen, and pray, you’ve guided. And you have a team and resources to support you.
You will also benefit.
Not only will you grow as you guide, but the people you’re guiding can also grow to be guides. As
guides multiply and invest in others, your guiding efforts will be multiplied.
Many of your existing relationships aren’t just guides. You’re investing in them more deeply, they’re coming around your house and family, you talk to them more than once a month. That’s great. And needed. Not all guiding relationships go deeper, and it’s not expected for them to. But where you have additional relationship to lead others, go for it.
More on ways to lead people well.These tools provided will help you lead in the different types of relationships.
If you don’t find what you need here, there are other resources available to help you Guide well.
As you find out who you’re guiding, use this template to make the connection. Customize as you need for each relationship.


|
MDAL
|
Public Types | |
| typedef HdfH< H5I_DATASPACE > | Handle |
Public Member Functions | |
| HdfDataspace (const std::vector< hsize_t > &dims) | |
| memory dataspace for simple N-D array | |
| HdfDataspace (hid_t dataset=-1) | |
| dataspace of the dataset | |
| void | selectHyperslab (hsize_t start, hsize_t count) |
| select from 1D array | |
| void | selectHyperslab (const std::vector< hsize_t > offsets, const std::vector< hsize_t > counts) |
| select from N-D array | |
| bool | isValid () const |
| hid_t | id () const |
Protected Attributes | |
| std::shared_ptr< Handle > | d |


WITNESS LIST State Affairs Committee May 9, 2001 -12:00P HB 407 Registering, but not testifying: For: Woodford, Suzy (Common Cause Texas), Austin, TX On: Lundquist, Karen (Texas Ethics Commission), Austin, TX HB 1599 Registering, but not testifying: For: Woodford, Suzy (Common Cause Texas), Austin, TX On: McGeehan, Ann (Secretary of State), Austin, TX HB 1669 ON: Ward, Donald (One-Call Board of Texas), Austin, TX Registering, but not testifying: For: Grundman, Rick (Southern Union Gas), Austin, TX Lawson, Richard (Verizon), Austin, TX Leverty, Don (CoServ Utilities), Corinth, TX Luby, Jamie (WCOM), Austin, TX Nugent, Patrick (Association of Texas Intrastate Natural Gas Pipelines), Austin, TX Reinhart, Patrick (Southwestern Bell Telephone Company), Austin, TX Rigsbee, Ken (Phillips Petroleum Company), Austin, TX HB 1678 FOR: Walker, Carol (Texas Auto Recyclers), Houston, TX AGAINST: McAllister, Marcia (Insurance Auto Auctions), Schaumburg, IL ON: Griffith, David (Texas Department of Public Safety), Austin, TX Registering, but not testifying: For: Fuelberg, Curtis (Texas Auto Recyclers Association), Austin, TX Against: Ruggiero, Denise (State Farm Insurance), Austin, TX On: England, Dave (Texas Independent Auto Resellers Association), Austin, TX Hunt, Darrel (TxDOT), Austin, TX Providing written testimony: Against: Zora, Chris M. (The Center for Concerned Citizens For Automotive Safety), The Woodlands, TX HB 1811 FOR: Henneberger, John (Texas Low Income Housing Information Service), Austin, TX HB 1856 ON: McGeehan, Ann (Secretary of State), Austin, TX Registering, but not testifying: For: Woodford, Suzy (Common Cause Texas), Austin, TX HB 1996 Registering, but not testifying: On: Rawson, Carol (TxDOT), Austin, TX HB 2058 FOR: Lyons, Steve (Houston Police Department/City of Houston), Houston, TX Registering, but not testifying: For: Findeisen, Les (Texas Motor Transportation Association), Austin, TX HB 2391 ON: Ward, Donald (One-Call Board of Texas), Austin, TX Registering, but not testifying: For: Grundman, Rick (Southern Union Gas), Austin, TX Lawson, Richard (Verizon), Austin, TX Leverty, Don (CoServ Utilities), Corinth, TX Luby, Jamie (WCOM), Austin, TX Nugent, Patrick (Association of Texas Intrastate Natural Gas Pipelines), Austin, TX Reinhart, Patrick (Southwestern Bell Telephone Company), Austin, TX Rigsbee, Ken (Phillips Petroleum Company), Austin, TX HB 2475 Registering, but not testifying: On: Allen, Ron (Texas State Board Veterinary Medical Examiners), Austin, TX HB 2684 Registering, but not testifying: On: Randall, Jim (TxDOT), Austin, TX HB 2691 FOR: Bettencourt, Honorable Paul (Harris County Tax Assessor-Collector), Houston, TX Registering, but not testifying: For: Gaston, James (Texas Democratic Party), Austin, TX Hammerleiu, George (Harris County Tax Office), Houston, TX Kamm, Bob (Travis County Commissioners Court), Austin, TX Woodford, Suzy (Common Cause Texas), Austin, TX On: McGeehan, Ann (Secretary of State), Austin, TX Smith, Kim (Texas Department of Public Safety), Austin, TX SB 1831 Registering, but not testifying: On: Rawson, Carol (TxDOT), Austin, TX


The maximum amount you can stake is {{ (((candidate.selfVote * 10)-candidate.totalNomination) / chainxAccountService.divisor) | currency:'':'':'1.2-8'}} PCX
A node can only receive up to 10 times the votes it bonded, please contact the node to increase the bonded votes. More info (Proposal 01)
Select your PCX wallet you want to stake PCX from
Minimum Amount:
No limit
Maximum Amount:
The maximum amount is 10 times the votes a node has bonded (check the available amount)
Minimum Staking Period:
No limit. You can revoke your staking anytime. Once you do, your PCX stays frozen for another 3 days before you can unfreeze them.
You have no balance
The maximum amount you can increase is {{ (((candidate.selfVote * 10)-candidate.totalNomination) / chainxAccountService.divisor) | currency:'':'':'1.2-8'}} PCX
A node can only receive up to 10 times the votes it bonded, please contact the node to increase the bonded votes. More info (Proposal 01)
The maximum amount you can decrease is {{ (candidateStaked / chainxAccountService.divisor) | currency:'':'':'1.2-8' }} PCX
Simply add PCX to your staking
You can add additional PCX to you staking and earn more rewards.
Maximum Amount:
The maximum amount is 10 times the votes a node has bonded (check the available amount)
Simply decrease your PCX staking
You can revoke your PCX from staking partly or the full amount.
Once you do, that PCX stays frozen for another 3 days before you can unfreeze them.
After revoking an amount of staked PCX, they stay locked for 3 days before you can unfreeze and transfer them back to your free balance.


Ansible and PHP7 have been successfully installed. You can test PHP functionality by clicking here to load phpinfo.php.


{% extends "home/base.html" %}
{% block title %}
Dzień {{ date.day }}-{{ date.month }}-{{ date.year }}
{% endblock %}
{% block content %}
{% include 'calendar/day.html' with worked_hours=worked_hours cash_reports=cash_reports report=reports %}
{% endblock %}


I am a freelance writer on arts, pop culture, and public history. Most of my work has been as a contributor to the Broad Street Review, a non-profit online arts and culture publication for the greater Philadelphia area. You can read my work here.
“Scribes, Scholars, and Scripts: Reviewing Data from Scribes of the Cairo Geniza” (forthcoming) • Manuscript Studies: a Journal of Schoenberg Institute for Manuscript Studies


The Veggies Garden
Grow a beautiful Vegetable Garden at your home now!
Package includes five to seven vegetables of your choice.
Bangalore
Currently Available
Seasonal
25 Pots
The Zen Garden
Experience the zen bliss within your home space.
Recommended by many high profile users for relaxation and soothing.
Bangalore,Delhi
Currently Available
Year-round
30 Pots
The Medi Garden
Grow your favourite medicinal plants in your backyard.
Package includes common and exotic medicinal herbs.
Delhi
Currently Available
Year-round
10 Pots
The Patio Garden
It's got that Patio going!
Add this beautiful patio garden to your house for that greener peace.
Bangalore,Delhi
Currently Available
Seasonal/Year-round
25 Pots
The Greenhouse Garden
Are you ready to fall in love with your home garden?
We set up greenhouses based on space and design available.
Bangalore,Delhi
Currently Available
Year-round
40 Pots
The Succulent Garden
There are so many varities of succelent you would be surprised.
These succulent plants are cute and add a beautiful aesthetics to your house.
Bangalore,Delhi
Currently Available
Year-round
35 pots


---
layout: post
title: Interesting Reads 1/25-2/31
date: '2014-01-31T11:57:00.001-05:00'
author: Allison McMillan
tags:
- women in tech
- things I've read
modified_time: '2014-01-31T11:57:38.305-05:00'
blogger_id: tag:blogger.com,1999:blog-6054545261088815023.post-1732960844464141278
blogger_orig_url: http://allisonsherenmcmillan.blogspot.com/2014/01/interesting-reads-125-231.html
---
Another busy week but I've got some good stuff today. For better or worse, the reads this week are mostly NOT code related, but they are fun.
Enjoy!
Delicious Flags
Regex Crossword!! I haven't done this yet, but I totally want to!
Jewish Hair - Learning to love it
Conference calls in real life video


{% extends "layouts/base.html" %} {% block title %} Advanced-video-processing {% endblock %} {% block stylesheets %} {% endblock stylesheets %} {% block content %}
Applying the facial recognition system on recorded videos, in order to identify one (or more) person appearing in these videos :
Instead of going through all the videos and analyzing them to find the person you are looking for,
the user can identify him by entering his name. And also Finding one (or more) person from a video stream even if it is not registered in the database (Use a temporary database)
.
There are {{ len }} identified person between ( {{ intervall_start }}
{{ intervall_end }}
) in this {{ extension }}
( There are {{ len }} identified person in this {{ extension }} )
{% endif %}- {{j}} {% if dict_time %}( Time : {{ dict_time|get_value:key }}
) {% endif %}
- {{j}} {% if dict_time %} ( Time : {{ dict_time|get_value:key }}
) {% endif %}
Oops!, {{Person}}{{ msg }} between ( {{ intervall_start }}
{{ intervall_end }}
) .
Oops!, {{Person}}{{ msg }}.
{% endif %}


PAN Validator
Card Number
Results
Luhn Algorithm Check
close
Major Industry Identifier
close
Issuer identification number
close
Personal Account Number
close


Unai Emery told of the mistakes he made when replacing Arsene Wenger at Arsenal
Unai Emery spent big in the January transfer window, with Arsenal signing Nicolas Pepe for a club record £74million, but so far there has been little improvement
by Irishmirror.ieUnai Emery's biggest mistake was trying to change things too quickly at Arsenal when he took over from Arsene Wenger after 22 years.
That's the opinion of Matthew Upson, who reckons the Spaniard may have already lost the dressing room given how poor the Gunners have been in recent weeks.
Emery replaced Wenger at the start of last season, but has yet to improve Arsenal, with the club failing to qualify for the Champions League.
The Spaniard spent big in January, with Arsenal signing Nicolas Pepe for a club-record £74million, but there has been little to show for the investment, with the Gunners floundering down in sixth - a staggering 17 points behind league leaders Liverpool.
And Upson believes the players may have lost belief in their boss.
"Maybe, maybe that's the case," Upson said BBC Radio 5 Live. "Maybe there's already a loss of belief or whatever it may be in the manager.
"Emery came to the club and he tried to change things, he tried to be more disciplined.
"Again you have to look at the recruitment, don't you? To spend what they have spent on an attacking wide player, with the other issues that need to be addressed in the team.
"I thought he had a decent first season. At the end of last season you thought: 'You have to progress next season' but I don't think they have."
He added: "A loss to Southampton [leaves Emery] in real limbo because I think he's struggling. I was at Leicester and I saw a really poor performance from Arsenal.
"It was almost like they tried to cater to not get beat at Leicester who were on top form, and this is Arsenal, and never really got any kind of grip on the game."


Company profile - Canadian Company Capabilities
Third-Party Information Liability Disclaimer
Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.
GVA Lighting, Inc.
Legal Name:
GVA Lighting, Inc.
Operating Name:
GVA Lighting
Alternate Name:
GVA
GVA Lighting
Mailing Address:
14-3400 Ridgeway Dr.MISSISSAUGA, Ontario
L5L 0A2
Location Address:
14-3400 Ridgeway Dr.MISSISSAUGA, Ontario
L5L 0A2
Tel.:<PHONE_NUMBER>
Tel.:<PHONE_NUMBER>
Fax:<PHONE_NUMBER>
Logo
Company Profile
Design and manufacture LED lighting systems for architectural, commercial and retail applications.
Market leader in 380VDC lighting.
Full profile
Full profile
Contact information
Company description
Product / Service / Licensing
STR9® is totally weatherproof and IP66 rated for use in dry, damp or wet locations. GVA's Unibody design, proprietary sealing process and sealed connectors (even when unmated) contribute to the STR9's unmatched reliability.
New for 2014, the STR9 ®now features through-wiring for end-to-end fixture connection; greatly simplifying installation. New, more compact mounting brackets are also featured on the new design. Its clean, modern look and compact size make it virtually invisible on the structure to which it is installed.
INFINITY technology is available for the STR9® . Up to 264m or 866ft of STR9 luminaires can be connected end-to-end and powered from a single source.
STR9® is available with mono color LEDs, as well as RGB color changing and Dynamic White.
HIGHLIGHTEHL-COVE uses GVA Lightings proprietary power and control technology, INFINITY, which allows it be installed in exceptionally long runs. Up to 672 modules can be connected to one feed for a single run of up to 200m.
Highlighter® HL-DL which features GVA Lightings proprietary power and control system, INFINITY®, which allows it be installed in exceptionally long runs, up to 672ft or 200m, with a single power and data feed.
The HL-COVE-LITE is a 1800mm (6ft) long linear luminaire producing up to 2700lm and consuming a maximum of 30W. Each unit is connected end-to-end to form long continuous straight lighting runs.
Using GVAs proprietary power and control technology, INFINITY®, up to 432ft (130m of HL-COVE-LITE can be fed from a single point. This means no power supplies, junction boxes or branch connections are required for the entire length of the run.
PDB-INF-2000 is a 2000 Watt, 380V DC model with INFINITY® technology for long-run lighting installations.
Technology profile
Market leader in 380VDC lighting systems.
Market profile
Alliances:
Strategic alliances:
GVA Lighting goes global. We sell our products in most regions of the world.We sell our products through the network of local Sales Representatives and Authorized Distributors.
Selected segments of the market are supplied directly by GVA Lighting.
Choose your region/country to find our local Representative on http://gvalighting.com/salesnetwork
Industry sector market interests:
- Electrical Equipment
Geographic markets:
Export experience:
- Austria
- Belarus
- Belgium
- Finland
- France
- Germany
- Honduras
- Hong Kong
- India
- Japan
- Kuwait
- Netherlands
- Qatar
- Russian Federation
- Saudi Arabia
- Singapore
- United Arab Emirates
- United States
Sector information
Classification codes
Total plant size:
Unique applications:
380VDC lighting. Lighting solutions for 380VDC based data centers.Success stories:
http://www.theglobeandmail.com/report-on-business/economy/canada-competes/led-innovator-shines-with-projects-abroad/article4588920/http://www.theglobeandmail.com/report-on-business/economy/canada-competes/in-pictures-gva-lighting-makes-colourful-statement-abroad/article4587743/
Testimonial:
http://www.theglobeandmail.com/report-on-business/economy/canada-competes/led-innovator-shines-with-projects-abroad/article4588920/http://www.theglobeandmail.com/report-on-business/economy/canada-competes/in-pictures-gva-lighting-makes-colourful-statement-abroad/article4587743/
International capital projects:
Architectural illumination of National Library of Belarus.Architectural illumination of Al Garhoud Bridge, Dubai, UAE.
LED cove lighting at Berlin Konzerthaus, Berlin, Germany.
Architectural illumination of the Lotus Santhigiri Parnasala, Kerala, India.
Architectural illumination of Ryerson University, Toronto, Canada.
Architectural illumination of Market Street Bridge, Philadelphia PA, USA.
Architectural illumination of Hong Kong City Hall.
LED cove lighting at Scarborough Town Center, Canada.
LED cove lighting at Yorkdale Mall, Toronto, Canada.
Color changing illumination of Southern Alberta Institute of Technology, Calgary, Canada.
Third-Party Information Liability Disclaimer
Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.
Contacts
Contact information
Description
Company description
Products, services and licensing
Product / Service / Licensing
STR9® is totally weatherproof and IP66 rated for use in dry, damp or wet locations. GVA's Unibody design, proprietary sealing process and sealed connectors (even when unmated) contribute to the STR9's unmatched reliability.
New for 2014, the STR9 ®now features through-wiring for end-to-end fixture connection; greatly simplifying installation. New, more compact mounting brackets are also featured on the new design. Its clean, modern look and compact size make it virtually invisible on the structure to which it is installed.
INFINITY technology is available for the STR9® . Up to 264m or 866ft of STR9 luminaires can be connected end-to-end and powered from a single source.
STR9® is available with mono color LEDs, as well as RGB color changing and Dynamic White.
HIGHLIGHTEHL-COVE uses GVA Lightings proprietary power and control technology, INFINITY, which allows it be installed in exceptionally long runs. Up to 672 modules can be connected to one feed for a single run of up to 200m.
Highlighter® HL-DL which features GVA Lightings proprietary power and control system, INFINITY®, which allows it be installed in exceptionally long runs, up to 672ft or 200m, with a single power and data feed.
The HL-COVE-LITE is a 1800mm (6ft) long linear luminaire producing up to 2700lm and consuming a maximum of 30W. Each unit is connected end-to-end to form long continuous straight lighting runs.
Using GVAs proprietary power and control technology, INFINITY®, up to 432ft (130m of HL-COVE-LITE can be fed from a single point. This means no power supplies, junction boxes or branch connections are required for the entire length of the run.
PDB-INF-2000 is a 2000 Watt, 380V DC model with INFINITY® technology for long-run lighting installations.
Technology
Technology profile
Market leader in 380VDC lighting systems.
Market
Market profile
Alliances:
Strategic alliances:
GVA Lighting goes global. We sell our products in most regions of the world.We sell our products through the network of local Sales Representatives and Authorized Distributors.
Selected segments of the market are supplied directly by GVA Lighting.
Choose your region/country to find our local Representative on http://gvalighting.com/salesnetwork
Industry sector market interests:
- Electrical Equipment
Geographic markets:
Export experience:
- Austria
- Belarus
- Belgium
- Finland
- France
- Germany
- Honduras
- Hong Kong
- India
- Japan
- Kuwait
- Netherlands
- Qatar
- Russian Federation
- Saudi Arabia
- Singapore
- United Arab Emirates
- United States
Sector
Sector information
Classification codes
Total plant size:
Unique applications:
380VDC lighting. Lighting solutions for 380VDC based data centers.Success stories:
http://www.theglobeandmail.com/report-on-business/economy/canada-competes/led-innovator-shines-with-projects-abroad/article4588920/http://www.theglobeandmail.com/report-on-business/economy/canada-competes/in-pictures-gva-lighting-makes-colourful-statement-abroad/article4587743/
Testimonial:
http://www.theglobeandmail.com/report-on-business/economy/canada-competes/led-innovator-shines-with-projects-abroad/article4588920/http://www.theglobeandmail.com/report-on-business/economy/canada-competes/in-pictures-gva-lighting-makes-colourful-statement-abroad/article4587743/
International capital projects:
Architectural illumination of National Library of Belarus.Architectural illumination of Al Garhoud Bridge, Dubai, UAE.
LED cove lighting at Berlin Konzerthaus, Berlin, Germany.
Architectural illumination of the Lotus Santhigiri Parnasala, Kerala, India.
Architectural illumination of Ryerson University, Toronto, Canada.
Architectural illumination of Market Street Bridge, Philadelphia PA, USA.
Architectural illumination of Hong Kong City Hall.
LED cove lighting at Scarborough Town Center, Canada.
LED cove lighting at Yorkdale Mall, Toronto, Canada.
Color changing illumination of Southern Alberta Institute of Technology, Calgary, Canada.


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Serves 4
Fillets of plaice or lemon sole are simply fried in butter and served with a wholesome bean stew laced with chorizo.
Heat a large frying pan until medium-hot. Add the olive oil and the chorizo and cook for 5 minutes, or until the oil has changed colour and the chorizo is crisp around the edges.
Add the tomato, garlic and shallot. Gently fry for a minute, then add the peppers, beans, rosemary, thyme and paprika and cook for a further 2 minutes.
Add the stock and bring to a simmer. Cook for 4-5 minutes, or until the shallot has softened and the volume of liquid has reduced slightly. Stir in the butter, cream and parsley. Season, to taste, with plenty of black pepper.
For the fish, heat the oil in a medium frying pan. Once hot, add the fish skin-side down in the pan and cook for 2-3 minutes on each side. Add the butter and baste the fish with it as it melts.
To serve, place the beans in serving bowls and top with the fish.


${forkMeOnGitHub}
${site.name}
${pom.organization.name}
/
${site.name}
|
Last Published: ${currentYYYY-MM-DD}
${pom.version}
Overview
Introduction
${generatedMenu}
Project Documentation
Project Information
Project Team
Source Repository
Issue Tracking
Project License
Dependency Repositories
Dependency Convergence
Continuous Integration
Distribution Management
Javadocs
Project Reports
${body}
-- Top --
Load in a new window
×
Artifact Details
Gradle
Maven


${msg}
Notice:
- Doodle uses Google Calendar to send SMS Notification, the Google Calendar account should be the same with ADMIN_EMAIL in setting.py.
- You need verify your mobile phone at "Calendar Settings" - "Mobile Setup" via Google Calendar.
- It's not recommended to use password to login, you can set ADMIN_PASSWORD to '' in setting.py to enable login by AuthSub, which need to do more settings, but safer.
- If you use your own domail (not appspot.com domain), you need register your domain via Google's Manage Your Domains page. See more details at Registration for Web-Based Applications.
- The notification uses default calendar, you can switch to other calendar by this way:
- Create or select a calendar, find out the "Private Address" at its "Calendar Settings". Its XML address should look like:
http://www.google.com/calendar/feeds/.....%40group.calendar.google.com/private-...../basic
- Replace "private-...../basic" to "private/full", then you get the correct feed address:
http://www.google.com/calendar/feeds/.....%40group.calendar.google.com/private/full


Last weekend been playing with language defined here . The basic idea was to define a language which basic OpenGL immediate mode functions wrapped, in order to map these functions to a lisp expression. Also alowed some basic control constructs, such as loops.
Not impressive results but it was very important to include iterations as an experience for the test.
Example expression for objects of these kind:
(GL-APP-DRAW (GL-APP-LOAD-IDENTITY) (GL-APP-TRANSLATE-2D 50 50) (GL-APP-POINT-SIZE 2) (GL-APP-REPEAT-N 100 (GL-APP-ROTATE-2D (ABS 50)) (GL-APP-TRANSLATE-2D (GL-APP-REPEAT-VAR *TIME-VARIABLE*) (GL-APP-REPEAT-VAR (+ (ABS 0.95134205) 0.2058494))) (GL-APP-TRIANGLE-2D (GL-APP-REPEAT-VAR 50) (GL-APP-REPEAT-VAR (ABS (ASIN *TIME-VARIABLE*))) 0.4790219 (ABS (ASIN *TIME-VARIABLE*)) (- (GL-APP-REPEAT-VAR (ABS (ASIN *TIME-VARIABLE*))) *TIME-VARIABLE*) (ASIN *TIME-VARIABLE*)) (GL-APP-COLOR 0.93181205 0.96525383 0.021565903)))


There are a number of things about the source data that the reader should consider when viewing the figures on this page. These can be found here.


AWS::ApiGatewayV2::Model
The
AWS::ApiGatewayV2::Model
resource define a data model for an API. For more information, see
CreateModel in the Amazon API Gateway V2 API Reference.
Syntax
To declare this entity in your AWS CloudFormation template, use the following syntax:
JSON
{ "Type" : "AWS::ApiGatewayV2::Model", "Properties" : { "ApiId" :
String
, "ContentType" :String
, "Description" :String
, "Name" :String
, "Schema" :JSON object
} }
YAML
Type: "AWS::ApiGatewayV2::Model" Properties: ApiId:
String
ContentType:String
Description:String
Name:String
Schema:JSON object
Properties
ApiId
-
The ID of the API with which to associate this model.
Required: Yes
Type: String
Update requires: Replacement
ContentType
-
The content type for the model.
Required: No
Type: String
Update requires: No interruption
Description
-
A description that identifies this model.
Required: No
Type: String
Update requires: No interruption
Name
-
A name for the model. If you don't specify a name, AWS CloudFormation generates a unique physical ID and uses that ID for the model name. For more information, see Name Type.
Required: Yes
Type: String
Update requires: No interruption
Schema
-
The schema to use to transform data to one or more output formats. Specify null (
{}
) if you don't want to specify a schema.Required: Yes
Type: JSON object
Update requires: No interruption
Return Values
Ref
When you pass the logical ID of an
AWS::ApiGatewayV2::Model
resource to the intrinsic
Ref
function, the function returns the
model ID, such as
abc123
.
For more information about using the
Ref
function, see
Ref.
Examples
Model creation example
The following example creates a model
resource called MyModel
for an API called MyApi
.
JSON
"MyModel": { "Type": "AWS::ApiGatewayV2::Model", "Properties": { "Name": "ModelName", "ApiId": { "Ref": "MyApi" }, "ContentType": "application/json", "Schema": { "$schema": "http://json-schema.org/draft-04/schema#", "title": "DummySchema", "type": "object", "properties": { "id": { "type": "string" } } } } }
YAML
MyModel: Type: 'AWS::ApiGatewayV2::Model' Properties: Name: ModelName ApiId: !Ref MyApi ContentType: application/json Schema: $schema: 'http://json-schema.org/draft-04/schema#' title: DummySchema type: object properties: id: type: string
See Also
-
CreateModel in the Amazon API Gateway V2 API Reference


We are unable to send the invites out
You are able to invite and remove contributors. Only the lead organisation and lead applicant cannot be removed.
You are able to invite contributors from your own organisation.
You are able to invite and remove contributors. Only the lead organisation and lead applicant cannot be removed.
You are able to invite contributors from your own organisation.


The other day I found myself idly staring at a Pluto notebook, wondering about the logo and how it would move when animated.
using Luxor
function plutodots(radius=50; outercircleratio=0.75, innercircleratio=0.65)
old_color_sequence_dark = [
Luxor.darker_red, Luxor.darker_purple, Luxor.darker_green]
old_color_sequence_light = [
Luxor.lighter_red, Luxor.lighter_purple, Luxor.lighter_green]
new_color_sequence = [
Luxor.julia_red, Luxor.julia_purple, Luxor.julia_green]
points = between.(O + (0, radius), O - (0, radius), range(0, 1, length=3))
setline(radius/10)
@layer begin
for (n, p) in enumerate(points)
setcolor(old_color_sequence_light[n]...)
circle(p, outercircleratio * radius, :fill)
setcolor(old_color_sequence_dark[n]...)
circle(p, outercircleratio * radius, :stroke)
end
end
return points
end
@svg begin
plutodots()
end 600 300 "_assets/images/depth/pluto.svg"
Pluto.jl is the amazing new reactive notebook system for Julia programming.
I think the first thing I'd noticed about the logo was that it was using the old Julia colors - the two-tone light and dark sequence that was part of the original logo and that lasted all the way to Julia version 1.1 (May 2019). The rings were originally lighter and edged in a darker color, but after version 1.1 the logo took on a simpler, bolder look. Here's how the Julia application icons as seen on my MacOS have changed:
Not many things in the computer world get simpler over time, but icons and logos often do: they evolve to become stronger, simpler, and more direct, as unnecessary details are discarded. Simpler designs also prove to be easier to draw and print on t-shirts or lorries.
The developers of Pluto.jl are meticulous about many details, so they may well have chosen the edged disks deliberately because they made a clearer image. If they'd used the newer colours, they would have got something like this:
function moreplutodots(radius=50; outercircleratio=0.75, innercircleratio=0.65)
new_color_sequence = [ Luxor.julia_red, Luxor.julia_purple, Luxor.julia_green]
points = between.(O + (0, radius), O - (0, radius), range(0, 1, length=3))
setline(radius/10)
@layer begin
for (n, p) in enumerate(points)
setcolor(new_color_sequence[n]...)
circle(p, outercircleratio * radius, :fill)
end
end
return points
end
@svg begin
moreplutodots()
end 600 300 "_assets/images/depth/morepluto.svg"
and that's not an improvement - the colors are now clashing with each other too much. Perhaps with a white "atmosphere" around each one?
function moreplutodots1(radius=50; outercircleratio=0.75, innercircleratio=0.65)
new_color_sequence = [ Luxor.julia_red, Luxor.julia_purple, Luxor.julia_green]
points = between.(O + (0, radius), O - (0, radius), range(0, 1, length=3))
setline(radius/10)
@layer begin
for (n, p) in enumerate(points)
setcolor(new_color_sequence[n]...)
circle(p, outercircleratio * radius, :fill)
sethue("white")
circle(p, outercircleratio * radius, :stroke)
end
end
return points
end
@svg begin
moreplutodots1()
end 600 300 "_assets/images/depth/morepluto1.svg"
nah - this also looks a bit odd. Anyway, I'm happy to leave this task to the developers, who know what they want.
Instead, I go back to wondering how it would move. It feels like it wants to jump into the third dimension and move, somehow. So I thought it would be worth digging out an old package I'd made a few years ago that makes 3D vector graphics: Thebes.jl. It was covered in digital dust, but it's now been updated to Julia 1.0. It's a little toy package that has occasionally justified its existence.
Thebes.jl is a very simple package that feeds Luxor.jl with 2D projections of 3D wireframe coordinates. The 3D world of Thebes and the 2D world of Luxor coexist happily:
using Thebes, Luxor
@svg begin
axes3D() ## Thebes
rulers() ## Luxor
end 600 300 "_assets/images/depth/the_realm.svg"
(The modern city of Luxor is built on the remains of the ancient Egyptian capital city of Thebes, hence the name.)
The two main things to know in Thebes.jl are:
the Point3D
type
the pin()
function
For example, say you want to draw a pentagon. You use Luxor's ngon()
function, convert the points to 3D with convert()
, which adds a z-ccordinate of 0.0, and then, when you're ready to finally draw them, use pin()
to convert them back to 2D and place them on the current Luxor drawing.
@svg begin
axes3D()
pentagon = convert.(Point3D, ngon(O, 150, 5, 0, vertices=true))
pin(pentagon)
end 600 400 "_assets/images/depth/pentagon.svg"
The name pin()
could be an acronym for "project it now!", but it was originally based on the idea of pinning 3D things onto a flat board. And the word is very short and doesn't clash with common words like draw
and plot
and paint
from other packages. There's a pin()
function in Pkg.jl, but I don't think it's exported from there.
@svg begin
htroch = convert.(Point3D, hypotrochoid(150, 27, 41, vertices=true))
pin(htroch)
axes3D(50)
end 600 300 "_assets/images/depth/htroch.svg"
Our brains spend a lot of time creating believable 3D worlds out of images displayed on flat surfaces such as phones, computers, and televisions, so it's not surprising that a few suggestive graphical shapes can produce a convincing 3D scene. The brain can't help but make them exist in 3D space, even though they're just 2D lines and polygons.
In this next example, it's even slightly disappointing that the 2D shapes aren't really intersecting each other. But they're just coloured shapes...
Here, the gfunction()
is the graphic action that's applied to the argument of pin()
.
gfunction(p3, p2) = poly(p2, close=true, :fill)
function main()
@svg begin
axes3D(200)
setopacity(0.5)
eyepoint(200, 200, 200)
perspective(200)
plane = convert.(Point3D, box(O, 250, 300, vertices=true))
sethue("green")
pin(plane, gfunction=gfunction)
rotateby!(plane, π/2, 0, 0)
sethue("red")
pin(plane, gfunction=gfunction)
rotateby!(plane, 0, π/2, π/2)
sethue("blue")
pin(plane, gfunction=gfunction)
end 600 400 "_assets/images/depth/planes.svg"
end
main()
Since I've not yet worked out how to draw Bézier paths in 3D, the best way to draw a circle at the moment is to make a many-sided polygon.
function disks()
helloworld() # reset to default view
@svg begin
sethue("grey40")
carpet(200)
d1 = convert.(Point3D, ngon(O, 50, 80, 0, vertices=true))
d2 = convert.(Point3D, ngon(O, 50, 80, 0, vertices=true))
d3 = convert.(Point3D, ngon(O, 50, 80, 0, vertices=true))
for (n, d) in enumerate((d1, d2, d3))
randomhue()
moveby!(d, Point3D(100cos(2π/3 * n), 100sin(2π/3 * n), 0))
pin(d, gfunction = (p3, p2) -> poly(p2, close=true, :fill))
end
axes3D()
end 600 400 "_assets/images/depth/disks.svg"
end
disks()
And wireframe spheres can be made in a similar way.
disk(r) = convert.(Point3D, ngon(O, r, 80, 0, vertices=true))
function sphere()
sethue("red")
d = disk(100)
rotateby!(d, 0, π/2, 0)
for n in 1:50
pin(rotateby!(d, 0, 0, 2π/50))
end
sethue("blue")
d = disk(100)
for n in 1:50
pin(rotateby!(d, 0, 2π/50, 0))
end
end
function spheres()
@svg begin
setline(0.5)
setlinejoin("bevel")
tiles = Tiler(600, 300, 1, 2)
@layer begin
translate(first.(tiles)[1])
eyepoint(200, 200, 200)
axes3D(150)
sphere()
end
@layer begin
translate(first.(tiles)[2])
eyepoint(0.1, 0, 200)
axes3D(150)
sphere()
end
end 700 400 "_assets/images/depth/spheres.svg"
end
spheres()
There are also a few functions that move and rotate 3D points. For example, the rotateby!()
function rotates a 3D polygon by specific angles. I haven't written one that rotates it to a specific orientation.
With these simple tools it's quite easy to make things move in space and time.
disk(r) = convert.(Point3D, ngon(O, r, 80, 0, vertices=true))
drawpoly(p3, p2) = poly(p2, close=true, :stroke)
function frame(scene, framenumber)
helloworld()
axes3D()
background("grey5")
setline(15)
step = 2π/scene.framerange.stop
d1, d2, d3 = scene.opts
sethue(Luxor.julia_red)
pin(rotateby!(d1, step, 0, 0), gfunction = drawpoly)
sethue(Luxor.julia_purple)
pin(rotateby!(d2, 0, step, 0), gfunction = drawpoly)
sethue(Luxor.julia_green)
pin(rotateby!(d3, step, step, step), gfunction = drawpoly)
end
function makemovie()
d1 = disk(150)
d2 = disk(100)
d3 = disk(50)
amovie = Movie(400, 400, "a movie")
animate(amovie, [Scene(amovie, frame, 1:100, optarg=(d1, d2, d3))],
framerate=25,
creategif=true,
pathname="_assets/images/depth/amovie.gif")
end
makemovie()
The main problem with this animation is that the three rings don't interact in three dimensions - they're completely independent of each other.
For there to be real depth in an image, the depths of each point have to compared. That's a bit more work - you have to collect all the lines and then work out how they interact with each other. The code is a bit too long for this post, but the results are OK, particularly if we gradually change the colours too:
And because it's all parameterized, there are plenty of interesting variations to explore:
This one looks a bit familiar:
Going back to where I started: I think I'm imagining the animation to be like three cars in a damaged ferris wheel (think of the London Eye after it was vandalized during the famous Brexit riots of 2021...).
Here's an animation to show what I mean. It's possible to make two 3D views, one for each pane, with different viewing parameters for each one. The manual for Thebes.jl has a little more information about 3D views.
function frame(scene, framenumber)
helloworld()
background("grey20")
setline(5)
# create two panes for the two views
panes = Tiler(800, 400, 1, 2)
r = scene.easingfunction(framenumber, 0, 1, scene.framerange.stop)
julia_colors = [Luxor.julia_red, Luxor.julia_purple, Luxor.julia_green]
# Say there are L cars in a ferris wheel
L = 16
# make the first view, a standard perspective view
@layer begin
translate(first.(panes)[1])
helloworld()
perspective(500)
eyepoint(250, 250, 250)
axes3D()
circuit = [Point3D(150cos(θ), 150sin(θ), 0) for θ in range(0, 2π, length=L)]
rotateby!(circuit, -π/2, r * 2π, 0)
disks = []
for (n, i) in enumerate(circuit[5:7]) # just cars 5, 6, and 7
d1 = convert.(Point3D, ngon(O, 50, 30, 0, vertices=true))
moveby!(d1, i)
push!(disks, (d1, n))
end
# sort by depth
sort!(disks, lt = (a, b) -> first(a)[1].z < first(b)[1].z)
for disk in disks
sethue(julia_colors[last(disk)])
pin(first(disk), gfunction = (_, p2) -> poly(p2, :fill))
sethue(1.2 .* julia_colors[last(disk)])
pin(first(disk), gfunction = (_, p2) -> poly(p2, close=true, :stroke))
end
end
# make the second view, from the top
@layer begin
translate(first.(panes)[2])
helloworld()
perspective(0)
eyepoint(5, -0.1, 200)
axes3D()
for disk in disks
sethue(julia_colors[last(disk)])
pin(first(disk), gfunction = (_, p2) -> poly(p2, :fill))
sethue(1.2 .* julia_colors[last(disk)])
pin(first(disk), gfunction = (_, p2) -> poly(p2, close=true, :stroke))
end
end
end
ferriswheel = Movie(800, 500, "ferris")
animate(ferriswheel,
Scene(ferriswheel, frame, 1:100, easingfunction=easeinoutcubic),
framerate=10,
creategif=true,
pathname="_assets/images/depth/ferriswheel.gif")
Talking of Pluto, Pluto (the planet) has five times as many moons as the Earth. I thought I'd create a simulation of the Plutonian system of moons. I haven't got the time or astronomical skill to do it for real, but it's relatively easy to fake a quick animation using the orbital details listed on wikipedia.

You can just make out the barycentric orbit of Pluto and Charon - they're both orbiting around a point that lies above the surface of Pluto.
function drawgrid()
@layer begin
sethue("grey15")
setline(1)
k = 100
[pin([Point3D(x, y, 0),
Point3D(x, y + k, 0),
Point3D(x + k, y + k, 0),
Point3D(x + k, y, 0)]) for x in -500:k:500, y in -500:k:500]
end
end
plutoniansystem = [
(name = "Pluto",
diameter = 2376, mass = 1305,
radius = 2035, period = 6.38723, init = 0),
(name = "Charon",
diameter = 1212, mass = 158,
radius = 17536, period = 6.38723, init = 0.5),
(name = "Styx",
diameter = (16 + 9 + 8)/3, mass = 0.00075,
radius = 42656, period = 20.16155, init = .1),
(name = "Nix",
diameter = (49.8 + 33 + 31)/3, mass = 0.005,
radius = 48694, period = 24.85, init = .2),
(name = "Kerberos",
diameter = (19 + 10 + 9)/3, mass = 0.0016,
radius = 57783, period = 32.16756, init = .3),
(name = "Hydra",
diameter = (50.9 + 36.1 + 30.9)/3, mass = 0.005,
radius = 64738, period = 38.20177, init = .4)]
function frame(scene, framenumber)
orbits = scene.opts
background("black")
eased_n = scene.easingfunction(framenumber, 0, 1, scene.framerange.stop)
sethue("grey80")
fontsize(20)
fontface("JuliaMono")
perspective(600)
eyepoint(400, 400, 400)
drawgrid()
for (n, e) in enumerate(plutoniansystem)
body = convert.(Point3D, ngon(O, rescale(e.diameter, 11, 2376, 1, 15), 30, 0,
vertices = true))
moveby!(body, orbits[n][mod1(framenumber, end)])
rotateby!(body, midpoint(body[1], body[15]), -π/4, 0, -π/4)
pin(body, gfunction = (p3, p2) -> begin
poly(p2, :fill)
text3D(" " * e.name, p3[1], rotation=(0, 0, deg2rad(135)))
end)
end
end
function drawplutonian()
orbits = Array{Point3D, 1}[]
for e in plutoniansystem
scaledradius = rescale(e.radius, 2035, 64738, 10, 300)
scaledperiod = convert(Int, floor(e.period * 100))
orbit = [Point3D(scaledradius * cos(ϕ + (2π * e.init)), scaledradius * sin(ϕ + (2π * e.init)), 0) for ϕ in range(0, 2π, length = scaledperiod)]
push!(orbits, orbit)
end
plutonian = Movie(800, 500, "plutonian system")
animate(plutonian, Scene(plutonian, frame, 1:638, optarg = orbits),
framerate = 50,
creategif = true,
pathname = "_assets/images/depth/plutonian.gif")
end
drawplutonian()
Of course I'm very tempted to give it some colours - but in reality I think it's all pretty bleak out there in deep space so I'd better not.
[2020-09-22]
This page was generated using Literate.jl.


The simplest way to understand Blocks, Procs and Lambdas in Ruby is as different ways of organizing code in our programs. In computer science, they are all called "closures". They have far more in common than they have apart, and Blocks are generally understood as the most basic of the three, so we will inspect them first.
A block should already look familiar to anyone with a few weeks' Ruby programming, even if it is not recognized by that name. Consider the following example:
array = [0, 1, 2, 3] # Creating a new array of numbers
array.map! { |x| x * 5 } # The block is everything in the {}
#=> Returns [0, 5, 10, 15]
# Below is an alternate syntax -- the block is everything inside the "do" and "end"
array.map! do |x|
x + 2
end
#=> Returns [2, 7, 12, 17]
As noted in the comments, the block is contained inside the {} or "do" "end" words -- the only difference there being stylistic. Typically we use the {} when the block can fit onto one line, and the "do" "end" syntax for anything longer. Inside those wrappers we have our block of code, which performs whatever operation we want -- in this case, multiplying each element in the array by 5, or adding 2 to each element. Pretty straightforward.
Procs (short for "procedures") are like blocks, but they have the added benefit of allowing you to assign a variable to them so you can use the same piece of code over again. This can be very handy, and is very Ruby-esque, in helping to eliminate repetitive code from a program. Rather than having to write the same block multiple times, you could simply assign it to a proc and just pass that to any method that accepts callable objects instead. Let's see an example:
array = [0, 1, 2, 3] # Creating a new array, same as before
times_5 = Proc.new { |x| x*5 } # Creates a new Proc instance
array.map!(×_5) # Calls the map! function with our new Proc instance
#=> Returns [0, 5, 10, 15]
array.map!{×_5) # Let's call it one more time
#=> Returns [0, 25, 50, 75]
Here the same block of code instructing the array to multiply each element by 5 is assigned to a Proc instance that we've called
Finally, we have Lambdas, which are technically also Proc objects -- just with their own little twist. An example illustrates best:
lam_test = lambda { |x| x*5 } # Creates new lambda instance
lam_test.call(4) # Returns 20
lam_test.call(1,2) # Returns ArgumentError: wrong number of arguments (2 for 1)
lam_test.call # Returns ArgumentError: wrong number of arguments (0 for 1)
As we see above, lambdas require you input the correct number of arguments -- in this example, one. If you input more or less, you get an ArgumentError. Procs do not behave this way -- if you pass a proc too many arguments, it just takes the first one(s) that it needs, and if you don't pass it any, it just returns nil.
And there is one other important difference between Procs and Lambdas worth mentioning -- how they handle
def proc_example
Proc.new { return "Inside the Proc block" }
return "Outside the Proc block"
end
def lambda_example
lambda { return "Inside the Lambda block" }
return "Outside the Lambda block"
end
puts proc_example
puts lambda_example
When we run this, we see that the proc_example returns


Get a print-out of each commit made to a repository.
Setup is simple. Just go to the 'Service Hooks' part of your repo's settings, and add the following URL as a WebHook URL:
http://little-commits.herokuapp.com/hook/YOUR_PRINT_CODE
Replace YOUR_PRINT_CODE
with your direct print code. Find it here.
Your print code is not stored, and if you want you can reset it on the page where you found it.
If you want, you can check out the source code on GitHub.


|
|
In The Brrrgh you are sure to meet Lil’ Oldman, the most legendary Toon in town. Lil’ Oldman can be one tough bunny, and maybe a little peculiar, but he is a master with the gags. Like any good coach he’ll work you hard, but in the end it’s worth it. No pain, no gain, right?
|
Here is a list of everything you will earn by completing all of the The Brrrgh’s tasks:
- A Laff point limit of 61
- Training for your sixth gag track
- Carry 50 gags
- Carry 120 jellybeans
- Carry four ToonTasks
- Teleport access to The Brrrgh playground
|
|
|
|


Who do you think created some of the most unique and facsinating historical technological advances? Countless women have been responsible for producing technological feats, yet many are not acknowloged. More often then not, when you read about science, technology, and computers, men's names are readily available. This gender disparity results from selective story telling by historians and organizations employing industry females.
The story of Jean Bartik and the ENIAC completely throws those common "males are the successful ones in science" assumptions out the window!
"I just say do what you love. I loved every minute of what I did. If you don't love what you do, what do you have?"


Match Play. 0-0 to 7. Should Red double to 8? If redoubled, should White take?
pips Red=48 White=87
(CorrectAnswer= 0/0, ErrorScore= 0)
My thanks to Alastair Woods for an accurate and succinct analysis which I won’t repeat unnecessarily so please read Alastair’s his comment.
This is the sort of situation where you need to take the time to do the necessary arithmetic as the outcome will in all likelihood determine the match result.
My opponent on Gridgammon didn’t and dropped the redouble quite quickly. Maybe he believed himself to be the better player and didn’t want to put the match on the line in one game? I will never know – I was just grateful for his error.
This is the sort of situation where you need to take the time to do the necessary arithmetic as the outcome will in all likelihood determine the match result.
My opponent on Gridgammon didn’t and dropped the redouble quite quickly. Maybe he believed himself to be the better player and didn’t want to put the match on the line in one game? I will never know – I was just grateful for his error.
Cube analysis 2-ply cubeless equity +0.490 (Money: +0.491) 0.738 0.015 0.000 - 0.262 0.000 0.000 Cubeful equities: 1. Double, take +0.908 2. Double, pass +1.000 (+0.092) 3. No double +0.548 (-0.360) Proper cube action: Redouble, take


posted 6 years ago
I think I found the problem. I checked by trying to save a text file right to that location manually and got a "you don't have permission error".
You can't save directly to the C drive like that I think.
Normally, since most Computers have a Users directory underneath the C drive, yours might not but the chances are high that it does,
then you would make a new Directory under the users directory, you might be able to just create it programmatically.
Anyway,
try creating it as C:/Users/SomeDirectory/textfile.txt
At the very least, you need a subdirectory underneath C. You can't just save something as a file itself to the C drive itself.
Sorry, scratch that, normally under the Users directory, you have a directoy that is your computer name. I wouldn't know what yours is.
so it's
C:/Users/YourComputerName/textfile.txt
that will work.
Repeal Obamacare.
http://www.dontfundobamacare.com/
http://liberty-amendments.freeforums.net/


India register Test triumph inside three days
A clinical performance from Virat Kohli's side to claim an easy victory by an innings and 130 runs
by AFPMohammed Shami took four wickets as India crushed Bangladesh by an innings and 130 runs inside three days of the first Test on Saturday.
Bangladesh were bowled out for 213 in the final session in Indore after their gamble to bat first after winning the toss backfired badly against the Indian pace attack.
Shami's fellow fast bowlers Umesh Yadav and Ishant Sharma shared three wickets between them after India declared their first innings on 6-493, with a lead of 343 runs.
"The captain gave me the freedom to bowl the way I wanted and it went well," Shami said after the game. "Having Umesh and Ishant alongside me is a plus."
Bangladesh batsman Mushfiqur Rahim offered some resistance, hitting 64 after Rohit Sharma dropped him on four off Shami.
Mushfiqur, who scored 43 in Bangladesh's 150 in the first innings, finally became one of three wickets taken by off-spinner Ravichandran Ashwin.
Ashwin, who reached 250 wickets in home Tests in the first innings, got last man Ebadat Hossain for one to spark India's victory celebrations.
India were dominant with the bat and ball against Bangladesh.
Opening batsman Mayank Agarwal played a key part in the win with his 243 - his second double century in four Tests - as India amassed 407 runs on the second day.
The bowlers kept up the pressure when Bangladesh started their second innings.
Yadav drew first blood, taking Imrul Kayes for six on a ball that curved into the left-hander and rattled the leg stump.
Ishant Sharma got Shadman Islam for six in the next over. Shami then trapped skipper Mominul Haque lbw for seven.
Mominul was given not out by the on-field umpire but India skipper Virat Kohli successfully reviewed the decision with replays showing the ball would have hit leg stump.
Shami, who also took three wickets in the first innings, took Mohammad Mithun for 18.
Bangladesh skipper Mominul said the batting of Mushfiqur and bowling of Abu Jayed had been the only positives in the disappointing defeat.
Abu Jayed stood out with his four wickets in the Indian innings but got little support from his teammates.
The second and final match is a day-night clash, with India hosting their first-ever pink-ball Test at Kolkata's Eden Gardens from November 22


HTML ESCAPE CODES
<div class="eulsoo">
- Copyright : © ©
- Registered trademark :® ®
- Trademark : ™ ™
- Less than : < <
- Greater than : > >
- Ampersand : & &
- Quotation mark : " "
- Left single quotation mark : ‘ ‘
- Right single quotation ’ ’
- Asterisk operator : ∗ ∗
- Division sign : ÷ ÷
- Multiplication sign : × ×


View Logan Halloween Costume Gif. See more ideas about kids costumes, halloween costumes, halloween costumes for kids. Get in costume as logan a.k.a.
How to dress like wolverine (logan). I was sally from nightmare before christmas and. Get in costume as logan a.k.a.
How to dress like wolverine (logan).
Wolverine halloween costume with diy claws and hair styling, plus get some ideas for alternate logan. Musclesuit costume muscle suit bodybuilder soldier wolverine rembo wwe halloween. Buy products such as jurassic world: Wolverine halloween costume with diy claws and hair styling, plus get some ideas for alternate logan.


{% extends 'base.html' %} {% load static %} {% block content %}
Choose Excel to Import
Choose the JSON File   Upload
File uploaded : {{ uploaded_file_url }}
JSON : {{ uploaded_json_url }}


During the game, the Player will find with a set of Characters, and he will be able to interact with them and talk to them. This Characters will provide content for the stories.


The canonical Open Addresses graph database, that stores all address information, history, and provenance.
Ernest has an API for storing data directly, but you wouldn't normally use it. Instead, you'd write scrapers using Turbot, and it sends them into Ernest. However, there are a couple of things you can do directly:
As well as storing addresses, Ernest calculates statistical confidence for an addresses existence. We've exposed this as an API, so other people can benefit.
If you want to validate the statistical confidence of an address you have, simply POST an address in the following format to https://ernest.openaddressesuk.org/confidence
:
{
"paon": "10",
"street": "Downing Street",
"town": "London",
"postcode": "SW1A 2AA",
"valid_at": "2015-01-01"
}
The "valid_at"
variable is the date (in ISO 8601 format) where the address can be confidently said to have existed. It is optional, and the calculation will default to today's date if it is missing
Here's an example using curl:
curl -X POST -H "Content-Type: application/json" -d '{"paon": "10", "street": "Downing Street", "town": "London","postcode": "SW1A 2AA"}' http://ernest.dev/confidence
You will then get a response in this format:
{
"address":{
"paon":"10",
"street":"Downing Street",
"town":"London",
"postcode":"SW1A 2AA"
},
"confidence":277.8294763284328
}
(Where "confidence"
is the calculated statistical confidence of the addresses existence - a value between 1 and 1000).
For more about our approach to confidence, and the calculations we use, see the blog post on confidence, or the detailed paper.
We use open data sources to create addresses, but it's still really handy to be able to confirm they exist (or don't). The address validation API allows clients to confirm addresses with optional reason and attribution statements.
| Option Name | Description | Format | Required? | Example |
|---|---|---|---|---|
| exists | Does the address exist? | true | false | yes | false |
| reason | A reason why the validation is what it is. | free text | no | The building has burnt down |
| attribution | Who or what checked the address? | free text | no | Bob Fish (using iOS validator app http://example.com) |
If you want to validate an address from your own web pages, then the main OpenAddresses website provides a simple bit of Javascript you can use. It depends on jQuery, so you'll need that as well.
<script src='https://code.jquery.com/jquery-2.1.3.min.js'></script>
<script src='https://alpha.openaddressesuk.org/assets/validate_address.js'></script>
<script>
function onValidateComplete(success) {
// Let the user know what happened
}
url = "https://alpha.openaddressesuk.org/addresses/rfV3zh"; // 10 Downing Street
validateAddress(url, // The URL of the address being validated on openaddressesuk.org
true, // Does the address exist?
"Bob Fish", // Attribution (optional)
"I'm standing outside it", // Reason (optional)
onValidateComplete); // Callback method for success or failure.
</script>
Using the API directly is slightly more complex, but not much. The main wrinkle is that while you want to validate an entry on https://openaddressesuk.org, you are actually validating the entry in the canonical ernest database, which those public addresses are derived from. So there are a couple of steps:
Get the JSON version of the address you want to verify from https://openaddressesuk.org. For instance, if you're verifying https://alpha.openaddressesuk.org/addresses/rfV3zh
, you'll want to get https://alpha.openaddressesuk.org/addresses/rfV3zh.json
.
{
address: {
url: "https://alpha.openaddressesuk.org/addresses/rfV3zh",
sao: null,
pao: "10",
street: {
name: {
en: [
"DOWNING STREET"
],
cy: [ ]
},
url: "https://alpha.openaddressesuk.org/streets/PXxwpD"
},
...
provenance: {
activity: {
executed_at: "2015-02-03T02:09:09.133Z",
processing_scripts: "https://github.com/OpenAddressesUK/distiller",
derived_from: [
{
type: "Source",
urls: [
"http://ernest.openaddressesuk.org/addresses/2935752"
],
downloaded_at: "2015-02-03T02:09:09.133Z",
processing_script: "https://github.com/OpenAddressesUK/distiller/tree/e1422600af0ee489e18c871cb93566151468f3e3/lib/distil.rb"
},
...
]
}
}
}
}
In that JSON, you can see that there is an ernest URL in the derivations. This shows the canonical address record in ernest that the address was based on. That's what you need to validate. Get hold of that URL, and then it's time for step 2.
POST a JSON document to the ernest record's validations
resource. If your ernest URL is https://ernest.openaddressesuk.org/addresses/2935752
, POST to https://ernest.openaddressesuk.org/addresses/2935752/validations
. The JSON document is very simple:
{ "exists": true, "reason": "I'm standing outside it", "attribution": "Bob Fish" }
You only have to provide exists
. The rest is optional.
If it works, you'll get back a 201
. If there was a problem with your input, you'll get a 400
.
If you notice anything wrong, please let us know, or better still open a pull request to fix it!.
This was built by the team at OpenAddresses. To find out more, visit the project website.


Version 0 A/C detail message, has an inherited header plus an array of XPMP2::RemoteAcDetailTy elements.
More...
|
| static constexpr size_t | NumElem (size_t _msgLen) |
| | Convert msg len to number of arr elements. More...
|
| |
Version 0 A/C detail message, has an inherited header plus an array of XPMP2::RemoteAcDetailTy elements.
◆ convert()
| RemoteMsgAcDetailTy * XPMP2::RemoteMsgAcDetailTy_v0::convert |
( |
size_t |
_msgLenV0, |
|
|
size_t & |
_msgLen |
|
) |
| const |
Convert v0 to v1 message, must be freed after use!
- Parameters
-
| _msgLenV0 | Message length of this message, ie. the v0 version |
| [out] | _msgLen | receives the message length of the converted message |
- Returns
- pointer to the converted message
Mallocates a memory chunk large enough for the v1 message (which could be larger than a real-life v1 message!) and converts each detail array element into it.
◆ NumElem()
| static constexpr size_t XPMP2::RemoteMsgAcDetailTy_v0::NumElem |
( |
size_t |
_msgLen | ) |
|
|
inlinestaticconstexpr |
Convert msg len to number of arr elements.
◆ arr
basis for the array of actual details
The documentation for this struct was generated from the following file:


Boggle solver
Words are matched against the Scrabble dictionary
Number of cells/rows
Randomize
Solve
Found words


The difference between this object and the rgb_pixel is just that this struct lays its pixels down in memory in BGR order rather than RGB order. You only care about this if you are doing something like using the cv_image object to map an OpenCV image into a more object oriented form.
So you should be able to use cv_image objects with many of the image processing functions in dlib as well as the GUI tools for displaying images on the screen.
SURF: Speeded Up Robust Features By Herbert Bay, Tinne Tuytelaars, and Luc Van Gool
Also note that there are numerous flavors of the SURF algorithm you can put together using the functions in dlib. The get_surf_points() function is just an example of one way you might do so.
SURF: Speeded Up Robust Features By Herbert Bay, Tinne Tuytelaars, and Luc Van GoolThis implementation was also influenced by the very well documented OpenSURF library and its corresponding description of how the fast Hessian algorithm functions:
Notes on the OpenSURF Library by Christopher Evans
Histograms of Oriented Gradients for Human Detection by Navneet Dalal and Bill Triggs
Note that you must define DLIB_JPEG_SUPPORT if you want to use this object. You must also set your build environment to link to the libjpeg library. However, if you use CMake and dlib's default CMakeLists.txt file then it will get setup automatically.
Note that you must define DLIB_PNG_SUPPORT if you want to use this object. You must also set your build environment to link to the libpng library. However, if you use CMake and dlib's default CMakeLists.txt file then it will get setup automatically.