Understanding neuronal networks
I tried to understand neuronal networks and deep learning. Therefore I read an viewed some really great tutorials, that I append on the end. You can find the custom implementations of neuronal networks here. The purpose is to try to understand the concepts and mathematics and to implement an own neuronal network from scratch.
Other work
Bottom to top
The explanation of Andrej Karpathy uses a bottom to top approach. He describes first how circuits are used to do calculations and goes then to backpropagation and calculus and then to neuronal networks.
Top to bottom
Th explanation of 3Blue1Brown uses a top to bottom approach. He describes first a neuronal network, then backpropagation and then the calculus behind it.
My try
For my neuronal network, I use the classic hello world program of machine learning: prediction handwritten digits.
Neuron
A neuron is just a ‘box’ that computes input values to an output value. It does this by getting a input values from previous neurons, giving them a weight and adding a bias. As an formular this looks like: ax + c, where a is the input from a previous neuron, which gets multiplied with an weight x, and c is the bias. As the bological neurons, a neuron does not send values always. That means, it does not fire all the time. To specify when it fires, you wrap the calculation of the output value into an activation function.
Neuronal network
A neuronal network consists of multiple layers that contain multiple neurons. The first layer is the input layer and holds the input data. The last layer is the output layer and computes the predictions.
Steps
Data
First you have to get data. This step contains often cleaning up and transforming the data, like in ETL processes. For the handwritten digits, this means, that you have to transform them in way you can pass them in the network. For example by resizing all images to one size, e.g. 28 px x 28 px and to align the images in the center. Then you can parse the images to a digist format, like a value between zero and one, depending on the darkness of the pixel. In the MNIST data set, all this done for you.
Training
Forwading data
Then the data has to loaded in the input layer. That means that the neurons of the input layer will be set with the data as value. As the pixels from the digits are loaded as an array of float numbers, each of them will be loaded in a single input neuron.
Backpropagation + Maths
After forwarding the data, all neurons will have random biases and weights, as well computed values and activations. Also the output neurons will have computed an prediction. Now you have to turn the prediciton into an understandable value, based on the goal of the network. For example you can create ten output neurons for the possible outputs of the network: numbers between zero and nine. Depending of the output values of each neuron you can calculate how much they are wrong or right. For example this can be done by a formular called mean squared error.
Testing
To check how accurate your network is, you have to test against data that it has never seen. Then you can simply calculate the error rate.
Implementing neuronal networks
One hidden layer with one neuron
The full code can be found here.
One hidden layer with multiple neurons
The full code can be found here.
Mulitple layers with multiple neurons
The challenge with multiple layers is that the backpropagation gets complexer, as changes on the first hidden layer will have impact on a lot of neurons because of the next connections between the neurons of the next layers. The challenge with multiple neurons per layer is that instead of one weight and input pair, the neuron has to calculate the sum of multiple pairs of weights and input values. Therefore you have to save the weights somewhere. The full code can be found here.
Adding dynammically layers and neurons
The full code can be found here.
Review
My neuronal network can be optimzied by using
More informations
- http://karpathy.github.io/neuralnets/
- http://neuralnetworksanddeeplearning.com
- https://www.youtube.com/watch?v=u4alGiomYP4 and https://codelabs.developers.google.com/codelabs/cloud-tensorflow-mnist/


How to use¶
To use Eclip, it is simpest to run the training function (RunTrain), and then the predicting function (RunPred). However, each function making up these can also be run independantly. This allows for more flexibility in the arguments.
The programs are run by calling the functions in the command line.
Examples of how to use¶
How to call:¶
RunPred --input=/INPUT-IMAGE-DIRECTORY/ --output=/OUTPUT-IMAGE-DIRECTORY
Available Functions:¶
The functions able to be called are as follows:
RunTrain¶
RunTrain is the module that produces a trained model, using input maps. Find the documentation for this module here.
RunPred¶
RunPred is the module that produces a score using a pretrained model. Find the documentation for this module here.
ConvMAP¶
ConvMAP is the module that converts maps to images. Find the documentation for this module here.
EP_success¶
EP_success is the module that updates the SQLite database with scores for the training data, and links to the image directories. Find the documentation for this module here.
EP_add_new¶
EP_add_new is the module that updates the SQLite database with the pdb_ids of the new data and links to the image directories. Find the documentation for this module here.


Scientific visualization is a powerful method to display the results of computer simulations and/or experimental measurements. The functionality of the Application Visualization System (AVS) from Advanced Visual Systems, Inc. modules have been ported to the Immersadesk© environment from Pyramid Systems, Inc.
There are two applications, one called IMolecule for the display of the geometric structure of molecules and the other is IMD for the display of the results of molecular dynamics simulations.
The IMolecule application code is designed to read geometric structure information of a molecule from a variety of file formats. For more information see the SC97 presentation.
For these displays, the visualization process begins by reading the structural information and other output data from the calculation. The data is currently displayed using traditional ball and stick models. The size of the atom is determined from the van der Waals radii, and one can input coordinates in either Bohrs or Angstroms.
To run type:
IMolecule filename filetype units
Navigation throughout the molecule is accomplished by:
The program currently can read structural information from the following types of files:
The IMD application code is designed to read the results of a molecular dynamics (MD) simulation of spherically symmetric, electrically neutral atom system interacting via a Lennard-Jones potential. The atoms are displayed as spheres, colored by the magnitude of the velocity. (Red being the fastest and blue being the slowest). For more information see the SC97 presentation.
The executable file is CaveDyn0, which is set to
read the file mdvis.dat.kenf_N64
1000 time steps 64
particles. The source file is CaveDyn0.c for the
the CaveDyn0 executable and lastly, a Makefile to make the
executable, make cave0 to make the
CaveDyn0 executable.


Input-Output iolib
¶
statsmodels
offers some functions for input and output. These include a
reader for STATA files, a class for generating tables for printing in several
formats and two helper functions for pickling.
Users can also leverage the powerful input/output functions provided by pandas.io. Among other things, pandas
(a statsmodels
dependency) allows reading and writing to Excel, CSV, and HDF5 (PyTables).
Examples¶
Module Reference¶
|
Stata .dta file reader. |
|
A class for writing Stata binary dta files from array-like objects |
|
Returns an ndarray or DataFrame from a Stata .dta file. |
|
Save an array to a text file. |
|
Produce a simple ASCII, CSV, HTML, or LaTeX table from a rectangular (2d!) array of data, not necessarily numerical. |
|
Return SimpleTable instance, created from the data in csvfile, which is in comma separated values format. |
|
Save the object to file via pickling. |
|
Load a previously saved object |
The following are classes and functions used to return the summary of estimation results, and mostly intended for internal use. There are currently two versions for creating summaries.
Result summary |
|
Methods |


The are two principal paths to take when registering a new type, either the type is a reference type that is located in dynamic memory, or the type is a value type that is located on the stack. Complex types are usually registered as reference types, while simple types that are meant to be used as primitives are registered as value types. A reference type support object handles (unless restricted by application), but cannot be passed by value to application registered functions, a value type doesn't support handles and can be passed by value to application registered functions.
The basic reference type should be registered with the following behaviours: asBEHAVE_FACTORY, asBEHAVE_ADDREF, and asBEHAVE_RELEASE. If it is desired that assignments should be allowed for the type the asBEHAVE_ASSIGNMENT behaviour must be registered as well. Other behaviours, such as math operators, comparisons, etc may be registered as needed.
// Registering the reference type r = engine->RegisterObjectType("ref", 0, asOBJ_REF); assert( r >= 0 );
The factory function is the one that AngelScript will use to instanciate objects of this type when a variable is declared. It is responsible for allocating and initializing the object memory.
The default factory function doesn't take any parameters and should return an object handle for the new object. Make sure the object's reference counter is accounting for the reference being returned by the factory function, so that the object is properly released when all references to it are removed.
CRef::CRef() { // Let the constructor initialize the reference counter to 1 refCount = 1; } CRef *Ref_Factory() { // The class constructor is initializing the reference counter to 1 return new CRef(); } // Registering the factory behaviour r = engine->RegisterObjectBehaviour("ref", asBEHAVE_FACTORY, "ref@ f()", asFUNCTION(Ref_Factory), asCALL_CDECL); assert( r >= 0 );
You may also register factory functions that take parameters, which may then be used when initializing the object.
The factory function must be registered as a global function, but can be implemented as a static class method, common global function, or a global function following the generic calling convention.
void CRef::Addref() { // Increase the reference counter refCount++; } void CRef::Release() { // Decrease ref count and delete if it reaches 0 if( --refCount == 0 ) delete this; } // Registering the addref/release behaviours r = engine->RegisterObjectBehaviour("ref", asBEHAVE_ADDREF, "void f()", asMETHOD(CRef,AddRef), asCALL_THISCALL); assert( r >= 0 ); r = engine->RegisterObjectBehaviour("ref", asBEHAVE_RELEASE, "void f()", asMETHOD(CRef,Release), asCALL_THISCALL); assert( r >= 0 );
CRef &CRef::operator =(const CRef &other) { // Copy everything from the other class, except the reference counter } // Registering the assignment behaviour r = engine->RegisterObjectBehaviour("ref", asBEHAVE_ASSIGNMENT, "ref &f(const &in)", asMETHOD(CRef,operator=), asCALL_THISCALL); assert( r >= 0 );
The assignment behaviour can be overloaded with other types if that is desired, that way the script writer doesn't have to manually convert the expressions before assigning the values to the type.
Reference counting as memory management has a drawback in that it is difficult to detect circular references when determining dead objects. AngelScript allows the application to register types with special behaviours to support the garbage collection for detecting circular references. These behaviours make the class a bit more complex, but you should only have to register them for a few types, e.g. generic container classes.
// Registering the garbage collected reference type r = engine->RegisterObjectType("ref", 0, asOBJ_REF | asOBJ_GC); assert( r >= 0 );
The difference between the garbage collected and non-garbage collected types is in the addref and release behaviours, the class constructor, and the extra support behaviours.
The GC determines when objects should be destroyed by counting the references it can follow for each object. If the GC can see all references that points to an object, it knows that the object is part of a circular reference. If all the objects involved in that circular reference have no outside references it means that they should be destroyed.
The process of determining the dead objects uses the first for of the behaviours below, while the destruction of the objects is done by forcing the release of the object's references.
void CGCRef::SetGCFlag() { // Set the gc flag as the high bit in the reference counter refCount |= 0x80000000; } bool CGCRef::GetGCFlag() { // Return the gc flag return (refCount & 0x80000000) ? true : false; } int CGCRef::GetRefCount() { // Return the reference count, without the gc flag return (refCount & 0x7FFFFFFF); } void CGCRef::EnumReferences() { // Call the engine::GCEnumCallback for all references to other objects held engine->GCEnumCallback(myref); } void CGCRef::ReleaseAllReferences() { // When we receive this call, we are as good as dead, but // the garbage collector will still hold a references to us, so we // cannot just delete ourself yet.  The easiest way of doing that is to have the factory behaviour, or the class constructor call the NotifyGarbageCollectorOfNewObject() method on the engine when initializing the class.
CGCRef *GCRef_Factory() { // Create the object and then notify the GC of its existence CGCRef *obj = new CGCRef(); int typeId = engine->GetTypeIdByDecl("gc"); engine->NotifyGarbageCollectorOfNewObject(obj, typeId); return obj; }
You may want to consider caching the typeId, so that it doesn't have to be looked up through the relatively expensive call to GetTypeIdByDecl every time an object of this type is created.
Note, if you create objects of this type from the application side, you must also notify the garbage collector of its existence, so it's a good idea to make sure all code use the same way of creating objects of this type.
For garbage collected objects it is important to make sure the AddRef and Release behaviours clear the GC flag. Otherwise it is possible that the GC incorrectly determine that the object should be destroyed.
void CGCRef::AddRef() { // Clear the gc flag and increase the reference counter refCount = (refCount&0x7FFFFFFF) + 1; } void CGCRef::Release() { // Clear the gc flag, decrease ref count and delete if it reaches 0 refCount &= 0x7FFFFFFF; if( --refCount == 0 ) delete this; } // Registering the addref/release behaviours r = engine->RegisterObjectBehaviour("gc", asBEHAVE_ADDREF, "void f()", asMETHOD(CGCRef,AddRef), asCALL_THISCALL); assert( r >= 0 ); r = engine->RegisterObjectBehaviour("gc", asBEHAVE_RELEASE, "void f()", asMETHOD(CGCRef,Release), asCALL_THISCALL); assert( r >= 0 );
Sometimes it may be useful to register types that cannot be instanciated by the scripts, yet can be interacted with. You can do this by registering the type as a normal reference type, but omit the registration of the factory behaviour. You can later register global properties, or functions that allow the scripts to access objects created by the application via object handles.
This would be used when the application has a limited number of objects available and doesn't want to create new ones. For example singletons, or pooled objects.
A variant of the uninstanciable reference types is the single-reference type. This is a type that have only 1 reference accessing it, i.e. the script cannot store any extra references to the object during execution. The script is forced to use the reference it receives from the application at the moment the application passes it on to the script.
The reference can be passed to the script through a property, either global or a class member, or it can be returned from an application registered function or class method.
// Registering the type so that it cannot be instanciated // by the script, nor allow scripts to store references to the type r = engine->RegisterObjectType("single", 0, asOBJ_REF | asOBJ_NOHANDLE); assert( r >= 0 );
This sort of type is most useful when you want to have complete control over references to an object, for example so that the application can destroy and recreate objects of the type without having to worry about potential references held by scripts. This allows the application to control when a script has access to an object and it's members.
Some C++ value types have special requirements for the memory where they are located, e.g. specific alignment needs, or memory pooling. Since AngelScript doesn't provide that much control over where and how value types are allocated, they must be registered as reference types. In this case you'd register the type as a scoped reference type.
A scoped reference type will have the life time controlled by the scope of the variable that instanciate it, i.e. as soon as the variable goes out of scope the instance is destroyed. This means that the type doesn't permit handles to be taken for the type.
A scoped reference type requires two behaviours to be registered, the factory and the release behaviour. The addref behaviour is not permitted.
Since no handles can be taken for the object type, there is no need to keep track of the number of references held to the object. This means that the release behaviour should simply destroy and deallocate the object as soon as it's called.
scoped *Scoped_Factory() { return new scoped; } void Scoped_Release(scoped *s) { if( s ) delete s; } // Registering a scoped reference type r = engine->RegisterObjectType("scoped", 0, asOBJ_REF | asOBJ_SCOPED); assert( r >= 0 ); r = engine->RegisterObjectBehaviour("scoped", asBEHAVE_FACTORY, "scoped @f()", asFUNCTION(Scoped_Factory), asCALL_CDECL); assert( r >= 0 ); r = engine->RegisterObjectBehaviour("scoped", asBEHAVE_RELEASE, "void f()", asFUNCTION(Scoped_Release), asCALL_CDECL_OBJLAST); assert( r >= 0 );
When registering a value type, the size of the type must be given so that AngelScript knows how much space is needed for it. If the type doesn't require any special treatment, i.e. doesn't contain any pointers or other resource references that must be maintained, then the type can be registered with the flag asOBJ_POD. In this case AngelScript doesn't require the default constructor, assignment behaviour, or destructor as it will be able to automatically handle these cases the same way it handles built-in primitives.
If the type will be passed to and from the application by value using native calling conventions, it is important to inform AngelScript of its real type in C++, otherwise AngelScript won't be able to determine exactly how C++ is treating the type in a parameter or return value. There are a few different flags for this:
| asOBJ_APP_CLASS | The C++ type is a class, struct, or union |
| asOBJ_APP_CLASS_CONSTRUCTOR | The C++ type has a defined constructor |
| asOBJ_APP_CLASS_DESTRUCTOR | The C++ type has a defined destructor |
| asOBJ_APP_CLASS_ASSIGNMENT | The C++ type has a defined assignment operator |
| asOBJ_APP_PRIMITIVE | The C++ type is a C++ primitive, but not a float or double |
| asOBJ_APP_FLOAT | The C++ type is a float or double |
// Register a primitive type, that doesn't need any special management of the content r = engine->RegisterObjectType("pod", sizeof(pod), asOBJ_VALUE | asOBJ_POD | asOBJ_APP_PRIMITIVE); assert( r >= 0 ); // Register a class that must be properly initialized and uninitialized r = engine->RegisterObjectType("val", sizeof(val), asOBJ_VALUE | asOBJ_APP_CLASS_CDA); assert( r >= 0 );
If a constructor or destructor is needed they shall be registered the following way:
void Constructor(void *memory) { // Initialize the pre-allocated memory by calling the // object constructor with the placement-new operator new(memory) Object(); } void Destructor(void *memory) { // Uninitialize the memory by calling the object destructor ((Object*)memory)->~Object(); } // Register the behaviours r = engine->RegisterObjectBehaviour("val", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(Constructor), asCALL_CDECL_OBJLAST); assert( r >= 0 ); r = engine->RegisterObjectBehaviour("val", asBEHAVE_DESTRUCT, "void f()", asFUNCTION(Destructor), asCALL_CDECL_OBJLAST); assert( r >= 0 );
The assignment behaviour is registered the same way as for reference types.
You can register operator behaviours for your types as well. By doing this you'll allow the script to work with the types in expressions, just like the built-in types.
There two forms of operator behaviours, either object behaviours or global behaviours. An object behaviour is implemented as a class method, and a global behaviour is implemented as a global function.
// Registering an object behaviour int &MyClass::operator[] (int index) { return internal_array[index]; } r = engine->RegisterObjectBehaviour("mytype", asBEHAVE_INDEX, "int &f(int)", asMETHOD(MyClass,operator[]), asCALL_THISCALL); assert( r >= 0 ); // Registering a global behaviour MyClass operator+(const MyClass &a, const MyClass &b) { MyClass res = a + b; return res; } r = engine->RegisterGlobalBehaviour(asBEHAVE_ADD, "mytype f(const mytype &in, const mytype &in)", asFUNCTIONPR(operator+, (const MyClass &, const MyClass &), MyClass), asCALL_CDECL); assert( r >= 0 );
You can find a complete list of behaviours here.
Class methods are registered with the RegisterObjectMethod call.
// Register a class method void MyClass::ClassMethod() { // Do something } r = engine->RegisterObjectMethod("mytype", "void ClassMethod()", asMETHOD(MyClass,ClassMethod), asCALL_THISCALL); assert( r >= 0 );
It is also possible to register a global function that takes a pointer to the object as a class method. This can be used to extend the functionality of a class when accessed via AngelScript, without actually changing the C++ implementation of the class.
// Register a global function as an object method void MyClass_MethodWrapper(MyClass *obj) { // Access the object obj->DoSomething(); } r = engine->RegisterObjectMethod("mytype", "void MethodWrapper()", asFUNCTION(MyClass_MethodWrapper), asCALL_CDECL_OBJLAST); assert( r >= 0 );
Class member variables can be registered so that they can be directly accessed by the script without the need for any method calls.
struct MyStruct { int a; }; r = engine->RegisterObjectProperty("mytype", "int a", offsetof(MyStruct,a)); assert( r >= 0 );
offsetof() is a macro declared in stddef.h header file.


# Angular 101
### Scalable front end development
Presented by [Chris Schmitz](http://chris-schmitz.com) / [@ccschmitz](http://twitter.com/ccschmitz)
Who is Chris?
- Husband and co-founder of the world's cutest 8-month-old boy.
- Lead front end developer at CCI Systems
- Co-Founder of DevTrain
- Lead Organizer of Startup Weekend Green Bay
- Board Member at Digital Fertilizer
What is Angular?
HTML enhanced for web apps!
Why should I care?
- Prevents the need for writing boilerplate code.
- Provides structure and a consistency, a unified approach.
- Makes testing a lot easier.
Alright, I'm sold! So...
How do I use it?
## Core Concepts
* A **template** is any HTML with additional Angular markup in it.
* A **compiler** parses templates and instantiates directives and expressions.
* A **view** is the loaded, transformed and rendered DOM.
## A Basic App
[Demo](http://plnkr.co/edit/ErGDbFcYPdrM8XPsky0J?p=info)
## Controllers
[Demo](http://plnkr.co/edit/IuHrsURzRTVMuS0DXKZw?p=info)
## Services
[Demo](http://plnkr.co/edit/ZiQzKlUrSJ2kwgenLxpP?p=info)
What else can it do?
- Custom Directives
- Routing
- Testing


Go back
Glossary
- Bar chart
-
A bar chart graphically represents categories as bars that are sized according to the value of its associated measure.
Read more about bar charts in wikipedia.
- Catalog
-
A catalog is a collection of cubes. Usually, the cubes in a catalog are related in terms of content or target audience.
- Hierarchy
-
A hierarchy is a collection of categorical values, ordered by aggregation level.
For example, time is hierarchically ordered into levels of year, quarter, month, and so on.
Read more about hierarchies in wikipedia.
- Level
-
A level of aggregation within a hierarchy.
- Cube
-
A data structure suitable for quick analysis of business process data.
Read more about cubes in wikipedia.
- Member
-
A member is a single categorical value within a level of a hierarchy.
For example, "2015" is a member of the year level within a time hierarchy.
- Measure
-
Measures (also known as facts) are quantitative data describing a business process.
For example, a sales process typically as sale quantity and sale price as measures.
Read more about measures in wikipedia.
- OLAP
-
OLAP is an abbreviation of Online Analytical Processing.
OLAP is mostly used for quickly analysing and reporting business process data on an ad-hoc basis .
Read more about OLAP in wikipedia.
- Pie chart
-
A pie chart graphically represents categories of one series of measures as sectors ("slice") of a circle.
Read more about pie charts in wikipedia.
- Pivot table
-
A pivot table (also known as crosstab) is a kind of table in which both column and row headers represent a group of data.
At the intersection of the column and row headers are cells containing an aggregated value calculated from the underlying measuresa>.
Read more about pivot tables in wikipedia.
- Property
-
Properties are additional data items or fields that are typically defined for levels.
The actual values of the properties are available for the members that belong to the level.
For example, a product level in a product hierarchy can hold useful bits of information like the product price.
Properties can also be used to store alternative or additional labels for the member, for example, an abbreviated caption or a longer description text.
- Tabel
-
A means of organizing data in a collection of rows having a fixed column structure.
Read more about tables in wikipedia.


Space Age
Input your age to see what age you are on different planets!
About You:
Name
Age
Gender
Other
Female
Male
Your Space Age:
Pick a Planet:
Mercury
Venus
Mars
Jupiter
Show my age in space years!


--- title: Tangoimperial.cz date: 2009-01-19 14:02:42.000000000 +02:00 categories: - dance - travelling tags: - dance - milonga - photos - prague - tango status: publish type: post published: true meta: _edit_last: '600927' reddit: a:2:{s:5:"count";s:1:"0";s:4:"time";s:10:"1245171638";} delicious: a:3:{s:5:"count";s:1:"0";s:9:"post_tags";s:0:"";s:4:"time";s:10:"1245171638";} author: login: kouk email<EMAIL_ADDRESS>display_name: Konstantinos Koukopoulos first_name: '' last_name: '' excerpt: !ruby/object:Hpricot::Doc options: {} ---
Back in autumn 2008 I visited Prague to attend a workshop. Beautiful city.
In Prague, my friend and colleague Giannis and I visited a nice milonga called Tangoimperial. Giannis took some nice pictures and the organizers were interested in posting them on their website, here. Following are some of the photos I appear in:
And one I took myself with Giannis' camera :-)
If you're interested check out Giannis' Prague photo set.


Copyright © 2013 W3C® (MIT, ERCIM, Keio, Beihang), All Rights Reserved. W3C liability, trademark and document use rules apply.
CSS is a language for describing the rendering of structured documents
(such as HTML and XML) on screen, on paper, in speech, etc. This module contains the features of CSS for conditional
processing of parts of style sheets, conditioned on capabilities of the
processor or the document the style sheet is being applied to. It includes
and extends the functionality of CSS level 2 [CSS21], which builds on CSS level 1
[CSS1]. The main
extensions compared to level 2 are allowing nesting of certain at-rules
inside ‘@media
’, and the addition of the
‘@supports
’ rule for conditional processing.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This document was produced by the CSS Working Group as a Candidate Recommendation.
A Candidate Recommendation is a document that has been widely reviewed and is ready for implementation. W3C encourages everybody to implement this specification and return comments to the (archived) public mailing list<EMAIL_ADDRESS>(see instructions). When sending e-mail, please put the text “css3-conditional” in the subject, preferably like this: “[css3-conditional] …summary of comment…”
Publication as a Candidate Recommendation does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.
See the section “CR Exit Criteria” for details on advancing this specification to W3C Recommendation. The specification will remain Candidate Recommendation at least until 2 October 2013. A test suite and implementation report are under development.
See the section “Changes” for changes since the last Working Draft.
The following features are at risk:
@font-face
’ rules and
‘@keyframes
’ rules as allowed within all of
the @-rules in this specification is at risk, though only because of the
relative rates of advancement of specifications. If this specification is
able to advance faster than one or both of the specifications defining
those rules, then the inclusion of those rules will move from this
specification to the specification defining those rules.
@supports
’ rule is at risk; if
interoperable implementations are not found, it may be removed to advance
the other features in this specification to Proposed Recommendation.
@media
’ rule
@supports
’ rule
This section is not normative.
[CSS21] defines
one type of conditional group rule, the ‘@media
’ rule, and allows only rulesets (not other
@-rules) inside of it. The ‘@media
’ rule
provides the ability to have media-specific style sheets, which is also
provided by style sheet linking features such as ‘@import
’ and <link>
. The
restrictions on the contents of ‘@media
’ rules
made them less useful; they have forced authors using CSS features
involving @-rules in media-specific style sheets to use separate style
sheets for each medium.
This specification extends the rules for the contents of conditional group rules to allow other @-rules, which enables authors to combine CSS features involving @-rules with media specific style sheets within a single style sheet.
This specification also defines an additional type of conditional group
rule, ‘@supports
’, to address author and user
requirements.
The ‘@supports
’ rule allows CSS to be
conditioned on implementation support for CSS properties and values. This
rule makes it much easier for authors to use new CSS features and provide
good fallback for implementations that do not support those features. This
is particularly important for CSS features that provide new layout
mechanisms, and for other cases where a set of related styles needs to be
conditioned on property support.
This module replaces and extends the ‘@media
’
rule feature defined in [CSS21] section 7.2.1 and
incorporates the modifications previously made non-normatively by [MEDIAQ] section
1.
Its current definition depends on @-rules defined in [CSS3-FONTS] and [CSS3-ANIMATIONS], but that dependency is only on the assumption that those modules will advance ahead of this one. If this module advances faster, then the dependency will be reversed.
Conformance requirements are expressed with a combination of descriptive assertions and RFC 2119 terminology. The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in the normative parts of this document are to be interpreted as described in RFC 2119. However, for readability, these words do not appear in all uppercase letters in this specification.
All of the text of this specification is normative except sections explicitly marked as non-normative, examples, and notes. [RFC2119]
Examples in this specification are introduced with the words “for
example” or are set apart from the normative text with class="example"
, like this:
This is an example of an informative example.
Informative notes begin with the word “Note” and are set apart from
the normative text with class="note"
, like this:
Note, this is an informative note.
This specification defines some CSS @-rules, called conditional group rules, that associate a condition with a group of other CSS rules. These different rules allow testing different types of conditions, but share common behavior for how their contents are used when the condition is true and when the condition is false.
For example, this rule:
@media print { /* hide navigation controls when printing */ #navigation { display: none } }
causes a particular CSS rule (making elements with ID "navigation" be display:none) apply only when the style sheet is used for a print medium.
Each conditional group rule has a condition, which at any time evaluates to true or false. When the condition is true, CSS processors must apply the rules inside the group rule as though they were at the group rule's location; when the condition is false, CSS processors must not apply any of rules inside the group rule. The current state of the condition does not affect the CSS object model, in which the contents of the group rule always remain within the group rule.
This means that when multiple conditional group rules are nested, a rule inside of both of them applies only when all of the rules' conditions are true.
@media print { // rule (1) /* hide navigation controls when printing */ #navigation { display: none } @media (max-width: 12cm) { // rule (2) /* keep notes in flow when printing to narrow pages */ .note { float: none } } }the condition of the rule marked (1) is true for print media, and the condition of the rule marked (2) is true when the width of the display area (which for print media is the page box) is less than or equal to 12cm. Thus the rule ‘
#navigation { display: none
}
’ applies whenever this style sheet is applied to print media,
and the rule ‘.note { float: none }
’ is applied
only when the style sheet is applied to print media and the width
of the page box is less than or equal to 12 centimeters.When the condition for a conditional group rule changes, CSS processors must reflect that the rules now apply or no longer apply, except for properties whose definitions define effects of computed values that persist past the lifetime of that value (such as for some properties in [CSS3-TRANSITIONS] and [CSS3-ANIMATIONS]).
The syntax of each conditional group rule consists of some syntax specific to the type of rule followed by a group rule body, which is a block (pair of braces) containing a sequence of rules.
A group rule body is allowed to contain rulesets and any @-rules that
are allowed at the top level of a style sheet before and after a ruleset.
This means that @-rules that must occur at the beginning of the style
sheet (such as ‘@charset
’, ‘@import
’, and ‘@namespace
’
rules) are not allowed inside of conditional group rules. Conditional
group rules can be nested.
In terms of the grammar, this specification defines the following productions for use in the grammar of conditional group rules:
nested_statement : ruleset | media | page | font_face_rule | keyframes_rule | supports_rule ; group_rule_body : '{' S* nested_statement* '}' S* ;
in which all the productions are defined in that grammar with the
exception of font_face_rule
defined in [CSS3-FONTS],
keyframes_rule
defined in [CSS3-ANIMATIONS], and media
and supports_rule
defined in this
specification.
In general, future CSS specifications that add new @-rules that are not
forbidden to occur after some other types of rules should modify this nested_statement
production to
keep the grammar accurate.
Style sheets must not use rules other than the allowed ones inside conditional group rules.
CSS processors must ignore rules that are not allowed within a group rule, and must handle invalid rules inside of group rules as described in section 4.2 (Rules for handling parsing errors), section 4.1.5 (At-rules), and section 4.1.7 (Rule sets, declaration blocks, and selectors) of [CSS21].
Conditional group rules are allowed at the top-level of a style sheet, and inside other conditional group rules. CSS processors must process such rules as described above.
Any rules that are not allowed after a ruleset (e.g., ‘@charset
’, ‘@import
’, or
‘@namespace
’ rules) are also not allowed after
a conditional group rule.  It consists
of the at-keyword ‘@media
’ followed by a
(possibly empty) media query list (as defined in [MEDIAQ]), followed by a group rule
body. The condition of the rule is the result of the media query.
This ‘@media
’ rule:
@media screen and (min-width: 35em), print and (min-width: 40em) { #section_navigation { float: left; width: 10em; } }
has the condition ‘screen and (min-width: 35em),
print and (min-width: 40em)
’, which is true for screen displays
whose viewport is at least 35 times the initial font size and for print
displays whose viewport is at least 40 times the initial font size. When
either of these is true, the condition of the rule is true, and the rule
‘#section_navigation { float: left; width: 10em;
}
’ is applied.
In terms of the grammar, this specification extends the media
production in the Grammar of CSS 2.1 ([CSS21], Appendix G)
into:
media : MEDIA_SYM S* media_query_list group_rule_body ;
where the group_rule_body
production is defined in this specification, the
media_query_list
production is defined in [MEDIAQ], and the others are defined
in the Grammar of CSS
2.1 ([CSS21],
Appendix G).
@supports
’ ruleThe ‘@supports
’
rule is a conditional group rule whose condition tests whether the
user agent supports CSS property:value pairs. Authors can use it to write
style sheets that use new features when available but degrade gracefully
when those features are not supported. CSS has existing mechanisms for
graceful degradation, such as ignoring unsupported properties or values,
but these are not always sufficient when large groups of styles need to be
tied to the support for certain features, as is the case for use of new
layout system features.
The syntax of the condition in the ‘@supports
’ rule is slightly more complicated than for
the other conditional group rules (though has some similarities to media
queries) since:
Therefore, the syntax of the ‘@supports
’ rule
allows testing for property:value pairs, and arbitrary conjunctions (and),
disjunctions (or), and negations (not) of them.
This extends the lexical scanner in the Grammar of CSS 2.1 ([CSS21], Appendix G) by adding:
@{S}{U}{P}{P}{O}{R}{T}{S} {return SUPPORTS_SYM;} {O}{R} {return OR;}
This then extends the grammar in the Grammar of CSS 2.1,
using the lexical scanner there, with the additions of AND
and
NOT
tokens defined in the Media Queries specification [MEDIAQ] and the OR
and SUPPORTS_SYM
tokens defined above,
and with declaration
,
any
,
and unused
productions and the FUNCTION
token taken from the core syntax of CSS defined in section 4.1.1
(Tokenization) of [CSS21], by adding:
supports_rule : SUPPORTS_SYM S* supports_condition S* group_rule_body ; supports_condition : supports_negation | supports_conjunction | supports_disjunction | supports_condition_in_parens ; supports_condition_in_parens : ( '(' S* supports_condition S* ')' ) | supports_declaration_condition | general_enclosed ; supports_negation : NOT S+ supports_condition_in_parens ; supports_conjunction : supports_condition_in_parens ( S+ AND S+ supports_condition_in_parens )+ ; supports_disjunction : supports_condition_in_parens ( S+ OR S+ supports_condition_in_parens )+ ; supports_declaration_condition : '(' S* declaration ')' ; general_enclosed : ( FUNCTION | '(' ) ( any | unused )* ')' ;
Implementations must parse ‘@supports
’ rules based on the above grammar, and when
interpreting the above grammar, must match the production
before an |
operator in preference to the one after it.
The above grammar is purposely very loose for forwards-compatibility
reasons, since the general_enclosed
production
allows for substantial future extensibility. Any ‘@supports
’ rule that does not parse according to the
grammar above (that is, a rule that does not match this loose grammar
which includes the general_enclosed
production) is
invalid. Style sheets must not use such a rule and
processors must ignore such a rule (including all of its
contents).
 (In other words, this production exists
only for future extensibility, and is not part of the description of a
valid style sheet in this level of the specification.) Note that future levels may define functions or other
parenthesized expressions that can evaluate to true.
The condition of the ‘@supports
’ rule is the
result of the supports_condition
term that
is a child of the supports_rule
term.
For example, the following rule
@supports ( display: flexbox ) { body, #navigation, #content { display: flexbox; } #navigation { background: blue; color: white; } #article { background: white; color: black; } }
applies the rules inside the ‘@supports
’
rule only when ‘display: flexbox
’ is
supported.
The following example shows an additional ‘@supports
’ rule that can be used to provide an
alternative for when ‘display: flexbox
’ is not
supported:
@supports not ( display: flexbox ) { body { width: 100%; height: 100%; background: white; color: black; } #navigation { width: 25%; } #article { width: 75%; } }
Note that the ‘width
’ declarations may
be harmful to the flexbox-based layout, so it is important that they be
present only in the non-flexbox styles.
The following example checks for support for the ‘box-shadow
’ property, including checking for
support for vendor-prefixed versions of it. When the support is present,
it specifies both ‘box-shadow
’ (with the
prefixed versions) and ‘color
’ in a way
what would cause the text to become invisible were ‘box-shadow
’ not supported.
@supports ( box-shadow: 2px 2px 2px black ) or ( -moz-box-shadow: 2px 2px 2px black ) or ( -webkit-box-shadow: 2px 2px 2px black ) or ( -o-box-shadow: 2px 2px 2px black ) { .outline { color: white; -moz-box-shadow: 2px 2px 2px black; -webkit-box-shadow: 2px 2px 2px black; -o-box-shadow: 2px 2px 2px black; box-shadow: 2px 2px 2px black; /* unprefixed last */ } }
To avoid confusion between ‘and
’ and ‘or
’, the syntax requires that both
‘and
’ and ‘or
’ be specified explicitly (rather than, say,
using commas or spaces for one of them). Likewise, to avoid confusion
caused by precedence rules, the syntax does not allow ‘and
’, ‘or
’, and ‘not
’ operators
to be mixed without a layer of parentheses.
For example, the following rule is not valid:
@supports (transition-property: color) or (animation-name: foo) and (transform: rotate(10deg)) { // ... }
Instead, authors must write one of the following:
@supports ((transition-property: color) or (animation-name: foo)) and (transform: rotate(10deg)) { // ... }
@supports (transition-property: color) or ((animation-name: foo) and (transform: rotate(10deg))) { // ... }
Furthermore, whitespace is required after a ‘not
’ and on both sides of an ‘and
’ or ‘or
’.
The declaration being tested must always occur within parentheses, when it is the only thing in the expression.
For example, the following rule is not valid:
@supports display: flexbox { // ... }
Instead, authors must write:
@supports (display: flexbox) { // ... }
The syntax allows extra parentheses when they are not needed. This flexibility is sometimes useful for authors (for example, when commenting out parts of an expression) and may also be useful for authoring tools.
For example, authors may write:
@supports ((display: flexbox)) { // ... }
A trailing ‘!important
’ on a declaration
being tested is allowed, though it won't change the validity of the
declaration.
For example, the following rule is valid:
@supports (display: flexbox !important) { // ... }
For forward-compatibility, section 4.1.8 (Declarations and properties) of [CSS21] defines rules for handling invalid properties and values. CSS processors that do not implement or partially implement a specification must treat any part of a value that they do not implement, or do not have a usable level of support for, as invalid according to this rule for handling invalid properties and values, and therefore must discard the declaration as a parse error.
A CSS processor is considered to support a declaration (consisting of a property and value) if it accepts that declaration (rather than discarding it as a parse error). If a processor does not implement, with a usable level of support, the value given, then it must not accept the declaration or claim support for it.
Note that properties or values whose support is effectively
disabled by user preferences are still considered as supported by this
definition. For example, if a user has enabled a high-contrast mode that
causes colors to be overridden, the CSS processor is still considered to
support the ‘color
’ property even though
declarations of the ‘color
’ property may
have no effect. On the other hand, a developer-facing preference whose
purpose is to enable or disable support for an experimental CSS feature
does affect this definition of support.
These rules (and the equivalence between them) allow authors to use
fallback (either in the [CSS1] sense of declarations that are
overridden by later declarations or with the new capabilities provided by
the ‘@supports
’ rule in this specification)
that works correctly for the features implemented. This applies especially
to compound values; implementations must implement all parts of the value
in order to consider the declaration supported, either inside a ruleset or
in the declaration condition of an ‘@supports
’
rule.
CSSRule
interfaceThe CSSRule
interface is extended as follows:
partial interface CSSRule { const unsigned short SUPPORTS_RULE = 12; }
CSSGroupingRule
interfaceThe CSSGroupingRule
interface
represents an at-rule that contains other rules nested inside itself.
interface CSSGroupingRule : CSSRule { readonly attribute CSSRuleList cssRules; unsigned long insertRule (DOMString rule, unsigned long index); void deleteRule (unsigned long index); }
cssRules
of type CSSRuleList
,
readonly
cssRules
attribute must return a
CSSRuleList
object for the list of CSS rules nested inside
the grouping rule.
insertRule(DOMString rule, unsigned long index)
, returns
unsigned long
insertRule
operation must insert a CSS rule
rule into the CSS rule list returned by cssRules
,
such that the inserted rule will be at position index, and any
rules previously at index or higher will increase their index
by one. It must throw INDEX_SIZE_ERR if index is greater than
cssRules.length
. It must throw SYNTAX_ERR if the rule has a
syntax error and is unparseable; this does not include syntax errors
handled by error handling rules for constructs inside of the rule, but
this does include cases where the string given does not parse into a
single CSS rule (such as when the string is empty) or where there is
anything other than whitespace or comments after that single CSS rule. It
must throw HIERARCHY_REQUEST_ERR if the rule cannot be inserted at the
location specified, for example, if an ‘@import
’ rule is inserted inside a group rule.
The return value is the index parameter.
deleteRule (unsigned long index)
, return
void
deleteRule
operation must remove a CSS rule from the
CSS rule list returned by cssRules
at index. It
must throw INDEX_SIZE_ERR if index is greater than or equal to
cssRules.length
.
CSSConditionRule
interfaceThe CSSConditionRule
interface represents all the "conditional" at-rules, which consist of a
condition and a statement block.
interface CSSConditionRule : CSSGroupingRule { attribute DOMString conditionText; }
conditionText
of type DOMString
The conditionText
attribute represents the condition of
the rule. Since what this condition does varies between the derived
interfaces of CSSConditionRule
, those
derived interfaces may specify different behavior for this attribute
(see, for example, CSSMediaRule
below). In the absence of such rule-specific behavior, the following
rules apply:
The conditionText
attribute, on getting, must return the
result of serializing the associated condition.
On setting the conditionText
attribute these steps must
be run:
CSSMediaRule
interfaceThe CSSMediaRule
interface
represents a ‘@media
’ rule:
interface CSSMediaRule : CSSConditionRule { readonly attribute MediaList media; }
media
of type MediaList
,
readonly
media
attribute must return a
MediaList
object for the list of media queries specified
with the ‘@media
’ rule.
conditionText
of type DOMString
(CSSMediaRule-specific definition for attribute on CSSConditionRule)
conditionText
attribute (defined on the CSSConditionRule
parent rule),
on getting, must return the value of media.mediaText
on the
rule.
Setting the conditionText
attribute must set the
media.mediaText
attribute on the rule.
CSSSupportsRule
interfaceThe CSSSupportsRule
interface
represents a ‘@supports
’ rule.
interface CSSSupportsRule : CSSConditionRule { }
conditionText
of type DOMString
(CSSSupportsRule-specific definition for attribute on CSSConditionRule)
conditionText
attribute (defined on the CSSConditionRule
parent rule),
on getting, must return the condition that was specified, without any
logical simplifications, so that the returned condition will evaluate to
the same result as the specified condition in any conformant
implementation of this specification (including implementations that
implement future extensions allowed by the general_enclosed exensibility
mechanism in this specification). In other words, token stream
simplifications are allowed (such as reducing whitespace to a single
space or omitting it in cases where it is known to be optional), but
logical simplifications (such as removal of unneeded parentheses, or
simplification based on evaluating results) are not allowed.
CSS
interface, and the supports()
functionThe CSS
interface holds useful
CSS-related functions that do not belong elsewhere.
interface CSS { static boolean supports(DOMString property, DOMString value); static boolean supports(DOMString conditionText); }
supports(DOMString property, DOMString value)
, returns
boolean
supports(DOMString conditionText)
, returns
boolean
supports()
method is invoked with two
arguments property and value, it must return
true
if property is a literal match for the name
of a CSS property that the UA supports, and value would be
successfully parsed as a supported value for that property. (Literal
match means that no CSS escape processing is performed, and leading and
trailing whitespace are not stripped, so any leading whitespace, trailing
whitespace, or CSS escapes equivalent to the name of a property would
cause the method to return false
.) Otherwise, it must return
false
.
When invoked with a single conditionText argument, it must
return true
if conditionText, when parsed and
evaluated as a supports_condition
, would
return true. Otherwise, it must return false
.
In order to allow these new @-rules in CSS style sheets, this
specification modifies the stylesheet
production in the Appendix G grammar of
[CSS21] by replacing
the media
production defined in [CSS21] with the media
production defined in this one, and
additionally inserting | supports_rule
alongside
ruleset | media | page
.
This specification defines conformance in terms of base modules, which are modules that this specification builds on top of. The base modules of this module are:
All of the conformance requirements of all base modules are incorporated as conformance requirements of this module, except where overridden by this module.
Additionally, all conformance requirements related to validity of syntax in this module and all of its base modules are to be interpreted as though all syntax in all of those modules is valid.
For example, this means that grammar presented in modules other than [CSS21] must obey the requirements that [CSS21] defines for the parsing of properties, and that requirements for handling invalid syntax in [CSS21] do not treat syntax added by other modules as invalid.
Additionally, the set of valid syntax can be increased by the conformance of a style sheet or processor to additional modules; use of such syntax does not make a style sheet nonconformant and failure to treat such syntax as invalid does not make a processor nonconformant.
Conformance to the CSS Conditional Rules Module is defined for three conformance classes:
A style sheet is conformant to the CSS Conditional Rules Module if it meets all of the conformance requirements in the module that are described as requirements of style sheets.
A processor is conformant to the CSS Conditional Rules Module if it meets all applicable conformance requirements in the module that are described as requirements of processors. In general, all requirements are applicable to renderers. Requirements concerning a part of CSS not performed by a processor are not applicable, e.g., requirements related to rendering are not applicable to a validator. The inability of a processor to correctly render a document due to limitations of the device does not make it non-conformant. (For example, a renderer is not required to render color on a monochrome monitor.)
An authoring tool is conformant to the CSS Conditional Rules Module if it writes style sheets that conform to the module and (if it reads CSS) it is a conformant processor.
So that authors can exploit the forward-compatible parsing rules to assign fallback values, CSS renderers must treat as invalid (and ignore as appropriate) any at-rules, properties, property values, keywords, and other syntactic constructs for which they have no usable level of support. In particular, user agents must not selectively ignore unsupported component values and honor supported values in a single multi-value property declaration: if any value is considered invalid (as unsupported values must be), CSS requires that the entire declaration be ignored.
To avoid clashes with future CSS features, the CSS specifications reserve a prefixed syntax for proprietary property and value extensions to CSS. The CSS Working Group recommends that experimental implementations of features in CSS Working Drafts also use vendor-prefixed property or value names. This avoids any incompatibilities with future changes in the draft. Once a specification reaches the Candidate Recommendation stage, implementors should implement the non-prefixed syntax for any feature they consider to be correctly implemented according to spec.
For this specification to be advanced to Proposed Recommendation, there must be at least two independent, interoperable implementations of each feature. Each feature may be implemented by a different set of products, there is no requirement that all features be implemented by a single product. For the purposes of this criterion, we define the following terms:
The specification will remain Candidate Recommendation for at least six months.
The following (non-editorial) changes were made to this specification since the 13 December 2012 Working Draft:
and
’ and ‘or
’ and after ‘not
’.
Thanks to the ideas and feedback from Tab Atkins, Arthur Barstow, Ben Callahan, Tantek Çelik, Alex Danilo, Elika Etemad, Pascal Germroth, Björn Höhrmann, Paul Irish, Anne van Kesteren, Vitor Menezes, Alex Mogilevsky, Chris Moschini, James Nurthen, Simon Pieters, Florian Rivoal, Simon Sapin, Nicholas Shanks, Ben Ward, Zack Weinberg, Estelle Weyl, Boris Zbarsky, and all the rest of the www-style community.
CSS
, 7.6.
CSSConditionRule
, 7.3.
CSSGroupingRule
, 7.2.
CSSMediaRule
, 7.4.
CSSSupportsRule
, 7.5.
@media
’ rule, 5.
@supports
’ rule, 6.


You are registered for the DESC July 2021 virtual meeting!
{{data.first_name}}, we are looking forward to seeing you at our virtual meeting!
The
Participants tab on the confluence page links to a live participant list, where you can confirm your
registration.
And have a look at the
agenda page to check the program of our virtual meeting!
Your Logistics Organizing Committee (LOC)


Ian Harley: Consistency is the key for high-flying Wolves
Wolverhampton forwards coach Ian Harley has challenged his side to stay consistent in the battle for promotion.
by Liam KeenThe Midlands 2 West (North) side sit second in the league after defeating top four rivals Leek and Stafford in their last two games.
A try from Alex Bird and a conversion and penalty from Liam Holder were enough for Wolverhampton to battle back from 7-0 down to win 10-7 away at Leek.
“We looked at the fixture list and thought Leek and Stafford would be the two teams to beat,” Harley said.
“We’ve beat the other three teams in the top four now, two of them away, so we’re very pleased and very proud.
“Leek were probably the best defensive team I’ve seen at this level.
“Neither side had a sniff for most of the game, with 90 per cent of it being played between the two 22s.
“We expect it from teams at the top, it wasn’t going to be a high-scoring game.
“It was a case of who was going to blink first and take a chance.
“There were no wild celebrations at the end, which really pleased us as coaches, it shows maturity.
“There’s an enjoyment and determination about this group.
“The lads in the pack really stood up too – it’s not a small group, but not a big one either.
“Their average age is around 24 and they’re really standing up to the physical battles.
“Our line-out has massively improved too.”
Harley’s side now sit second in the division, equal on points with leaders Camp Hill and third-placed Leek.
But Wolverhampton hold a game in hand over their rivals and Harley has warned his team not to be complacent when they face struggling Tamworth on Saturday.
“The message is clear, there’s no point in beating the teams at the top and not beating the teams at the bottom of the table,” he added.
“It’s the same attitude that the lads have – Tamworth aren’t suddenly a bad team.
“We never came out and said that we were going for promotion, we said that we were targetting a win in every game.
“If you do that, you win promotion.
“It’s an unsaid message really, that’s what we’re aiming for in every game.
“Go out and enjoy some rugby and get some tries on the board.”


Sorry, you can not print this page. Only to view online.
Paella is wonderful any time of year and a robust Valenciana – with sausage, chicken and seafood – is especially welcome in the fall. This dish has been on our menu from the very start and remains one of our most popular. If you don't have a sofrito ready to go, then substitute with tomato paste. Once you master the basics of great saffron-infused paella the variations are endless.
Ingredients:
There are a few claims about who invented this delicious cake. I’ve heard David Bouley created it back in 1985. Legend also says Jean-Georges Vongerichten made the first molten cake. And if you ask Jacques Torres, this tasty treat has its origins in the chocolatiers of France. No matter its creator, I know you’ll enjoy this luscious, chocolatey dessert.
This slow cooked short rib ragout is a great weekend project. The time invested to make this dish is well worth it. One bite of the tender, melt-in-your-mouth short ribs will make you so happy you’ll want to make it every weekend. You can also pair this rich and hearty ragout with olive oil potato puree or parmesan polenta. Either way, this ragout is the perfect comfort food!


What domain to receive mail for
mydestination
You specify what domains this machine will deliver locally, instead of
forwarding to another machine. The default is to receive mail for the machine
itself.
Local machine: $myhostname, localhost.$mydomain
Whole Domain: $myhostname, localhost.$mydomain,
$mydomain
You can also specify the full path of a file, which will contain the names of
domains that this machine will deliver mail locally for.
Example: /etc/postfix/mydestination
Caution: in order to avoid mail delivery loops, you must list all
hostnames of the machine, including $myhostname, and
localhost.$mydomain. DO NOT LIST VIRTUAL DOMAINS HERE. LIST THEM IN
THE VIRTUAL FILE INSTEAD.


Welcome to my website! My name is Marissa Le Coz, and I'm an aspiring iOS developer. I graduated from Dartmouth College in June 2017 with a B.A. in Computer Science and will graduate with an M.S. in Computer Science also from Dartmouth in June 2018. I am currently seeking full-time iOS development positions in the Boston/Cambridge area for mid- to late- Summer 2018.
Employers: Please download my resume with the link below and contact me if you see a potential match! Other devs: Want to collaborate on a project? Please contact me!
NovenaNetwork is a social media app for praying novenas (a Catholic form of prayer) with others around the world! I taught myself iOS through this project, which I completed for my senior thesis in Computer Science at Dartmouth. Get NovenaNetwork on the App Store. And check out my written thesis.
Close ProjectCKTrends is a system for tracking your iOS app's CloudKit database. CKTrends consists of an iOS app for viewing your CloudKit trends, as well as an API on Github to integrate into the app whose trends you wish to track. I completed this project for a two-term independent study as part of my graduate coursework. The CKTrends app was ultimately not accepted by the App Store because it was determined that the CKTrends system essentially "scrapes" CloudKit, which is not permitted by the Apple Developer License Agreement. Building the app was still a great experience, and I enjoy using it for tracking NovenaNetwork's usage. Read my paper here.
Close ProjectPulSonify is an iPhone app / Apple Watch duo that allows you to make sounds to the tempo of your heartbeat. PulSonify uses Apple's HealthKit APIs to access the user's heartrate. This information is sent to the user's corresponding iPhone app, which determines the rate at which selected sounds are played. PulSonify allows the user to be an artist of sorts, with both conscious control (selecting sounds) and unconscious control (their heartbeat modulating the tempo) of the sounds produced by the PulSonify app. This project was completed for the Digital Signal Processing course I took at Dartmouth in Winter 2018 as part of my Master's coursework. I plan to continue to work on this project as time allows to get it App Store ready. View the project on Github.
Close Project


This is where you design your dream set list. Put all the songs that you want to learn here to keep yourself motivated!


Hello, my name is
Mattias
!
Under construction...
In the mean time
visit me @
linkedin.com/mattiasback
github.com/mattiasback


Hello ,
I am undergraduate computer science student.
I posted in the Forums before a while the following:
http://openenergymonitor.org/emon/node/10468
I am working step by step to configure the the emontx and the raspberry pi with the following plan:
get the hardware to work with emoncms.org> get the hardware to work with emoncms in localhost> use method 1 you answered to me in the forums to get some data in my website.
I attached to this post a document of my progress.
I am having problem in getting the hardware to work with emoncms in localhost
I am following the link followed to run in localhost
https://github.com/emoncms/emoncms/blob/master/docs/WindowsInstall.md
I am stocked in the point where I run the python script.
I am getting this error
the error says:
SerialException("could not open port %r: %r" % (self.portstr, ctypes.WinError()))
SerialException: could not open port 'COM3': WindowsError(2, 'The system cannot find the file specified.')
I hope you give me some help or tips to get the data in the localhost.
I would also be very very thankful for your if you instruct me how to get some data in files or databases other than emoncms.
I will be praying and waiting to read and get help from you.
Thanks in advance.
Regards,
Re: Problem in letting rapberry pi to send data to emoncms in localhost
Please note that I do not have a jeelink plugged into the usb port
Re: Problem in letting rapberry pi to send data to emoncms in localhost
There appears to be some confusion of softwares here, Your other thread says you do not want to use emoncms as you want to store the data in your own mySQL database, And "method 1" appears to be writing your own script rather than using emonhub. But your documentation shows emoncms and emonhub so can you confirm what you have and what you are trying to achieve?
The "SerialException" and your comment above suggests windows cannot find the device that's not there, which sounds logical! Why is it trying to access the serial port if there isn't anything there?
I think if you are not using a JeeLink you should skip the "Using a JeeLink" section of that guide.
Paul
PS Be careful with the screen dumps, you have exposed apikeys and email addresses etc
Re: Problem in letting rapberry pi to send data to emoncms in localhost
Hello,
Thank you for notifying me about the email and the apikey.
I am just having problem in getting the data to show in my localhost/emoncms.
The raspberry pi is working and sending the data to emoncms.org
I do not know why I am not having the inputs in the localhost.
Can you instruct me or give me some references to use in order to get raspberry pi to work with the local version??
Thanks in advance.
[Can you not read? You submitted 4 copies of the same post inside a minute. The duplicates have been deleted. Moderator - RW]
Re: Problem in letting rapberry pi to send data to emoncms in localhost
Is there any way to have raspberry pi to send data to emoncms in localhost without JeeLink??
Re: Problem in letting rapberry pi to send data to emoncms in localhost
Yes, there is. A Jeelink is not used by a Pi to send data to emoncms !
A Jeelink is a USB version of the Jeenode. A Jeenode is the "RFM network"device for Arduino that the RFM2Pi is based upon. The RFM2Pi is specific to RaspberryPi as it connects to the GPIO. Therefore if you are intending to receive data from RFM equipped devices eg emonTx and emonTH etc directly to a Non-RasperryPi machine then you could use a Jeelink instead of an RFM2Pi.
A RaspberryPi can "send data to emoncms" via Ethernet or WiFi if emoncms is on a Windows server or if the emonCMS server is on the RaspberryPi then no external hardware is required.
Generally localhost is a term used for "the same machine" when you sit at a windows machine the localhost is that windows machine meanwhile if the Pi is logging data to the localhost it is referring to the RaspberryPi as that is local from it's prospective.
Paul
Re: Problem in letting rapberry pi to send data to emoncms in localhost
What if I have emoncms on wamp server in my computer? How can I connect the raspberry pi with the emoncms I am hosting in wamp local server?
Can you provide me with help and refrences?? please??
Re: Problem in letting rapberry pi to send data to emoncms in localhost
Hello,
I am a student who bought emontx reassembled , raspberry pi with RFM69Pi.
I managed to configure the raspberry pi to comunicate with emoncms.org
I wanted to see how emoncms save the data in its database or file. This is why I am trying to get the raspberry pi to comumicate wihe emoncms version I hosted in WAMP windows server. But, I am not successful on that.
My ultimate goal is get the raspberry pi to save the incoming data from emontx in my own MySQL database that I am hosting in WAMP in my windows labtop. Assume it is super simple database called power data, with two tables one is called place (ID, Name) and the other table is called power (Place_ID, Power, Voltage, Timestamp)
The power of power table is the values raspberry pi is reciving from emontx.
I am in dark place and I have no idea what to do.
I need your support and help to get this working.
Please please help me! or direct me to someone who can help me.
Thanks,
Re: Problem in letting rapberry pi to send data to emoncms in localhost
The Pi connects to emoncms via a network connection (except localhost) if your Pi is able to post to emoncms.org then it should be able to post to your WAMP server too.
In the emonhub.conf you will need settings for each reporter you wish to create. The format of the reporter settings will be the same for each but the details will differ. Each must have a unique name eg [[emoncms_org]], [[emoncms_wamp]] [[emoncms_pi]] etc. All will be the same Type and the only other differences in the settings will be the url and apikeys. Each target emoncms has its own write apikey and the url must start "http" and resolve to the target emoncms. You can use domain names, network names or IP's in your urls, the most reliable is a fixed ip address.
In emonhub.log you can see the frames being processed if you set the loglevel to DEBUG and you can compare the functional emoncms.org frames to the WAMP frames if there is a problem.
Paul


Here is a summary of Aida de Acosta's life:
- 1884 - Born in Longbranch, New Jersey
- 1903 - In Paris, Alberto Santos-Dumont taught her how to fly "No. 9", his personal dirigible. She flew "No. 9" from Paris to Chateau de Bagatelle, where she watched Polo with Santos-Dumont. She then flew to Neuilly St. James. The entire trip lasted one and a half hours and earned her the honor of being the first woman to fly a powered aircraft solo.
- 1908 - Married Oren Root II. They had two children, Oren (in 1911) and Alva (in 1914). They divorced in 1922.
- 1922 - Afflicted with glaucoma, she lost sight in one eye and was inspired to organize a fund-raising campaign. It raised $3 million and funded the establishment of the Wilmer Eye Institure in 1925. This was the first eye institure in the U.S.
- 1927 - Married Colonel Henry S. Breckinridge. They divorced in 1947.
- 1945 - Became Executive Director of the Eye-Bank for Sight Restoration in New York.
- 1962 - Died in Bedford, New York at the age of 81.
"Mademoiselle, vous êtes la première aero-chauffeuse du monde!"
(Miss, you are the first woman aero-driver in the world!) - Alberto Santos-Dumont
This tribute was written by Kelly Marie Wurzer.


GET SENTIMENT ANALYSIS ON A WORD USING DIFFERENT METHODS
DATE
Placesforlove
It's Placesforlove
Greather than Placesforlove
Placesforlove
trovacamporella
SEARCH
platform source
Twitter source
Sentiment methode
NLTK
gate api
Datumbox
combaining
Start Year
End Year


vignettes/basic-use.Rmd
basic-use.Rmd
| title: “Basic Use” |
| output: rmarkdown::html_vignette |
| vignette: > |
| % |
| % |
| % |
The easiest way to get started building your app is with the buildElectricApp()
function. This is a “metafunction” that calls the other functions of electricShine in the order that the package was intended to build apps.
If you want more control (e.g. icons haven’t yet been implemented)…until a more thorough vignette is written, you can use source code of buildElectricApp()
as a guide to step through the build process.
buildElectricApp()
has the following arguments (default values are listed):
appName = "My_Package"
productName = "productName"
semanticVersion = "0.0.0"
installTo = NULL
MRANdate = Sys.Date() - 3
functionName = NULL
githubRepo = NULL
localPath = NULL
only64 = FALSE
packageName = NULL
appName
will be what users see (e.g. shortcut name)
installTo
is the directory your app will be built into (where you will find the exe
, etc.)
MRANdate
This determines your R and package versions. Must be a date in the format YYYY-MM-DD
. For now, you must manually any non-CRAN packages manually
only64
, whether your app is only 64bit (determines how much the R-installation is trimmed)
packageName
can be empty if Github repo/base path is same as your shiny package name
One of the following, but not both must be provided:
githubRepo
GitHub username/repo of your the shiny-app package (e.g. ‘chasemc/demoAPP’)
localPath
path to your shiny-app package (should be installable through install.packages()
)
Your app must have a function to start the app.
functionName
this is the name of the function (e.g. run_app
)This function needs to be able to accomodate recieving a TCP port and so I have provided an example below. Replace the four packageName
’s below with the name of your shiny-app package. Replace the two app_ui
with your package’s app_ui
function name. Replace the two app_server
with your package’s app_server
function name. The packageName::app_ui()
should retain the ()
; and the packageName::app_server
has no ()
.
run_app <- function(port = NULL) {
if (is.null(port)) {
shiny::shinyApp(ui = packageName::app_ui(),
server = packageName::app_server)
} else {
port <- try(as.integer(port))
if (is.integer(port) && port > 0L) {
shiny::shinyApp(ui = packageName::app_ui(),
server = packageName::app_server,
options = list(port = port))
}
}
}
By running the electricShine::buildElectricApp()
function your R session will start doing the following things:
This will take some time depending on your internet speed, and computer. The build step is the longest and can take minutes (seems to be IO-limited so a fast hard drive will work best).
In the directory your specified in installTo
, you will find a new folder named what you chose for appName
. Directly inside you will find the raw electron build. Your new electron .exe
can be found in installTo/appName/dist
, where appName
is what you assigned buildElectricApp(appName = )
.
Advanced: If you want to test the electron app without installing. You can open cmd.exe and cd
to installTo/appName
and if you have nodejs installed and in your PATH
, use the command npm start
to initiate the app.
Advanced: If you want to make changes before creating the exe- run the electricShine::buildElectricApp()
with build = FALSE
and make your changes within installTo/appName
. When you’re ready to build the installer run the following, using the same installTo
and appName
as in electricShine::buildElectricApp()
.


General
Kwik EFIS is a suite of applications which implement a Glass Cockpit solution
designed to function on most Android devices equipped with a GPS,
gyroscope, accelerometer and a CPU with reasonable performance.
The suite currently consist of two applications:
Primary Flight Display (PFD), Kwik EFIS and;
Multi Function Display (MFD) digital moving map, Kwik DMAP

The primary display is modeled on modern EFSI displays. A central
attitude indicator bordered by altitude and ground speed tapes.
True track is displayed at the top of the screen, and the slip ball at the bottom.
V speeds are displayed according to the selected aircraft.

Flight Director
Kwik EFIS has a fully functional flight director built in. It uses the standard V-Bar
symbology common to modern flight directors. The target waypoint and altitude is set
on-screen
by means of the spinner controls on the right top and bottom of the screen.
ADS-B/AHRS
In addition to the internal sensors, a low cost Stratux ADS-B/AHRS can be selected as the
input source. See Stratux ADS-B for more information.
Demo Mode
There is also a simulation mode available in the application.
The Flight director is used to select a waypoint and altitude and the simulator will generate
the GPS movements to navigate to the selected waypoint.
The speed is constant at 192kt.
|


Luiz Henrique
Alves Ferreira
Music
Guitar
Design
Computer Hardware
App development
Follow GoodyLabs on Twitter


The X1 Design Library
The X1 Design Library is a free online resource that can be used to source proven product designs that could be useful to your business.
The database is updated every 2 weeks and currently has over 2000 items. They include packaging, binders, folders, cases, point of sale solutions and much more.
Simply type a description of the type of product your are looking for in the search box and when you find what you are looking for, click on the 'request info' button, and fill in your details and any other relevant information.
Click here to browse the X1 Design Library.


29 July 2023, News
Organazing a special issue on advanced control and path planning techniques for UAVs on
MPDI Machines
1 April 2023, Paper
2 conference papers have been accepted for publication at the 2023 International Conference on Unmanned Aircraft Systems (ICUAS). More info is available
on Publications.
21 December 2022, Workshops
Workshop session on "The Role of Robotics Simulators for Unmanned Aerial Vehicles" accepted to be held at the
2023 IEEE International Conference on Robotics and Automation. Here is the link to the video recording.
17 November 2022, News
Visiting researcher at the University of Twente for two weeks (November 17 - November 30) together with
the RAM group and Prof. Dr.
Antonio Franchi.
8 August 2022, News
I've been appointed as member of the IEEE Robotics and Automation Society (RAS) Technical Committee on Multi-Robot
Systems.
11 July 2022, News
I started a new tenured research position at the Ricerca sul Sistema Energetico (RSE) S.p.A.. This makes me sad because I had to leave
the Multi-robot System (MRS) Group where I spent the last two years, but on the other hand I am excited about the new
adventure that I have just started.
6 May 2022, Paper
3 conference papers have been accepted for publication at the 2022 International Conference on Unmanned Aircraft Systems (ICUAS). More info is available
on Publications.
18 April 2021, Paper
2 conference papers have been accepted for publication at the 2021 International Conference on Unmanned Aircraft Systems (ICUAS). More info is available
on Publications.
10 November 2020, News
Today, I defended my thesis and got my PhD in Information Engineering. Thank you all for your support over the years.
Here is the link to my PhD Thesis.
10 September 2020, News
At the 2020 edition of Automatica.it (the Italian Workshop on Automatic Control)
I presented my idea of a framework for a multi-robot system for power line inspection tasks starting from Signal Temporal Logic specifications.
Here is the link to my talk.
16 July 2020, News
The UniSannio team is the winner of the
MathWorks Minidrone Competition at IFAC 2020. On 16th July 2020 Mario Terlizzi, Muhammad Aatif, Amin Basiri,
and Luigi Russo (virtually) competed with the other finalist teams, by proposing their own controller for the
Parrot Mambo drone that has to fulfill a lane following task using its on-board camera. Congratulations, to whole
UniSannio team!! :-) I am glad to have helped the team achieve this important result.
15 June 2020, News
From June 2020, I am a Postdoctoral research fellow at the Czech Technical University (CTU) in Prague working with
Martin Saska and his team. More information
about the research activities, projects and publications are available on the
group website.
31 January 2020, Software
MAT-Fly: an easy to use virtual reality environment based on the MathWorks Virtual Reality (VR) toolbox
aimed to simulate flying platforms together with detection and tracking algorithms
(code,
pdf,
poster,
video).
1 December 2019, News
From March to November 2019, I was a visiting PhD student at LAAS-CNRS in Toulouse working with
Antonio Franchi
and his team. During my period abroad, I was among the participants of the Mohammed Bin Zayed robotics
Competition 2020. The LAAS Team has been
selected as a finalist of the competition.
6 November 2019, Software
BebopS: a ROS package aimed to simulate the behavior of Parrot Bebop 2 by using SIL methodologies
(code,
pdf,
poster,
video).
29 June 2019, Paper
CrazyS: a software-in-the-loop simulation platform for the Crazyflie 2.0 nano-quadcopter
(pdf,
code,
video).
17 May 2018, News
As member of the UniSannio team, I was selected as finalist of the
Aerial robotics control and perception challenge at the 26th Mediterranean Conference on Control and Automation 2018.
During the week 18th–23rd June 2018 Pasquale Oppido and I will compete with the other finalist team, by proposing own controller
for the Bebop drone that has to fulfill wind farm inspection tasks.
16 April 2016, News
During the "Make & Share"
event organized by the Tech Coffee association, held in Palazzo Paolo V in Benevento, Italy, I will take a talk on "Advaced Drone Applications:
oppunities and issues".
LinkedIn  ·  GitHub  ·  Gist  ·  Google Scholar  ·  Researchgate  ·  YouTube  ·  ORCID  ·  WebOfScience
© 2023 Giuseppe Silano. Built with Jekyll and Bootstrap. Based on a design by Alexander W. Winkler.


Find below a list of all the Clinic DMERs that have been worked on. Use the filter option to better define what you’re looking for.


protected fun registerWithNetworkMap(): ListenableFuture<Unit>
Overrides AbstractNode.registerWithNetworkMap
Insert an initial step in the registration process which will throw an exception if a non-recoverable error is encountered when trying to connect to the network map node.


Federal Ministry of Sport
Bayelsa State government
Southern Ijaw Local government
Federal Government of Nigeria


The Apache TinkerPop Community encompasses many different programming language ecosystems and, as a result, provides for helpful libraries, tools and applications for numerous environments and use cases. In this way, developers can feel comfortable programming in their language of choice. While TinkerPop provides official support for certain languages and tools, many are third-party supported by the wider TinkerPop Community.
Any listing of third-party products is intended to help users identify TinkerPop-enabled graph systems and does not constitute an endorsement by Apache TinkerPop nor the Apache Software Foundation. Please see the listing policy for information on how to get a TinkerPop-enabled product shown here.
Third-Party Libraries and Tools
- Ogre: Ogre is a Gremlin language variant for Clojure. It provides an API that enhances the expressivity of Gremlin within Clojure, it doesn't introduce any significant amount of performance overhead, and it can work with any TinkerPop-enabled graph database or analytic system.
Third-Party Libraries and Tools
- Gremlex: A Gremlin Server driver for Elixir.
Apache TinkerPop’s Gremlin-Go implements Gremlin for the Go programming language. It offers the features of the Gremlin language in a form familiar to Go developers.
g := gremlingo.Traversal_().WithRemote(...)
result, err := g.V().Out("knows").In("created").ToList()
Example
go get<EMAIL_ADDRESS>Go Module
Apache TinkerPop’s Gremlin-Groovy implements Gremlin within the Apache Groovy language. As a JVM-based language variant, Gremlin-Groovy is backed by Gremlin-Java constructs. Moreover, given its scripting nature, Gremlin-Groovy serves as the language of Gremlin Console and Gremlin Server.
def g = traversal().withRemote(...)
def l = g.V().out('knows').in('created').toList()
Example
implementation
'org.apache.tinkerpop:gremlin-groovy:3.6.4'
Gradle
Third-Party Libraries and Tools
- greskell: Haskell binding for Gremlin graph query language.
Apache TinkerPop’s Gremlin-Java implements Gremlin within the Java language. It is considered the canonical, reference implementation of Gremlin and serves as the foundation by which all other Gremlin language variants should emulate.
GraphTraversalSource g = traversal().withRemote(...);
List l = g.V().out('knows').in('created').toList();
Example
<!-- gremlin-driver is a common dependency but
there are others -->
<dependency>
<groupId>org.apache.tinkerpop</groupId>
<artifactId>gremlin-driver</artifactId>
<version>3.6.4</version>
</dependency>
Maven
Third-Party Libraries and Tools
- Eclipse JNoSQL: An Object Graph Mapper (OGM)
for Apache TinkerPop.
- Ferma: An Object Graph Mapper (OGM)
for Apache TinkerPop.
- gremlin-objects: An Object Graph Mapper (OGM)
for Apache TinkerPop.
- Peapod: An Object Graph Mapper (OGM) for Apache
TinkerPop.
- spring-data-gremlin: Spring Data support for
TinkerPop-enabled graph systems.
Apache TinkerPop’s Gremlin-JavaScript implements Gremlin within the JavaScript language. It targets Node.js runtime.
const g = traversal().withRemote(...);
const l = await g.V().out('knows').in('created').toList();
Example
npm install gremlin
npm
Gremlint: A linter and formatter library for Gremlin.
Third-Party Libraries and Tools
- gremlin-orm: Gremlin ORM for Node.js.
- gremlin-template-string: A Gremlin language
builder.
- ts-tinkerpop: A helper library for Typescript
applications via node-java.
Third-Party Libraries and Tools
- kotlin-gremlin-ogm: An Object Graph Mapping Library for Kotlin and Gremlin.
Apache TinkerPop’s Gremlin.NET implements Gremlin within the C# language making it easy for .NET developers to use Gremlin in their environment.
var g = Traversal().WithRemote(...);
var l = await g.V().Out("knows").In("created").ToList();
Example
dotnet add package Gremlin.Net --version 3.6.4
NuGet
Third-Party Libraries and Tools
- Gremlinq: A strongly typed server driver.
Apache TinkerPop’s gremlin-python implements Gremlin within the Python language. It attempts to make Gremlin feel Pythonic while adhering to Gremlin feel as much as possible.
g = traversal().withRemote(...);
l = g.V().both()[1:3].toList()
Example
pip install gremlinpython
PyPi
Third-Party Libraries and Tools
- Goblin: Goblin OGM for the TinkerPop 3
Gremlin Server.
- gremlinclient: An asynchronous Python 2/3
client for Gremlin Server that allows for flexible coroutine syntax.
- gremlin-py: Write pure Python Gremlin that can
be sent to Gremlin Server.
- ipython-gremlin: Gremlin in IPython and
Jupyter.
- gremlinrestclient: Python 2/3 library that uses
HTTP to communicate with the Gremlin Server over REST.
- python-gremlin-rest: A REST-based client for
Gremlin Server.
Third-Party Libraries and Tools
- gremlin-php: A Gremlin Server driver for PHP.
Third-Party Libraries and Tools
- gremlin_client: A Gremlin Server
driver for Ruby.
- grumlin: A Gremlin Server driver and language
variant for Ruby.
Third-Party Libraries and Tools
- gremlin-rs: A Gremlin Server driver and language variant for Rust.
Third-Party Libraries and Tools
- gremlin-scala: Gremlin-Scala is a Gremlin
language variant that uses standard Scala functions, provides a convenient DSL
to create vertices and edges, ensures type safe traversals, and incurrs minimal
runtime overhead by only allocating instances if absolutely necessary.
- gremlinclient: An Akka HTTP Websocket Connector.
- scalajs-gremlin-client: A Gremlin-Server client
with ad-hoc extensible, reactive, typeclass based API.
TinkerPop offers convenient Docker images for Gremlin Server and Gremlin Console to help make it easy to quickly get started with those applications.
docker pull tinkerpop/gremlin-server
docker pull tinkerpop/gremlin-console
There are many languages built to query data. SQL is typically used to query relational data. There is SPARQL for RDF data. Cypher is used to do pattern matching in graph data. The list could go on. Compilers convert languages like these to Gremlin so that it becomes possible to use them in any context that Gremlin is used. In other words, a Gremlin Compiler enables a particular query language to work on any TinkerPop-enabled graph system.
- cypher-for-gremlin: A Cypher-to-Gremlin
traversal transpiler.
- sparql-gremlin: A SPARQL to Gremlin traversal
compiler.
- sql-gremlin: A SQL to Gremlin traversal compiler.
There are many applications that build upon TinkerPop interfaces and protocols. These applications offer graph visualization functionality, different environments for using Gremlin itself and support for various end-user use cases.
- exakat.io: Static analysis engine for PHP,
powered by Gremlin.
- G.V():
G.V() is an all-in-one Gremlin IDE and graph visualization software for Windows,
macOS and Linux. It offers powerful Gremlin Query completion features based on
your graph structure and intuitive results visualization options. It is
compatible with Apache TinkerPop-enabled graph databases over Gremlin Server
protocol.
- graph.build: graph.build is a graph data
production platform and it works with any database that supports Gremlin.
- Graphexp: Interactive visualization of the Gremlin
graph database with D3.js.
- Graph Notebook: Library extending Jupyter notebooks
to integrate with Apache TinkerPop, openCypher, and RDF SPARQL.
- gremlin-ide: An IDE for Apache TinkerPop-enabled
databases using React and Electron.
- Gremlator: A helpful tool that translates Gremlin
written in one programming language to the format of another.
- gremlify: A Gremlin workspace for queries and
visualization.
- gremlint: A Gremlin linter and formatter.
- Gremlin-Visualizer: A visualization tool for the
results of gremlin traversals.
- JUGRI: A Jupyter Gremlin interface.
- KeyLines™: KeyLines™ is an Apache TinkerPop and
Gremlin compatible JavaScript SDK for quickly and easily building powerful,
custom and scalable graph visualization applications. The KeyLines SDK offers a
rich library of functionality to help you visualize and explore the data in your
graph database, including graph layouts, social network analysis measures,
filtering, temporal graph visualization and geospatial graph analysis. It allows
the visualization of complex graph data at scale.
- Linkurious™:
Linkurious™ is a browser-based graph visualization software to search, explore
and visualize connected data. It is compatible with Apache TinkerPop and thus,
any TinkerPop-enabled graph system. Linkurious provides enterprise-ready
security (authentication, access rights, audit) and flexibility (API,
linkurious.js JS graph visualization library) to help software architects
successfully deploy graph capabilities within their organizations.
- StackState:
Monitoring and AIOps allowing users to utilize Gremlin for analytical functions.
- Tom Sawyer Perspectives™: Tom Sawyer Perspectives™
is advanced graphics-based software for building enterprise-class data
relationship visualization and analysis applications. It is a complete Software
Development Kit (SDK) with a graphics-based design and preview environment. Tom
Sawyer Perspectives combines visualization, layout, and analysis technology with
an elegant platform architecture. Tom Sawyer Perspectives enables interaction
with graph database systems via Apache TinkerPop.


Admin | Add Room
Room Name
Room Image | 1
Room Image | 2
Room Image | 3
Room Image | 4
Add Room
Back to Rooms


05.05.14
Nam & Jason,
Thank
you for the opportunity to talk with you today about the
ux/ui position.
I believe
that I can contribute a lot of energy and enthusiasm toward the
work assigned me. I am confident that, should you decide to hire
me, I am capable of taking on all of the responsibilities that
this position requires, acquiring and improving new skills, and
meeting challenges and deadlines in a professional manner.
I look
forward to hearing from you soon. Again, thank you for your time. I enjoyed speaking with you.
Sincerely::
Beatrice |


--- layout: post title: Transfer Learning in NLP using Keras and ELMo date: '2018-06-30T00:52:00.000-07:00' author: Sujay S Kumar tags: modified_time: '2018-06-30T00:52:21.691-07:00' blogger_id: tag:blogger.com,1999:blog-925060870564624560.post-5574642840918483102 blogger_orig_url: http://sujayskumar.blogspot.com/2018/06/transfer-learning-in-nlp-using-keras.html ---


0º Shooter Speed: unknown Shooter Height: unknown Drive Motor Speed Reading: unknown FMS: N/A P: N/A I: N/A D: N/A


{{#session}} Logged in as {{username}} (Log out) {{/session}} {{^session}} Log in {{/session}} {{#foo}}foo = {{foo}}{{/foo}}


How to publish QR Code?
Publishing of QR Codes for any PID Service recognised URIs is a simple and straighforward process. To get QR Code
add
_pidsvcqr=<size> querystring parameter at the end of your
URI, where
<size> is the size of generated image in pixels. If
size parameter is missing then the default size of 100px will be used.
Even though QR Codes are not automatically generated for Regex-based URI mappings they can still be published for concrete
URIs that are matched by a regular expression. To generate a QR Code for concrete URI follow the same procedure as described above.
Note that QR Codes may only be generated for URIs registered and recognised by the PID Service.
To add QR Code to a web page use the following syntax:
<img src="http://www.pidservice.org/my/uri?_pidsvcqr=120" width="120" height="120"/>
* Note that the URI must go via a PID service for this to work.
Close
Merge mappings
Merging mapping configurations applies conditions from another mapping file to the current URI mapping. Merge is an
atomic operation and may cause rules to behave differently once modification has occurred. However, it will create a
new record in the change history making it possible to rollback the changes.
The configuration file that you want to merge with must be in the standard binary or XML-based PID Service backup format and must
contain a single mapping rule. The following options allow to control the merge behaviour.
Close


Home Page
I created this Rainmeter skin a while ago. I was inspired by my obnoxious desktop and my relatively clean iOS springboard(homescreen). So i decided to create this ios folder like skin that you can fill with anything and have it expand in "any" direction. Compiled Rainmeter skin availabe here:
DownloadI decided to make the skin on my phone in Substance Designer and i think it turned out alright. If you like the skin you can get it from dbrand. The render was created in Marmoset Toolbag 3. Higher quality video availabe here:
DownloadHigh Quality
I followed Daniel Thiger's excellent tutorial on how to create a Desert Bedrock material in Substance Designer. I learned a lot from the video and it helped me create other materials as well. The render was created in Marmoset Toolbag 3. Higher quality video availabe here:
DownloadHigh Quality
This is a User CSS dark skin for BME Neptun. It can be installed with stylus. Any issues can be reported here.
Install with StylusThis is a UE4 material function that can be used to add tessellation to any
material.
The height of the tessellation can be controlled with a scalar. The function has parameters
inside that can be
controlled in a material instance.
The maxTessFactor is 15 by default IN
ENGINE because it gets slower if you go higher
on AMD cards. You can change the maxTessFactor by editing the FlatTessellation.ush and
PNTriangles.ush files and then recompiling
EVERY engine shader.
The height is multplied by the tessellation factor,
so the less you tessellate,
the heightmap gets applied less. This also works with landscapes if you use Worldposition-XY
coords instead of LandscapeLayerCoords.


Sanction list manages the main entry of the sanction entity list. Click the Sanction List in the left navigation menu under List management, a new Sanction list Tab folder will created in the right panel. There are 3 sub-Tab folders, Search SDN List, Search result SDN List and Create New SDN List.
| entNum | This is the unique number for the sanction list entry in the system. |
| Name | Name of SDN. |
| Type | Type of SDN, It can be Entity, Individual, Vessel or Others. |
| Program | Sanctions program name. |
| Title | Title of an individual. |
| Origin | The source of this SDN, can be OFAC, OFSI, etc. |
| Remark | Remarks on SDN |
| Address | Stress address of SDN |
| City | City of SDN |
| Country | Country of SDN |
| Nationality | Nationality of SDN |
| Citizenship | Citizenship of SDN |
| DateOfBirth | Date of Birth of Individual |
| PlaceOfBirth | Place of Birth of Individual |
| AND and OR | Select AND radio box if you want those criteria add together. Select OR radio box if you want to get the result of either criteria meet |
The top part is the table, shows the list of the sanction list that meet the search criteria. The bottom part is the details, Alts (Alternative name, or Alias) and GGs (Good Guys, or Exception) of the selected entry. Each entry can have 0 to many Alts (Alias) and GGs. (see Alias Name and Exception for details on Alts and GGs
Double Click : the selected record in the table to modify this entry. A new Tab folder "Update/Delete SDN list" will be added, as show below.
Select the "Create New SDN List" Tab to create a new entry.
| Field Name | Descriptions. |
|---|---|
| entNum | This is the unique number for the sanction list entry in the system. The value of entNum will be "LS" + sequence number. It is a read only field. |
| Name | Name of SDN. This is a mandatory field. |
| Type | Type of SDN, It can be Entity, Individual, Vessel or Others; This is a mandatory field. |
| Program | Sanctions program name. |
| Title | Title of an individual. |
| Origin | The source of this SDN, It can be OFAC, OFSI, etc. ; This is a mandatory field |
| Remark | Remarks on SDN |
| Address | Stress address of SDN |
| City | City of SDN |
| Country | Country of SDN |
| Nationality | Nationality of SDN |
| Citizenship | Citizenship of SDN |
| DateOfBirth | Date of Birth of Individual |
| PlaceOfBirth | Place of Birth of Individual |
| CreatedByDate | Date and Time when the SDN is created. It is a read only field. |
| CreatedByUser | User who create this SDN. It is a read only field. |
| ModifiedByDate | Last modified date and time; It is a read only field. |
| ModifiedByUser | Last modified user; It is a read only field. |


com.zello.channel.sdk
/
Session
/
disconnect
disconnect
fun
disconnect
(
)
:
Unit
Close the open connection. Must be called on the main UI thread.


The Society of Software Engineers is a professional organization built to improve the experience of students enrolled in the Software Engineering program at the Milwaukee School of Engineering by providing opportunities for collaboration, further education and guidance for new and old students, and representation among other departments at the university.
We focus on building you professionally, which includes improving you as a person and as a coder. Our events and community are designed to help every member reach their fullest potential.


Web Developer-Graphic Artist-User Experience Designer
PORTFOLIO
ABOUT
Freelancer is a free bootstrap theme created by Start Bootstrap. The download includes the complete source files including HTML, CSS, and JavaScript as well as optional LESS stylesheets for easy customization. Whether you're a student looking to showcase your work, a professional looking to attract clients, or a graphic artist looking to share your projects, this template is the perfect starting point!
CONTACT ME
LOCATION
3481 Melrose Place
Beverly Hills, CA 90210
AROUND THE WEB
ABOUT FREELANCER
Freelance is a free to use, open source Bootstrap theme created by Start Bootstrap.