-
Hip disorder
-
results from partial interruption of blood supply to immature femoral head
-
cause unknown
-
children 4-8yo
-
boys>>girls (4:1)
-
Increased incidence in:
-
low birth weight
-
abnromal birth presentation
-
fhx
-
higher birth order
-
lower socioeconomic status
Presentation
-
hip pain
-
usually unilateral
-
atraumatic limp
-
referred pain in knee
Examination
-
Limited hip abduction
-
internal rotation
-
leg-length discrepancy
Investigations
-
AP and frog-leg lateral radiographs
-
varying degrees of:
-
flattening
-
fragmentation
-
sclerosis
-
of prox femur growth centre with joint space widening
-
DDx
-
Septic arthritis
-
osteomyelitis
-
SUFE
-
Irritable hip
Poor prognostic factors:
-
age >6yo at onset
-
greater extent of femoral head deformity
-
hip joint inconfuity
-
dec. hip ROM
Treatment
-
ortho referral - exclude septic arthritis [bloods]
-
arthroscopic chondroplasty and loose body excision has shown good short-term results
-
rest
-
analgesia
-
Usually resolves: Return to sport is possible when symptom-free and XR shown some improvement


Feeling Alone with Parkinson’s Disease
by Sherri WoodbridgeWe’ve all been alone. We’ve all felt alone. And we all know there is a difference between the two.
Being alone is having no one around to laugh with, to cry with, or to be with us when we need them. Feeling alone can happen in a coliseum, surrounded by thousands of people.
When we feel alone, it is hard to pull ourselves out of the pit. We withdraw and separate ourselves from others. Feeling alone lends itself to isolation.
With Parkinson’s disease, it is easy to sink into loneliness. We convince ourselves that no one wants to spend time with us because they don’t understand us or what we’re going through. That’s not always true. Sometimes it can be that another’s perception of what is going on with us is different than what is really happening. But we are convinced that they don’t understand our plight in life.
Let’s say they don’t understand.
Others can’t see when we shake on the inside. And when we shake on the outside, they only see half of it. We don’t always think clearly or speak loudly enough to be heard or understood. Newly impaired vision may prevent us from seeing what they do. That frustrates them. They don’t know when the pain becomes unbearable.
It they can’t see what is affecting us, how can we expect them to understand?
It is up to us to educate others about this disease. We have to help them understand that we aren’t the same as we once were. Few people are, but Parkinson’s can accelerate that reality. It changes us emotionally and mentally, as well as physically. We can’t do things as quickly as we once did. We can’t do some things at all anymore. Like writing. Or jogging around the park with a friend. Or eating without needing someone to cut up our food. Parkinson’s affects our ability to finish sentences and keep up with conversations.
It is up to us to tell others how we are being affected by this disease. If we don’t, who will? We can’t expect others to understand unless we intentionally begin sharing. And if they still can’t — or won’t — understand, we’ve done all we can do.
We must move forward, knowing that we are in this together. We are never alone.
Note: Parkinson’s News Today is strictly a news and information website about the disease. It does not provide medical advice, diagnosis, or treatment . This content is not intended to be a substitute for professional medical advice, diagnosis, or treatment . Always seek the advice of your physician or another qualified health provider with any questions you may have regarding a medical condition. Never disregard professional medical advice or delay in seeking it because of something you have read on this website. The opinions expressed in this column are not those of Parkinson’s News Today or its parent company, BioNews Services, and are intended to spark discussion about issues pertaining to Parkinson’s disease.
http://www.parkinsonsjourney.com
Sherri was diagnosed with Young Onset Parkinson’s disease over fifteen years ago. She can be found working in her garden, going for walks, taking pictures, or reading books to her three favorite grandkids. Taking life somewhat slower, and perhaps with guarded steps, but she’s not giving in.
×
Sherri Woodbridge
Sherri was diagnosed with Young Onset Parkinson’s disease over fifteen years ago. She can be found working in her garden, going for walks, taking pictures, or reading books to her three favorite grandkids. Taking life somewhat slower, and perhaps with guarded steps, but she’s not giving in.
http://www.parkinsonsjourney.com


Evaluations¶
Metrics¶
For each test instance, we will expect you to return a set of 100 choices (candidate ids) from the set of possible follow-up sentences and a probability distribution over those 100 choices. As competition metrics we will compute range of scores, including recall@k, MRR(mean reciprocal rank) and MAP(mean average precision).
Following evaluation metrics will be used to evaluate your submissions.
Sub-Task
Ubuntu
Advising
1
Recall @1, Recall @10, Recall @50, MRR
Recall @1, Recall @10, Recall @50, MRR
2
Recall @1, Recall @10, Recall @50, MRR
3
Recall @1, Recall @10, Recall @50, MRR, MAP
4
Recall @1, Recall @10, Recall @50, MRR
Recall @1, Recall @10, Recall @50, MRR
5
Recall @1, Recall @10, Recall @50, MRR
Recall @1, Recall @10, Recall @50, MRR
Note: We will evaluate MAP for sub-task 3 with Advising data as the you are supposed to return the correct response and all the paraphrases associated with it.
Best Scores¶
The ranking considers the average of Recall@10 and MRR. Best Recall@10 and MRR scores for each subtask is is shown in the below table.
Recall@10
Sub-Task
Ubuntu
Advising-Case-1
Advising-Case-2
1
0.902
0.85
0.63
2
0.361
NA
NA
3
NA
0.906
0.75
4
0.739
0.652
0.508
5
0.905
0.864
0.63
MRR
Sub-Task
Ubuntu
Advising-Case-1
Advising-Case-2
1
0.7350
0.6078
0.3390
2
0.2528
NA
NA
3
NA
0.6238
0.4341
4
0.5891
0.3495
0.2422
5
0.7399
0.6455
0.3390


Whether you're looking to refresh your store's look with a new theme, stimulate new growth, or level up your business completely with a new Shopify plan, now's the perfect time to make a change.
It only takes one good idea to hit it big. Just ask Casper, which became a $555-million company practically overnight with a mattress-in-a-box that delivered a loud wake-up call to the entire "sleep" industry.


Table of Contents
Peradeniya Engineering Faculty Alumni Association
The Peradeniya Engineering Faculty Alumni Association (PEFAA), formed in September 1991, is a government registered charity organization. Its main objectives are to encourage, foster, and promote close relations between the Faculty and its alumni and among alumni, and also to assist and support, financially and otherwise, the Faculty and its students and alumni. Any person who has completed an undergraduate or postgraduate course in the Faculty or has been a member of the academic staff of the Faculty can be a Life Member of PEFAA. Here 'Faculty' means the Engineering Faculties of the University of Ceylon, the University of Sri Lanka (Peradeniya Campus), and the University of Peradeniya. The present membership is around 4500.
PEFAA supports needy students of the Faculty by giving financial assistance through its Needy Students' Fund, and its Benevolent Fund helps needy alumni. It also helps the undergraduates through orientation programs and by organizing lectures and seminars on industry related topics. PEFAA also supports industrial training of undergraduates and collects material for the Faculty library and laboratories through its members. In the recent past, PEFAA has been involved in administering a number of scholarships to undergraduates, granted by alumni.
In addition to the Annual General Meeting, PEFAA organizes trips, visits and get-togethers for its members to meet and exchange ideas both formally and informally. A quarterly newsletter (PEFAA News) keeps members informed of PEFAA activities.
In 1997 PEFAA embarked on its most ambitious project, setting up of the Engineering and Technology Centre (ET Centre). The main objective of the ET Centre is to educate, entertain and inspire people of different backgrounds by making Engineering and Technology accessible to them at their own level. The location for the proposed ET Centre is directly opposite the Faculty, across the Upper Gampola Road. The estimated cost of the project is about Rs. 120 million. Due to lack of sufficient funds this project is now stalled.
In last AGM it was decided to use the collected funds for ET center for PEFAA activites. If any donor has any concerns they were requested to inform the secretary PEFAA before 31 March 2018. Since there were no objections, the Ex-Co decided to open a Fixed Deposit whose interest (75%) will be used for the PEFFA activities. Remaining 25% will be capitallized
About the PEFAA Official Web Site
The main aim of the development of this web site is to provide a place where details and other correspondence information of all members could be obtained. Furthermore this is going to be a virtual place for effective interaction amongst the alumni for knowledge sharing and other career development activities. The web page will consist of the Members database, PEFAA news, PEFAA calendar, details regarding PEFAA projects, Office bearers and the Executive committee details, and annual events such as annual trips and the General Body meetings.
What is PEFAA
The Peradeniya Engineering Faculty Alumni Association (PEFAA), formed in September 1991, is a government registered charity organization. The present membership is over 3000.
Objectives of PEFAA
To encourage, foster, and promote close relations between the Faculty and its alumni and among alumni.
To assist and support, financially and otherwise, the Faculty and its students and alumni.
Who can become a Life Member
- Any person who has completed an undergraduate or postgraduate course in the Faculty
- Any person who has been a member of the academic staff of the Faculty can be a Life Member of PEFAA.
Here 'Faculty' means the Engineering Faculties of the University of Ceylon, the University of Sri Lanka (Peradeniya Campus), and the University of Peradeniya.
Main activities of PEFAA
- Support given to the students and the Faculty of Engineering
- Providing loans and bursaries through its Needy Students' Fund
- Administrating scholarships and bursaries and awards given to undergraduates, granted by alumni, either individually or as a group.
- Administrating donations to improve infrastructure facilities of the Faculty, granted by alumni.
- Providing drawing instruments on loan.
- Partly funding overseas travel for the students who represent the university at international seminars or sports competitions.
- Partly funding innovative activities organised by the faculty.
- Contributing to the annual 'Industry Day', an open day where personnel from the Industry are invited to the faculty to interact with the students and vice versa.
- Organizes a Seminar Series conducted by leading personalities in many different spheres sharing their experiences.
- Supports industrial training of undergraduates
- Collects material for the Faculty library and laboratories through its members.
Activities for the benefit of its membership
- Annual Industrial visit.
- Annual excursion with family members.
- Annual get-together with family members to meet and exchange ideas both formally and informally.
- The Benevolent Fund to help needy alumni.
- Organizes or facilitates Continuous Professional Development (CPD) programmes through the Engineering Design Centre (EDC).
- Issuing quarterly newsletter (PEFAA News) that keeps members informed of activities of PEFAA, and the achievements of its members.


Welcome to Unilever DevOps Workshop Bangalore India.
Please fill in this form to create an account and Login to account to generate your KPMG DevOps Workshop Participation Certificate.
Name
Organization
Designation
Email Id
Contact Number
Cancel
Submit
Copyright Akbar Jafri Unilever India


Demodulator Plugins
The source code of the demodulator plugins is available here .
In this example we demonstrate how to implement multiple plugins in the same .NET assembly, how to create the plugins that are used in DSP Pipeline, and how to make use of the DspFun library for signal processing.
Three Plugins in the Same Assembly
The three demodulators presented here demodulate CW, SSB and RTTY respectively.
The demodulation process is the same for all three modes, the difference
is only in the parameter values. Demodulation is implemented in the base class,
BaseDemodulator
, each plugin inherits from that class and changes the
default values of the
Pitch
and Sideband
parameters, as well as the plugin and mode names:
public abstract class BaseDemodulator : IPlugin, IDemodulator
{
...
}
[Export(typeof(IPlugin))]
[Export(typeof(IDemodulator))]
public class CwDemodulator : BaseDemodulator
{
public CwDemodulator()
{
pluginName = "CW Demodulator";
modeName = "CW";
settings.Pitch = 600;
settings.Sideband = Sideband.Upper;
}
}
[Export(typeof(IPlugin))]
[Export(typeof(IDemodulator))]
public class SsbDemodulator : BaseDemodulator
{
public SsbDemodulator()
{
pluginName = "SSB Demodulator";
modeName = "SSB";
settings.Pitch = 0;
settings.Sideband = Sideband.Upper;
}
}
[Export(typeof(IPlugin))]
[Export(typeof(IDemodulator))]
public class RttyDemodulator : BaseDemodulator
{
public RttyDemodulator()
{
pluginName = "RTTY Demodulator";
modeName = "RTTY";
settings.Pitch = 2125;
settings.Sideband = Sideband.Lower;
}
...
}
The derived classes export IPlugin
,
which turns them into plugins, and IDEmodulator
, so that
DSP Pipeline
can use them for demodulation.
Demodulation
The demodulation process includes these steps:
- resample the input I/Q signal down to 12 kHz, the standard sampling rate for audio processing;
- flip the sideband if necessary;
- if
Pitch
is non-zero, mix the signal up to the pitch frequency; - apply a 0..6 kHz filter to suppress the lower sideband.
The DspFun library that comes with Ham Cockpit has classes for all these signal processing tasks, which makes our job much easier. Moreover, these classes implement the ISampleStream interface, so they are easy to cascade.
IDemodulator : IInitSampleStream
IInitSampleStream.Initialize
The
Initialize
method implemented by the plugins
creates objects that will preform the signal processing tasks
and connects them in a chain:
private ISampleStream signal;
...
public void Initialize(ISampleStream source)
{
//input signal
signal = source;
//resampler
Resampler resampler = new Resampler(SignalFormat.AUDIO_SAMPLING_RATE, 30);
resampler.Initialize(signal);
signal = resampler;
//sideband flipper
flipper = new SidebandFlipper();
flipper.Initialize(signal);
signal = flipper;
//mixer
mixer = new Mixer(settings.Pitch);
mixer.Initialize(signal);
signal = mixer;
//filter
float Fc = 2962f / SignalFormat.AUDIO_SAMPLING_RATE;
var realTaps = Dsp.BlackmanSincKernel(Fc, 235);
Complex32[] taps = Dsp.FloatToComplex32(realTaps);
Dsp.Mix(taps, 0.25); //shift filter passband -3..3 kHz -> 0..6 kHz
filter = new ComplexFirFilter(taps);
filter.Initialize(signal);
signal = filter;
}
The ComplexFirFilter
needs an array of filter taps as an input
parameter to the constructor. We use the helper methods from
DspFun
to generate the taps.
IDemodulator : ISampleStream
ISampleStream.Format
The output from the demodulator is real-valued audio data filtered
to 0..6000 Hz. To create the Format property that describes the output format of
the demodulator, signal.Format
of the last processing stage
is used as a prototype, and the new parameters are set as follows:
format = new SignalFormat(signal.Format)
{
IsComplex = false,
PassbandLow = 0,
PassbandHigh = 6000,
Sideband = settings.Sideband
};
ISampleStream.Read
The Read
method of the demodulator is called by the next plugin in the DSP Pipeline
chain. When this method is called, the demodulator calls Read
on the previous plugin in the chain to get input data, and
uses its own signal processing blocks to produce
downsampled, freq-shifted, sideband-flipped and 6kHz-filtered I/Q
data. The final step is to discard the imaginary part of
the I/Q values and make it real-valued data:
public int Read(float[] buffer, int offset, int count)
{
//input I/Q
int read = count * Dsp.COMPONENTS_IN_COMPLEX;
if (inputBuffer == null || inputBuffer.Length < read) inputBuffer = new float[read];
//read downsampled, freq-shifted, sideband-flipped and 6kHz-filtered I/Q
read = signal.Read(inputBuffer, 0, read);
count = read / Dsp.COMPONENTS_IN_COMPLEX;
//complex to real
for (int i = 0; i < count; i++) buffer[offset + i] = inputBuffer[i * Dsp.COMPONENTS_IN_COMPLEX] * 100f;
SamplesAvailable?.Invoke(this, new SamplesAvailableEventArgs(buffer, offset, count));
return count;
}
IDemodulator : IModeSwitch
IModeSwitch.Mode
The Mode
property returns the name of the mode demodulated by
the plugin. The setter is not implemented since each demodulator
supports only one mode:
public string Mode { get => modeName; set => throw new NotImplementedException(); }
IModeSwitch.Sideband
The Sideband
property is read-write, it reflects the Enabled
state
of SidebandFlipper
used in the demodulator:
public Sideband Sideband { get => settings.Sideband; set => SetSideband(value); }


Hello, participants!
This is a jumbotron example, that is used in many of the designs you would like to use for your portfolio pages. Using this Bootstrap feature will help you to create the desired layouts.
Photos
Progress Bars
Contact Form
DropUp Split Button
Tab Panel
Dismissable Alerts
Success! Your Updates have been saved.
Error: Please fill in all required fields.


In this tutorial, we’ll use some simple JQuery connected with a Quote API to make a website present a quote after the spacebar is pressed. We will be using AJAX to service requests between the API and handling the JSONP response.
As always, you’ll need a folder with three files:
To start with, our content will be displayed in the center of the screen. We also want to display our quote and source/author separately. Create a parent container div and two other divs for the quote and source. Last, create some instructions at the tails of the site so people know how to use it, import JQuery scripts using CDN, and link a custom font for us to use from Google Fonts. Our website isn’t functional and it’s pretty sketchy right now so let’s use some CSS to alleviate parts of those problems.

<meta charset="utf-8">
<title>
Quote
</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="style.css">
<link href="https://fonts.googleapis.com/css?family=Inconsolata" rel="stylesheet">

 press space to inspire

The divs are empty, so you won’t see them. However, they still are there, but all you should see as a result is the instructions to press the space we typed earlier.
Here’s some basic things you should style:
This is my approach, feel free to tweak it to your preferences.
html,body {
height: 100%;
width: 100%;
background: #202020;
display:table;
overflow: hidden;
}
/* font css */
p {
font-size:2em;
}
/* main container css */
.contain{
display:table-cell;
vertical-align: middle;
text-align: center;
padding:3em;
}
/* quote css */
#quote{
color:white;
font-family : Inconsolata;
position: relative;
}
/* source css */
#writer{
opacity:1;
font-size: 1em;
padding-right:2em;
text-align: right;
color:white;
font-family : Inconsolata;
position: relative;
-webkit-transition: all 1s ease-in-out;
-moz-transition: all 1s ease-in-out;
-o-transition: all 1s ease-in-out;
transition: all 1s ease-in-out;
}
/* for the after stage of the source */
.fade {
opacity:0 !important;
}
/* for the after stage of the quote.*/
.executed {
opacity:1;
right: 0;
-webkit-transition: all 2s ease-in-out;
-moz-transition: all 2s ease-in-out;
-o-transition: all 2s ease-in-out;
transition: all 2s ease-in-out;
}
/* for the before stage of the quote; should slide right when presented and left when removed. */
.reset {
opacity:0;
right:600;
-webkit-transition: all 1s ease-in-out;
-moz-transition: all 1s ease-in-out;
-o-transition: all 1s ease-in-out;
transition: all 1s ease-in-out;
}
/* for the instructions at the bottom */
.bottom {
bottom:10;
position: absolute;
color:#454545;
font-family:Inconsolata;
}
Now that we’ve styled our app, we need to implement the true function of it. Let’s go ahead and do that.
To get the quotes, we need to call the Quotes API when the spacebar is pressed. Luckily, JQuery implements a window function just for that, known as keypress. To understand what to write, we have to go through what is happening in our site at that point. The current quote being displayed will be removed and we will request for a new one. When it returns from the API, we will display it.
http://quotesondesign.com/wp-json/posts?filter[orderby]=rand&filter[posts_per_page]=1&_jsonp=mycallback
and we can use some pretty simple AJAX (a way to send post/get requests) to retrieve the quote from the API. more on AJAXVoila! May this be useful when you are lacking inspiration:
$(window).keypress(function(e) {
if (e.which === 32) {
$("#quote").addClass("reset");
$("#quote").removeClass("executed");
$("#writer").toggleClass("fade");
setTimeout(function(){
$.ajax({
crossOrigin: true,
url: "https://quotesondesign.com/wp-json/posts?filter[orderby]=
rand&filter[posts_per_page]=1&_jsonp=mycallback",
dataType:"jsonp"
});
}, 1000);
}
});
function mycallback(json){
var quote = json[0];
$("#quote").html(quote.content)
$("#writer").html(quote.title)
$("#quote").addClass("executed");
$("#quote").removeClass("reset");
$("#writer").toggleClass("fade");
}
Your API is super powerful! Try making the site responsive and changing up the style. Try making other apps using JSON APIs like a weather app!


As Managing Member of Dotslash Designs LLC, Cari specializes in Web development and provides consulting services related to Systems, Networks, and Databases.
Cari develops web pages using the following languages:
Thanks for visiting! Contact Cari via Twitter @twenty4coins or GitHub at 24coins.


How much do we pay?
Have you ever wondered how much we're paying to landlord every year?
| Boroughs | Rent Ratio |
| City of London | 36.36% |
| Barking and Dagenham | 29.17% |
| Barnet | 35.58% |
| Bexley | 24.63% |
| Brent | 40.55% |
| Bromley | 24.42% |
| Camden | 42.91% |
| Croydon | 25.12% |
| Ealing | 31.68% |
| Enfield | 30.70% |
| Greenwich | 27.96% |
| Hackney | 38.18% |
| Hammersmith and Fulham | 39.96% |
| Haringey | 33.53% |
| Harrow | 30.27% |
| Havering | 24.95% |
| Boroughs | Rent Ratio |
| Hillingdon | 26.35% |
| Hounslow | 32.53% |
| Islington | 34.76% |
| Kensington and Chelsea | 47.00% |
| Kingston upon Thames | 20.79% |
| Lambeth | 35.35% |
| Lewisham | 27.95% |
| Merton | 29.70% |
| Newham | 31.85% |
| Redbridge | 25.28% |
| Richmond upon Thames | 31.50% |
| Southwark | 34.92% |
| Sutton | 25.62% |
| Tower Hamlets | 32.44% |
| Waltham Forest | 28.54% |
| Wandsworth | 28.70% |
| Westminster | 43.19% |
About
@ThomasMarks
Data viz hack was put together @makeshifts 'Hack, Play Learn' weekend.


The Evolving Definition of Unit Testing
Back in the day a unit test was defined as something like:
"[a] test that exercises a single class in isolation of all others"
The really big shake up in unit testing came with the development of JUnit and it's clones. This made it a requirement that unit tests should be automated and repeatable. Along with the introduction of JUnit some developers actually started writing unit tests, rather than just reading about them in books. The operational definition of unit testing shifted to:
“tests that are run against a project using a unit testing framework”
After all, if your using a unit test framework, what your writing must be a unit test - surely?. The requirement for a test of a single class was relaxed. What mattered was that the test was automated and repeatable.
Now lots of people have attempted unit testing, and some have succeeded. But many, or I suspect most, have failed. It's just a hard skill to acquire. It's rock hard for a novice unit tester to apply unit testing to an existing code base - the code's just not testable. Even on a virgin code base it's difficult. You can easily have large chunks of the system which you don't know how to test.
The thing which makes unit testing difficult is external dependencies. The points where your code starts to talk to something else - the boundaries of the system. Examples of external dependencies are:
- Database
- Smtp client
- Network
- Active directory
- Creating a process
- Web services
- File system
- HttpContext
- Message queues
- Windows registry
- Calling outside the CLR
- Calling outside the current AppDomain
The problem with external dependencies is, you have to configure them prior to the test, and verify them after the test. This set-up and verification is difficult - it makes the tests hard to write and harder still to understand. It also makes the tests slow. This lead Michael Feathers adopted the hard line position:
A test is not a unit test if:
- It talks to the database
- It communicates across the network
- It touches the file system
- It can't run at the same time as any of your other unit tests
- You have to do special things to your environment (such as editing config files) to run it.
So just having automated tests isn't good enough. To make unit testing work well, during the test you must replace the external dependency somehow. What you need to do is replace the dependency with an in-memory object which is easy to set-up and verify - a stub (or mock or fake or dummy). But how? You must talk to your dependency via an interface, then during testing you can replace the real implementation, with the stub/mock/fake/dummy version.
Just think about that for a moment. To make unit testing work you have to change the design of the system, so that all external dependencies are accessed via an interface. You have to change the architecture of the system, to make testing possible. That's really quite shocking.
All this leads to my current definition of unit testing:
Unit test - an automated test, without external dependencies. Integration test - an automated test, with external dependencies.
The aim is to test all of the business logic within unit tests. The integration tests are necessary and important, but their scope is limited to testing the interfaces to the external dependency. Integration tests need not test business logic too. The unit and integration tests are separated, say into different projects. This means you can run the fast unit test frequently. The slower integration test are run less often - say when you know you've changed the interface or prior to check-in. It is not a strict requirement that the unit test covers only a single class, though in practice if your test covers too much it will be hard to understand.
You can see with the definitions of unit testing described here, the cultural relativism implicit in the definition we use. What you think unit testing is depends on whether you actually write any, the tools you use, and how good you are at it.


UCome - Your Content Management
::Login::
::Voir::
::Edit::
::Directory::
::Edit directory::
Questions or Comments? Advice for me or from me? Please
email me.
Firstname
Lastname
Tel. 1
Tel. 2
Tel. 3
Fax
Mail
Password
UCome - Created by
Free&ALter Soft
Look closely adapted from
OSWD
Sliqua design shareright © 2002 Phlash


There is NO personal data stored on ethers.io servers. If you lose this file or forget your password, it is IMPOSSIBLE to recover your account. If you share this file and your password, stolen funds CANNOT be recovered. Keep this file and your password safe!
Please select your backup wallet by clicking below, or dragging it into this window from your downloads.
This tool allows you to send or transfer ether to other accounts or to contracts.
Are you sure you wish to send this transaction? Transactions cannot be reversed.
| Amount | Ξ (estimating transaction fee) |
|---|---|
| From Account: | |
| To Address: | |
| Data: |
Please wait while your transaction is propagating on the Ethereum network.


Please refer to the errata for this document, which may include some normative corrections.
See also translations.
Copyright © 2009 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.
The Protocol for Web Description Resources (POWDER) facilitates the publication of descriptions of multiple resources such as all those available from a Web site. This document describes how sets of IRIs can be defined such that descriptions or other data can be applied to the resources obtained by dereferencing IRIs that are elements of the set. IRI sets are defined as XML elements with relatively loose operational semantics. This is underpinned by the formal semantics of POWDER which include a semantic extension, defined separately. A GRDDL transform is associated with the POWDER namespace that maps the operational to the formal semantics.
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 is a W3C Recommendation that was developed by the POWDER Working Group.
Please see the Working Group's implementation report and Disposition of Last Call Comments. The disposition of comments received during previous calls are also available. Changes since the previous version of this document are minor in nature and are fully documented in the Change log.
Publication of this Recommendation is synchronized with several other documents:
The W3C Membership and other interested parties are invited to review the document and send comments to<EMAIL_ADDRESS>(with public archive).
This document has been reviewed by W3C Members, by software developers, and by other W3C groups and interested parties, and is endorsed by the Director as a W3C Recommendation. It is a stable document and may be used as reference material or cited from another document. W3C's role in making the Recommendation is to draw attention to the specification and to promote its widespread deployment. This enhances the functionality and interoperability of the Web.
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.
includeregex
The Protocol for Web Description Resources (POWDER) facilitates the publication of descriptions of multiple resources such as all those available from a Web site. These descriptions are attributable to a named individual, organization or entity that may or may not be the creator of the described resources. This contrasts with more usual metadata that typically apply to a single resource, such as a specific document's title, which is usually provided by its author.
Description Resources (DRs) are described separately [DR]. This document sets out how groups (i.e. sets) of resources may be defined, either for use in DRs or in other contexts. Set theory has been used throughout as it provides a well-defined framework that leads to unambiguous definitions. However, it is used solely to provide a formal version of what is written in the natural language text.
POWDER uses a limited set of XML elements to define sets of resources and these have relatively loose semantics. However, a GRDDL [GRDDL] transform is associated with the POWDER root namespace through which formal semantics are accessible as RDF/OWL. This is known as Semantic POWDER or POWDER-S. The details of the GRDDL transform and the formal semantics are defined separately [FORMAL] and outlined in Section 1.4 below. The use cases, a primer, test suite and schema namespace documents complete the document set.
The POWDER schema namespace is http://www.w3.org/2007/05/powder#
for which we use the prefix wdr
. The POWDER-S namespace is http://www.w3.org/2007/05/powder-s#
for which we use the prefix wdrs
and All namespaces and prefixes used in this document are shown in the table below.
| Prefix | Namespace |
|---|---|
wdr |
http://www.w3.org/2007/05/powder# |
wdrs |
http://www.w3.org/2007/05/powder-s# |
rdf |
http://www.w3.org/1999/02/22-rdf-syntax-ns# |
rdfs |
http://www.w3.org/2000/01/rdf-schema#" |
owl |
http://www.w3.org/2002/07/owl# |
xsd |
http://www.w3.org/2001/XMLSchema |
ex |
An arbitrary prefix used to denote an 'example vocabulary' |
In this document, the words MUST, MUST NOT, SHOULD, SHOULD NOT and MAY are to be interpreted as described in RFC 2119 [RFC2119].
POWDER makes substantial use of XML, the processing rules for which MUST be followed faithfully. The processing rules for attribute-value normalization are particularly relevant when considering the white space separated lists of values that occur in POWDER. A space-separated list is a string of which the items are separated by one or more space characters (in any order). The string may also be prefixed or suffixed with zero or more of those characters. To obtain the values from a space-separated list user agents MUST replace any sequence of space characters with a single #x20 character, dropping any leading or trailing #x20 character, and then chopping the resulting string at each occurrence of a #x20 character, dropping that character in the process.
The (unqualified) terms POWDER, POWDER Document and Description Resource (DR) refer to operational representations and semantics. The term POWDER-S refers to documents and data that express the formal semantics of POWDER. Unqualified XML element names are in the POWDER (wdr
) namespace
In designing a system to define sets of resources we have drawn on earlier work [Rabin] carried out in the Web Content Label Incubator Activity [WCL-XG], and taken into account the following considerations.
Operationally, POWDER does not define resource sets, rather, it facilitates the definition of sets of IRIs (International Resource Identifiers) [IRIS], which can be used to denote resources in terms of their identifiers. We use the notion of IRIs instead of URIs[URIS] since IRIs are a superset of URIs. Therefore, an IRI set definition may denote a set of IRIs as well as a set of URIs.
Defining a resource set by specifying the characteristics that the identifiers of resources in the set share is clearly an indirect approach, albeit a very useful one in the real world. In a logical sense, the definition must be interpreted to arrive at the full set.
More formally, an IRI Set definition D denotes a set of IRIs IS = DI, where DI is the interpretation of D, i.e., the set of IRIs sharing the characteristics denoted by D.
We take this further and allow an IRI set definition to be built up in stages.
An IRI set IS is denoted by an IRI set definition DIS in terms of one or more characteristics that the elements of the set have in common. Each characteristic is expressed by an IRI constraint C, and IRI constraints C1, C2, … Cn give rise to IRI set definitions D, 1, D2, … Dn, so that the complete IRI set definition DIS comprises D1, D2, … Dn.
The IRI set IS is the intersection of the IRI sets denoted by the IRI set definitions in DIS.
Formally:
IS = DISI = D1I ∩ D2I ∩ … ∩ DnI = (D1 ∧ D2 ∧ … ∧ Dn)I.
For example, suppose that an IRI set IS is denoted by the following definitions:
example.org
”/foo
“Then, DIS will be defined as follows: “the top level components of the host component of the IRI exactly match example.org
” AND “the path component of the IRI begins with /foo
.”
Whether the IRI of a specific resource R, known as the candidate resource, is a member of IRI Set IS or not is determined by comparing its characteristics with those denoted by the set definitions used in DIS. It must be an element of the intersection of the sets defined by the interpretation of D1, D2, …, Dn to be an element of IS.
If an IRI set definition contains no constraints, then its interpretation is by definition the empty set ∅. Formally:
Let IS be an IRI Set, and let DIS be the set of IRI Set definitions denoting the IRIs in IS: if DIS = ∅, then IS = ∅.
The POWDER XML schema [WDR] defines the set of XML elements and attributes to be used for enforcing the operational semantics of an IRI set definition.
More precisely, we define an XML element iriset
to take the place of the IRI set, and its child elements denote the set of IRI constraints C1, C2, …, Cn. The example reported in the previous section can therefore be written as follows:
<iriset> <includehosts>example.org</includehosts> <includepathstartswith>/foo</includepathstartswith> </iriset>
The operational semantics described above are underpinned by formal semantics. A GRDDL [GRDDL] transform
is associated with the POWDER namespace that allows the XML data to be rendered and processed as RDF/OWL with one important
proviso — that a semantic extension is understood. Defined fully in the Formal Semantics document
[FORMAL], this allows a candidate resource's IRI to be matched against regular expressions that are values
of an OWL data type property wdrs:matchesregex
(or wdrs:notmatchesregex
in
the case of patterns that are to be excluded). An OWL class takes the place of the IRI set
and resources whose IRIs match all the property restrictions defined using wdrs:matchesregex
and wdrs:notmatchesregex
are
instances of that class. The regular expression syntax used is defined by XML schema as modified by XQuery 1.0 and
XPath 2.0 Functions and Operators [XQXP].
As shown in Example 1-1 above, the POWDER XML elements generally take strings as values. These are converted into regular expressions as a first step in the GRDDL transform which renders POWDER documents in an intermediate format known as POWDER-BASE. It is POWDER-BASE that is then transformed into POWDER-S. For clarity, this two-stage process is not referred to in the main section of this document on defining a resource set which only presents POWDER and POWDER-S examples. POWDER-BASE is, however, an important part of the extension mechanism of POWDER Resource Grouping. The Formal Semantics document gives full details of the transformation of all elements of POWDER documents to POWDER-BASE and POWDER-S.
The result of the GRDDL transformation on Example 1-1 above is shown below.
<owl:Class rdf:nodeID="iriset_1"> <owl:equivalentClass> <owl:Class> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">(([^\/\?\#]*)\@)?([^\:\/\?\#\@]+\.)?(example\.org)(:([0-9]+))?\/</owl:hasValue> </owl:Restriction> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">(([^\/\?\#]*)\@)?([^\:\/\?\#\@]*)(\:([0-9]+))?(\/foo)</owl:hasValue> </owl:Restriction> </owl:intersectionOf> </owl:Class> </owl:equivalentClass> </owl:Class>
A Resource Set is defined in terms of the IRIs of resources that are its members. Determining whether a candidate resource is, or is not, a member of the set, can therefore be done by comparing its IRI with the data in the set definition. Importantly, defining the Resource Set in terms of IRIs allows us to verify whether the candidate resource is in the set without having to fetch and parse it, or perform a DNS lookup, thus maximizing processing efficiency in many environments.
We define a range of methods to support set definition by IRI, and provide support for methods defined in other Recommendations.
The syntax of an IRI, as defined in RFC 3987 [IRIS], provides a generic framework for identification schemes that goes beyond what is demanded by the POWDER use cases [USECASES]. We therefore limit our work to IRIs with the syntax: scheme://iuser@ihost:port/ipath?iquery#ifragment
, as shown below:
http://jdoe@www.example.com:1234/example1/example2?query=help#fragment \ / \ / \ / \ /\ / \ / \ / -- -- ------------- -- ---------------- -------- ------ | | | | | | | scheme iuser ihost port ipath iquery ifragment info
The following Regular Expression, elaborated from that offered in RFC 3986 [Rabin], provides a means of splitting both URIs and IRIs of this type into their component parts.
^(([^:/?#]+):)?(//((([^/?#]*)@)?([^/?#:]*)(:([^/?#]*))?))?([^?#]*)(\?([^#]*))?(#(.*))?
If the IRI of the candidate resource is valid, this yields the components as shown in Table 2 (strings that are not valid IRIs will inevitably lead to unpredictable results).
| Component | RE variable |
|---|---|
scheme | $2 |
iuserinfo | $6 |
ihost | $7 |
port | $9 |
ipath | $10 |
iquery | $12 |
ifragment | $14 |
For the scheme, ihost, port, ipath, and iquery IRI components we define corresponding IRI constraints, the value of most of which is a white space-separated list of strings, any one of which must match the relevant portion of the IRI of the candidate resource. The exceptions are the iquery and ihost components, which we discuss further in sections 2.1.2 and 2.1.3.
The iuserinfo and ifragment components are not used in POWDER IRI set definitions directly as it is felt that these may add a layer of unnecessary complexity with few practical applications. That said, it is important not to discard these components when processing the candidate resource's IRI. Furthermore, IRI sets may be defined using additional vocabularies as set out in Section 3. That extension method, or the use of the includeregex
and excluderegex
properties (see Section 2.3 below), means that user info and fragments can be used in IRI set definitions if required.
Formally, an IRI set definition D is expressed by one or more IRI constraints of the form C = IRI_component_matches(?x, {string1 | string2 | … | stringn}), where ?x is a variable denoting the IRI component under consideration, and {string1 | string2 | … | stringn} denotes a set consisting either of string string1 OR string2 OR … OR stringn.
Any number of IRI constraints C1, C2, …, Cn can be declared, and, as stated in Section 1.2, the overall IRI set is the intersection of the sets that can be interpreted from IRI set definitions corresponding to Cn. With some exceptions, each particular IRI constraint can only appear 0 or 1 times.
Strings are matched according to one of four rules:
startsWith
, meaning that the IRI component starts with any of the strings listed in the value of the relevant IRI constraint;endsWith
, meaning that the IRI component ends with any of the strings listed in the value of the relevant IRI constraint;exact
, meaning that there is an exact match between the candidate IRI component and at least one of the strings listed in the value of the relevant IRI constraint;contains
, meaning that at least one of the strings listed in the value of the relevant IRI constraint appears somewhere in the IRI component.Recognizing the great diversity of potential uses and set definition requirements, multiple IRI constraints are defined relating to the path component. Furthermore, for each constraint there is a ‘negative’ constraint, that is, a constraint whose value is a list of strings that must not be present in the relevant IRI component.
| IRI constraint | IRI component | Matching rule | Negative constraint |
|---|---|---|---|
includeschemes |
scheme |
exact |
excludeschemes |
includehosts |
ihost |
endsWith |
excludehosts |
includeexactpaths |
ipath |
exact |
excludeexactpaths |
includepathcontains † |
contains |
excludepathcontains |
|
includepathstartswith |
startsWith |
excludepathstartswith |
|
includepathendswith |
endsWith |
excludepathendswith |
|
includeports |
port |
exact |
excludeports |
includepathcontains
may appear any number of times within an IRI set definition, so that it is easy to create one in which multiple strings must be present in paths. This is in contrast to all other terms in Table 3 which can only occur 0 or 1 times, since the IRI of a candidate resource can only have one scheme, one host etc.As a quick example, the set of all resources on example.org
, whether fetched using specifically http
or https
, where the path component of their IRIs starts with foo
, and where the path does not end with .png
or .jpg
is defined thus:
<iriset> <includeSchemes>http https</includeSchemes> <includeHosts>example.org</includeHosts> <includePathStartsWith>/foo</includePathStartsWith> <excludePathEndsWith>.png .jpg</excludePathEndsWith> </iriset>
As outlined in Section 1.4, the POWDER GRDDL transform maps the IRI constraints in Table 3 to regular expressions against which the candidate IRI can be matched. These are shown in Table 4 below where var means the value of the XML element following processing as set out in the formal semantics document [FORMAL]. In brief this turns white space separated lists of strings into alternative values within the regular expression such that:
<includehosts>example.org example.com </includehosts>
becomes
(example\.org|example\.com)
.
| IRI Constraint ( include / exclude …) |
Regular Expression |
|---|---|
schemes |
^ var\:\/\/ |
hosts |
\:\/\/(([^\/\?\#]*)\@)?([^\:\/\?\#\@]+\.)? var(\:([0-9]+))?\/ |
ports |
\:\/\/(([^\/\?\#]*)\@)?([^\:\/\?\#\@]+\.)*[^\:\/\?\#\@]+\:var\/ |
exactpaths |
\:\/\/(([^\/\?\#]*)\@)?([^\:\/\?\#\@]*)(\:([0-9]+))? var($|\?|\#) |
pathcontains |
\:\/\/(([^\/\?\#]*)\@)?([^\:\/\?\#\@]*)(\:([0-9]+))?\/[^\?\#]* var[^\?\#]*[\?\#]? |
pathstartswith |
\:\/\/(([^\/\?\#]*)\@)?([^\:\/\?\#\@]*)(\:([0-9]+))? var |
pathendswith |
\:\/\/(([^\/\?\#]*)\@)?([^\:\/\?\#\@]*)(\:([0-9]+))?\/[^\?\#]* var($|\?|\#) |
These template regular expressions may be useful in processing POWDER documents directly but other methods of determining whether a candidate IRI does or does not match a particular constraint are equally valid.
Example 2-2 below uses the regular expressions from Table 4 in the POWDER-S version of Example 2-1.
1 <owl:Class rdf:nodeID="iriset_1"> 2 <owl:equivalentClass> 3 <owl:Class> 4 <owl:intersectionOf rdf:parseType="Collection"> 5 <owl:Restriction> 6 <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> 7 <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">^(http|https)\:\/\/</owl:hasValue> 8 </owl:Restriction> 9 <owl:Restriction> 10 <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> 11 <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">(([^\/\?\#]*)\@)?([^\:\/\?\#\@]+\.)?(example\.org)(:([0-9]+))?\/</owl:hasValue> 12 </owl:Restriction> 13 <owl:Restriction> 14 <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> 15 <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">(([^\/\?\#]*)\@)?([^\:\/\?\#\@]*)(\:([0-9]+))?(\/foo)</owl:hasValue> 16 </owl:Restriction> 17 <owl:Restriction> 18 <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#notmatchesregex" /> 19 <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">(([^\/\?\#]*)\@)?([^\:\/\?\#\@]*)(\:([0-9]+))?\/[^\?\#]*(\.png|\.jpg)($|\?|\#)</owl:hasValue> 20 </owl:Restriction> 21 </owl:intersectionOf> 22 </owl:Class> 23 </owl:equivalentClass> 24 </owl:Class>
Note the use of notmatchesregex
in line 18 to encode the excludepathendswith
element.
includeports
and excludeports
Although ports are clearly integers, POWDER treats them as a string in the same way as the other constraints in Table 3. Port ranges (such as 80-100) are not supported but note that the value of includeports
and excludeports
is a white space separated list so that multiple ports may be enumerated.
includequerycontains
and excludequerycontains
Query strings typically contain a series of name-value pairs separated by ampersands thus:
?name1=value1&name2=value2
These are usually acted on by the server to generate content in real time and the order of the name-value pairs is unimportant. For practical purposes ?name1=value1&name2=value2
is equivalent to ?name2=value2&name1=value1
. As a result, a significant amount of processing must be done to determine whether or not a candidate IRI is or is not an element of an IRI set that includes either the includequerycontains
or excludequerycontains
IRI Constraints.
To keep such processing manageable, the includequerycontains
and excludequerycontains
IRI Constraints take a single value not a white space separated list of values. Including two or more
name/value pairs in an includequerycontains
or excludequerycontains
means that all those
pairs must be present in the query string for the candidate IRI to be a member of the set.
Section 2.6 includes a further discussion on creating unions of multiple IRI sets
where it is necessary to create a set defined in terms of alternative name/value pairs.
By default, the POWDER GRDDL transform assumes that the delimiting character in a query string is the ampersand (&
). However, an alternative delimiter can be specified as the value for the delimiter
attribute on includequerycontains
and excludequerycontains
constraints. Example 2-3 below shows this.
<iriset> <includehosts>socialnetwork.example.com</includehosts> <includequerycontains delimiter=",">id=abcdef,group=12345</includequerycontains> </iriset>
The GRDDL transform splits the value provided for the includequerycontains
or excludequerycontains
IRI Constraints into its constituent pairs at the delimiting character and the presence of each name-value pair within the candidate IRI is then tested for independently. The template regular expression for such a test is:
\:\/\/(([^\/\?\#]*)\@)?([^\:\/\?\#\@]*)(\:([0-9]+))?\/[^\?\#]*\?([^\#]*d)?q(d|$)
Where d is the delimiting character and q is the name-value pair. The Formal Semantics document [FORMAL] sets this out in more detail.
An important consequence of this processing model is that within the query string, only complete name-value pairs or value-less parameters are matched. More precisely, only complete query conjuncts in the query string are matched. As complete query conjuncts we consider any minimal substring of the query string that has ?
or d before the first character and d or $
after the last character, where, as in the template regular expression, d is the query delimiter and $
is the end-of-string.
If the value of includequerycontains in Example 2-3 were changed to simply abcdef
(rather than id=abcdef,group=12345
) then:
http://socialnetwork.example.com/?group=12345,id=abcdef
would not match, even though the query does contain the string abcdef
http://socialnetwork.example.com/?abcdef
would match.http://socialnetwork.example.com/?abcdef=ijklm
would not matchAgain, a POWDER processor may use alternative methods to determine whether a given name-value pair is present in a candidate IRI but the template regular expression is used in the GRDDL transform to generate the POWDER-S shown in Example 2-4. Notice that the pre-processing described here allows POWDER-S to use the same restriction on the wdrs:matchesregex
data property as the other elements in Table 3.
<owl:Class rdf:nodeID="iriset_1"> <owl:equivalentClass> <owl:Class> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">(([^\/\?\#]*)\@)?([^\:\/\?\#\@]+\.)?(socialnetwork\.example\.com)(:([0-9]+))?\/</owl:hasValue> </owl:Restriction> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">(([^\/\?\#]*)\@)?([^\:\/\?\#\@]*)(\:([0-9]+))?\/[^\?\#]*\?([^\#]*,)?id=abcdef(,|$)</owl:hasValue> </owl:Restriction> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">(([^\/\?\#]*)\@)?([^\:\/\?\#\@]*)(\:([0-9]+))?\/[^\?\#]*\?([^\#]*,)?id=abcdef(,|$)</owl:hasValue> </owl:Restriction> </owl:intersectionOf> </owl:Class> </owl:equivalentClass> </owl:Class>
includehosts/excludehosts
Equivalence of internationalized domain names is defined in terms of ASCII case insensitive
comparison of the output of the ToASCII
operation (section 2 of [RFC 3490]).
If a regular expression is constructed to match the ihost component of an IRI, then it MUST be constructed to match the ASCII representation of that component.
Specifically, to generate a regular expression from an includehosts
or excludehosts
constraint,
the value of each space separated token under the ToASCII
operation, with the
UseSTD3ASCIIRules
flag unset and the AllowUnassigned
flag set, MUST
be used. [RFC 3490]. Behavior if the ToASCII
operation fails is undefined.
When internationalized (non-ASCII) domain names appear in the values of the includehosts
and excludehosts
constraints, they SHOULD be represented either as the output of a successful
ToASCII
operation, or as a string of Unicode characters that is mapped to itself when the
ToASCII
and ToUnicode
operations are successfully applied, in this order.
(Note, in particular, that behavior for these strings is well-defined, since the ToASCII
operation must succeed by definition.)
Before determining whether an IRI is or is not a member of a given set, it is important to make sure that the IRI is represented in the same way as the data against which it is being matched. We set out below a series of steps that are designed to help processors make a best effort in this regard, which are consistent with RFC 3986 [URIS], RFC 3987 [IRIS] and URISpace [URISpace].
%c3%a7
becomes ç
etc.). Note the hexadecimal digits are case-insensitive.
However space characters (%20) and reserved characters as per Section 2.2 of RFC 3986 [URIS]
must not be converted to literals, as that may invalidate the URI/IRI - the reason a URI would contain
(for example) %2F
instead of /
would be to distinguish between a literal /
,
such as in 'his/hers', and the /
which is used as a path separator.| Input IRI/URI | Canonical form |
|---|---|
http://example.com/staff/Fran%c3%a7ois |
http://www.example.com/staff/François |
http://example.com/my%20doc.doc |
http://www.example.com/my doc.doc |
In this next example the %2F is a literal slash, not a path separator, and so is left as %2F |
|
http://www.example.com/foo/his%2Fhers |
http://www.example.com/foo/his%2Fhers |
authority
is present, but the scheme
is absent, the scheme
should default to http
.path
is absent, a path
of /
is appended..
characters in the host
are removed, i.e. http://www.example.com./
becomes http://www.example.com/
ToASCII
operation to the host
string, with the UseSTD3ASCIIRules
flag unset and
the AllowUnassigned
flag set [RFC 3490].
Note that behavior if the ToASCII
operation fails is undefined.scheme
and host
strings to ASCII lowercase.port
is specified, but it is the default port for the scheme, it is removed.The following table gives some examples.
| Input IRI | Canonical form |
|---|---|
www.example.com | http://www.example.com/ |
http://www.example.com | http://www.example.com/ |
HTTPS://WWW.EXAMPLE.COM/FOO | https://www.example.com/FOO |
http://www.example.com./foo | http://www.example.com/foo |
http://www.example.com:80/foo | http://www.example.com/foo |
http://sigmaσ.example.org/ | http://xn--sigma-kde.example.org |
To complement the IRI canonicalization steps described in the previous section, related processing steps must also be carried out on the strings supplied as set defining data. The following steps should therefore be applied to each item in the list separately.
host
, trailing .
characters are removed.host
, and does not completely consist of ASCII characters,
the ToASCII
operation is applied as described in Section 2.1.3scheme
or host
, it is normalized to
ASCII lower case.includepathstartswith
, excludepathstartswith
, includeexactpaths
or excludeexactpaths
must begin with the /
character which is pre-pended if absent.If the IRI set definition includes values related to the port
then matching of the data against the candidate resource's IRI must be carried out as follows:
includeports
then, when matching, if the default port for the candidate resource's IRI is present in the list of supplied values, but the candidate resource's IRI does not specify the port, the candidate resource IS an element of the set IF all other conditions are met.excludeports
then, when matching, if the default port for the candidate resource's IRI is present in the list of supplied values, but the candidate resource's IRI does not specify the port, the candidate resource is NOT an element of the IRI Set.includeiripattern
and excludeiripattern
IRI constraintsIt is anticipated that resource groups will typically be defined in terms of the
domains and sub domains from which they are available. In order to provide as much flexibility as possible
in this regard, the includeiripattern
and
excludeiripattern
properties allow domains and sub-domains
to be substituted by a wildcard character (*) according to the following EBNF:
iri-pattern ::= (scheme "://")? domain-pattern (":" port)? | "*" domain-pattern ::= domain | "*." domain
scheme
and port
are used as defined in
RFC 3986 [URIS]. domain
is an internationalized
domain name as defined in RFC 3490 [RFC3490].
It follows that:
<includehosts>example.com</includehosts>
and
<includeiripattern>example.com</includeiripattern>
are equivalent. However, *.example.com
, meaning resources on sub-domains of example.com
but not on example.com
itself, is not a valid value for includehosts
.
In contrast to the IRI constraints shown in Table 3, includeiripattern
and excludeiripattern
take a single pattern, not a white space separated list of values. Note that paths and query strings MUST NOT be included in the pattern. If these are required in an IRI set definition, the relevant IRI constraints from Table 3 can be used.
Any processing method that accurately tests a candidate IRI against the value of an includeiripattern
or
excludeiripattern
element is valid but the POWDER GRDDL transform does it in the same way as the other
IRI constraints, namely by creating a restriction on the
wdrs:matchesregex
and wdrs:notmatchesregex
properties as shown
in the example below. Full details of the transformation are provided in the Formal Semantics
document [FORMAL] however it is worth noting here once again that
if a regular expression is constructed to match the host
component of an IRI, then
it MUST be constructed to match the ASCII representation of that component.
POWDER
<iriset> <includeiripattern>http://example.org</includeiripattern> <excludeiripattern>search.example.com:81</excludeiripattern> </iriset>
POWDER-S
<owl:Class rdf:nodeID="iriset_1">
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<owl:Restriction>
<owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" />
<owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">^http\:\/\/([^\:\/\?\#\@]+\.)+example.org(\:[0-9]+)?</owl:hasValue>
</owl:Restriction>
<owl:Restriction>
<owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#notmatchesregex" />
<owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">^[A-Za-z]+\:\/\/([^\:\/\?\#\@]+\.)*search.example.com\:81</owl:hasValue>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
includeregex
and excluderegex
IRI constraintsIt is believed that the IRI constraints discussed above will be easy to use and cover the overwhelming
majority of POWDER use cases. However, the use of strings with fixed matching rules clearly presents a restriction
on flexibility. To support fully flexible set definition by IRI, the
includeregex
and excluderegex
properties take a Regular Expression and should be applied to the candidate resource's complete IRI (after following
the canonicalization steps above and ensuring that regular expressions are
constructed using the ASCII representation of IRI components related to the host
as
discussed in Section 2.1.3). In common with
includepathcontains
and excludepathcontains
, and unlike the other IRI constraints,
includeregex
and excluderegex
may occur any number of times in an IRI set. This
follows from the GRDDL transformation associated with POWDER introduced in
Section 1.4. The same section notes that the regular expression
syntax used is that defined by XML schema as modified by XQuery 1.0 and XPath 2.0 Functions and
Operators [XQXP].
For POWDER-S, the regular expressions are copied verbatim as values
for the wdrs:matchesregex
and wdrs:notmatchesregex
properties.
N.B. The value of the includeregex
and excluderegex
properties MUST be a single Regular Expression, not a white space-separated list.
As an example, the set of all the resources hosted either by example.org
or example.net
, where the path component of their IRIs starts either with foo
or bar
, can be defined thus:
POWDER:
<iriset> <includeregex>^(([^:/?#]+):)//([^:/?#]+.)?example.(org|net)/(foo|bar)</includeregex> </iriset>
POWDER-S:
<owl:Class rdf:nodeID="iriset_1"> <owl:equivalentClass> <owl:Class> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">^(([^:/?#]+):)//([^:/?#]+.)?example.(org|net)/(foo|bar)</owl:hasValue> </owl:Restriction> </owl:intersectionOf> </owl:Class> </owl:equivalentClass> </owl:Class>
It is important to note that Example 2-6 does not take account of the need to escape certain characters.
The following characters are used as meta characters in regular expressions and MUST therefore be escaped if used in a pattern given as the value of the includeregex
property:
. \ ? * + { } ( ) [ ]
In addition, the < (less than) and & (ampersand) characters MUST always be escaped to < and & as per the XML specification [XML].
As a safeguard against unintended consequences, other characters that always or typically have special meaning within IRI strings and/or XML SHOULD also be escaped, namely:
! " # % ' , - / : ; = > @ [ ] _ ` ~
As a result, Example 2-6 should properly be written as shown in Example 2-7 below.
POWDER:
<iriset> <includeregex>^(([^\:\/\?\#]+)\:)//([^\:\/\?\#]+\.)?example\.(org|net)/(foo|bar)</includeregex> </iriset>
POWDER-S:
<owl:Class rdf:nodeID="iriset_1"> <owl:equivalentClass> <owl:Class> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">^(([^\:\/\?\#]+)\:)//([^\:\/\?\#]+\.)?example\.(org|net)/(foo|bar)</owl:hasValue> </owl:Restriction> </owl:intersectionOf> </owl:Class> </owl:equivalentClass> </owl:Class>
includeregex
Example 2-7 uses a modified version of the regular expression given Section 2.1. This is the safest method but is not, perhaps, the most natural way to proceed. If a less rigorous approach is taken it is easy to make mistakes when specifying regular expressions, and incorrect regular expressions in set definitions will have one of two possible (and obvious) consequences
Example 2-8 below shows how this can happen.
<iriset> <includehosts>example.org</includehosts> <includeregex>https</includeregex> </iriset>
The intention of the regular expression given in Example 2-8 is probably to say "all resources on
example.org
with a URI beginning with https
." However, as the regular expression is not
anchored at either end, what this actually means is "all resources on example.org
where the URI
includes https
". Thus this IRI set includes both of:
https://www.example.org/page.html
http://www.example.org/why_we_use_https.html
Adding in anchors at the beginning and end of the regular expression can have equally undesirable consequences.
<iriset> <includehosts>example.org</includehosts> <includeregex>^https$</includeregex> </iriset>
In Example 2-9, the intention is, again probably, to define the set of "all resources on example.org
fetched using https
only". However, adding both the ^
and $
anchors at the beginning and end of the regular expression means that the whole IRI must be https
from start to finish — which can never be true so this IRI set is equivalent to the empty set.
Example 2-10 shows one possible way to encode the intended set definition.
<iriset> <includehosts>example.org</includehosts> <includeregex>^https</includeregex> </iriset>
Whilst Example 2-10 'works', the potential dangers of using regular expressions mean that it is generally better to use component strings where possible. Example 2-10 is therefore better written as shown in Example 2-11 below.
<iriset> <includehosts>example.org</includehosts> <includeschemes>https</includeschemes> </iriset>
It is noteworthy that POWDER does not define any special procedures where the host component of an IRI is expressed as an IP address. These are treated as strings, not as a sequence of digits. If the intention is to define an IRI set that encompasses a particular group of resources however they are accessed then it may be appropriate to include both the domain name and associated IP address as two space separated values in an includehosts
element for example. However, this assumes that there is a one to one relationship between the domain name and the IP address which, of course, is often not the case.
As noted in Section 1.2, POWDER defines sets of IRIs, not of the resources that they identify. IRI sets must therefore be defined with care. For operational reasons, a user agent MAY perform a DNS or reverse DNS lookup to match domains names and IP addresses but this is very much application-specific.
includeresources
and excluderesources
ConstraintsIt is useful to be able to include or exclude IRIs from sets by simple listing. The includeresources
and excluderesources
constraints support this, both of which take white space separated lists of IRIs. To give a simple example, the set of all resources on example.org
except its stylesheet and JavaScript library can be encoded as shown in Example 2-12 below.
<iriset> <includehosts>example.org</includehosts> <excluderesources>http://www.example.org/stylesheet.css http://www.example.org/jslib.js</excluderesources> </iriset>
The white space separated list of values is processed as set out in the Formal Semantics document [FORMAL] to create a pattern var that can be inserted into the simple template regular expression:
^var$
Thus Example 2-12 is transformed into the following POWDER-S.
<owl:Class rdf:nodeID="iriset_1"> <owl:equivalentClass> <owl:Class> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">(([^\/\?\#]*)\@)?([^\:\/\?\#\@]+\.)?(example\.org)(:([0-9]+))?\/</owl:hasValue> </owl:Restriction> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#notmatchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">^(http\:\/\/www\.example\.org\/stylesheet\.css|http\:\/\/www\.example\.org\/jslib\.js)$</owl:hasValue> </owl:Restriction> </owl:intersectionOf> </owl:Class> </owl:equivalentClass> </owl:Class>
As emphasized throughout this document, each constraint and its value creates a set definition of its own and the full IRI set is the intersection of those sets. Thus an alternative way of looking at Example 2-12 is to say that a candidate IRI is a member of the IRI set IF it is on example.org
AND does not have the IRI http://www.example.org/stylesheet.css
AND does not have the IRI http://www.example.org/jslib.js
.
POWDER allows a DR to express any grouping of resources whatsoever, no matter how complex.
Atomic negation is achieved by complementing each IRI constraint that includes certain IRI
components by one that excludes them, and vice versa; furthermore, all includeX
and excludeX
constraints
are mutually exclusive. The analogous properties matchesregex
and notmatchesregex
properties are used in POWDER-S. Negation of complex constraints is not supported.
Conjunction of atomic propositions (both positive and negative) is inherent in the basic model - an IRI must match all the constraints if it is to be an element of the set. The GRDDL transform uses owl:intersectionOf
to render in POWDER-S iriset
elements with multiple constraints.
The disjunction of conjunctions of atomic propositions (both positive and negative) is also possible, as a DR may contain multiple iriset
elements, and if any of them holds, then the DR holds. The GRDDL transform encodes multiple iriset
elements as multiple clauses in POWDER-S.
It follows from the above, that POWDER allows the expression of Disjunctive Normal Form propositions. Since arbitrarily complex propositions can be brought into DNF (DNF Theorem), it follows that POWDER allows the expression of any proposition.
Example 2-14 shows a Description Resource defining the set of IRIs on example.com with a path beginning with /foo and those on example.org where the path starts with /bar.
<?xml version="1.0"?> <powder xmlns="http://www.w3.org/2007/05/powder#" xmlns:ex="http://example.org/vocab#"> <attribution> <issuedby src="http://authority.example.org/company.rdf#me" /> <issued>2007-12-14T00:00:00</issued> </attribution> <dr> <iriset> <includehosts>example.com</includehosts> <includepathstartswith>/foo</includepathstartswith> </iriset> <iriset> <includehosts>example.org</includehosts> <includepathstartswith>/bar</includepathstartswith> </iriset> <descriptorset> <ex:color>red</ex:color> <ex:shape>square</ex:shape> <displaytext>Everything on example.com where the path starts with /foo and everything on example.org where the path starts with /bar is red and square</displaytext> <displayicon>http://example.org/icon.png</displayicon> </descriptorset> </dr> </powder>
In this document we have specified various methods for defining sets of resource identifiers. The elements are clearly designed to be used with information resources available on the Web, identified by IRIs containing host names, directory paths, port numbers, and so on. The POWDER grouping vocabulary can be easily extended by new elements, defined via GRDDL transformation, which build upon the elements defined by POWDER. As examples, in Sections 3.1 and 3.2 we show how other methods of defining IRI sets that may suit particular situations can be transformed into POWDER-BASE.
Furthermore, there is no fundamental reason to constrain the domain of POWDER descriptions to HTTP IRIs, so there should not be unnecessary constraints on how the protocol works. In other words, the domain of grouping extensions does not need to be HTTP IRIs, but may be any kind of IRIs. As an example, in Section 3.3 we show such an extension for ISAN numbers.
It should be noted that the treatment of non-HTTP IRIs is one of the basic motivations behind the two-step GRDDL transform from POWDER to POWDER-BASE to POWDER-S, outlined in
Section 1.4 and fully specified in the Formal Semantics document [FORMAL]. If POWDER were rendered into POWDER-S in a single direct transform, the only XML language from which to derive extensions would be POWDER, which would oblige POWDER extensions to include HTTP-specific IRI restrictions such as includehosts
, even if they are meaningless for the domain of the extension.
In the intermediate POWDER-BASE language, on the other hand, all HTTP-specific elements have been rendered as regular expressions, using the includeregex
and excluderegex
IRI restrictions, as POWDER-BASE only requires that these two restrictions are supported. Developers of non-HTTP extensions and tools are advised to use POWDER-BASE to derive their extension from, instead of POWDER, as this relieves them of the obligation to also implement the HTTP-specific IRI restrictions in their tools.
XML elements suitable for defining sets of URIs or IRIs from schemes other than HTTP may be created
and a GRDDL transform defined that renders such IRI sets in POWDER-BASE. This is an generic extension mechanism since a conformant POWDER Processor, as defined in the Description Resources document [DR], MUST be able to process POWDER-BASE. For clarity: POWDER-BASE is not a separate encoding of POWDER — it is all done in the wdr
namespace — merely a restricted form of POWDER that just has the two possible child elements of iriset
.
Developers of POWDER tools MAY directly implement extensions they know about, and MAY include support for transformation technologies such as XSLT so that unknown extensions can be processed.
As an example of a service-specific extension, consider a service which uses unix shell wildcards instead of regular expressions, so that www.example.org/*
means "all the resources on www.example.org fetched using HTTP." Such a system is easily used within an IRI set, only requiring the definition of a near copy of the POWDER schema [WDR] with a single IRI constraint shell:includepattern
as child element of its IRI set element (good practice when defining shell:includepattern
would be to also define shell:excludepattern
).
A publisher of a document using shell:includepattern
SHOULD define a GRDDL transform
that will generate a POWDER-BASE document as shown the example below.
Custom IRI pattern:
<shell:iriset> <shell:includepattern>www.example.org/*</shell:includepattern> </shell:iriset>
POWDER-BASE:
<iriset> <includeregex>http\:\/\/www\.example\.org\/.*</includeregex> </iriset>
Note that the custom IRI pattern SHOULD NOT be used in a document with its root element in the POWDER namespace since the only valid child elements of the iriset
element within a POWDER document are those defined in this document.
Many content providers serve dynamic content stored in a database, so that IRIs express queries to that database. This kind of IRI will have certain structure but this is typically neither obvious nor easily human-interpreted.
As an example, consider sport.example.com
, a sports news site, where IRIs look like the one shown in Example 3-2. The adopted scheme is systematic so that sport=2&countryID=16
provides a front page with news about Greek basketball and links to various Greek basketball leagues, sport=3&countryID=16
a front page about Greek volleyball, etc.
http://sport.example.com/matches.asp?sport=1&countryID=16&champID=2
A POWDER document providing metadata about this Web site would have to use regular expression matching with explicit reference to the numerical values in the country
and sport
fields of the query. This process is error-prone, and requires extensive changes if the underlying database schema is modified or extended.
As an alternative, the site developer may provide a POWDER-like scheme that abstracts away from the specific database fields to allow reference to sports and countries, as shown in Example 3-3. Description Resource authors can then use the properties in this extension to generate POWDER-BASE documents that are valid even if the site schema is modified, as long as the site developer updates the relevant transformations.
Custom IRI constraint:
<sport:iriset> <wdr:includehosts>sport.example.com</wdr:includehosts> <sport:countries>Greece</sport:countries> <sport:sports>Football Basketball</sport:sports> </sport:iriset>
Corresponding POWDER-BASE IRI set:
<iriset> <includeregex>(([^\/\?\#]*)\@)?([^\:\/\?\#\@]+\.)?(sport\.example\.com)(:([0-9]+))?\/</includeregex> <includeregex>country=16</includeregex> <includeregex>sport=[1|2]</includeregex> </iriset>
The International Standard Audiovisual Number [ISAN1] is a globally-unique, centrally managed and permanent numbering system for the identification of audiovisual works and versions. Following ISO 15706 [ISAN3], [ISAN3-2], the ISAN numbers are written as 24 bit hexadecimal digits in the following format [ISAN2].
-----root----- |
episode |
-version- |
||||
ISAN |
1881-66C7-3420 |
- |
0000 |
-7- |
9F3A-0245 |
-U |
The root segment of an ISAN number is assigned to a core work. When the core work is a serial, episodes are identified with a non null episode segment. Versions are assigned in the version segment and refer to changes in the audiovisual content, being a different language or soundtrack, subtitles, editions, promotional trailers, and so on.
Since ISAN numbers are URNs [URN], and hence IRIs of the urn:
scheme [URIS], a vocabulary can readily be defined to allow IRI Sets to be defined based on ISAN numbers. The terms might be along the lines of:
includeRoots
— the value of which would be a white space separated of hexadecimal digits and hyphens that would be matched against the first three blocks in the ISAN number.
includeEpisodes
— a white space separated list of hexadecimal digits and hyphens that would be matched against the 4th block of 4 digits in the ISAN number.
includeVersions
— a white space separated list of hexadecimal digits and hyphens that would be matched against the 5th and 6th blocks of 4 digits in the ISAN number.
The set of all audio visual resources that relate to two particular works might then be defined as shown in Example 3-4.
Custom ISAN pattern:
<ex_isan:iriset> <ex_isan:includeRoots>1881-66C7-3420 1881-66C7-3421</ex_isan:includeRoots> </ex_isan:iriset>
Corresponding POWDER-BASE IRI Set:
<iriset> <includeregex>^urn:isan:(1881-66C7-3420)|(1881-66C7-3421)</includeregex> </iriset>
An IRI set definition is a Conformant IRI set definition if it adheres to the specification described in this document.
More precisely:
The editors duly acknowledge the earlier work in this area carried out by Jo Rabin. Jeremy Carroll and David Booth developed the operational and formal semantics model which was further developed by Stasinos Konstantopoulos. Eric Prud'hommeaux, Addison Phillips and Thomas Roessler made significant contributions to the development of the canonicalization section. The editors gratefully acknowledge the further contributions made by Régis Flad of ISANIA and members of the POWDER Working Group.
Changes since the 3 April 2009 draft are as follows:
| Element Name | Content | Attributes | Cardinality | Introduced |
|---|---|---|---|---|
iriset |
Any of
includeschemes ,
excludeschemes ,
includehosts ,
excludehosts ,
includeexactpaths ,
excludeexactpaths ,
includepathcontains ,
excludepathcontains ,
includepathstartswith ,
excludepathstartswith ,
includepathendswith ,
excludepathendswith ,
includeports ,
excludeports
|
At least 1 must be a child element of a dr |
Section 1.3 | |
includeschemes |
Token list | 0 or 1 | Section 2.1 | |
excludeschemes |
||||
includehosts |
||||
excludehosts |
||||
includeexactpaths |
||||
excludeexactpaths |
||||
includepathcontains |
Token list | any number | ||
excludepathcontains |
||||
includepathstartswith |
Token list | 0 or 1 | ||
excludepathstartswith |
||||
includepathendswith |
||||
excludepathendswith |
||||
includeports |
||||
excludeports |
||||
includequerycontains |
Single value | delimiter (any single character). Default value is: & (“ampersand”) |
0 or 1 | Section 2.1.2 |
excludequerycontains |
||||
includeiripattern |
Single value | 0 or 1 | Section 2.2 | |
excludeiripattern |
||||
includeregex |
Single value | Any number | Section 2.3 | |
excluderegex |
||||
includeresources |
Token list | 0 or 1 | Section 2.5 | |
excluderesources |


# The following comment should be removed at some point in the future. # mypy: strict-optional=False from __future__ import absolute_import import os import sys from pip._internal.utils.typing import MYPY_CHECK_RUNNING if MYPY_CHECK_RUNNING: from typing import Optional, Tuple def glibc_version_string(): # type: () -> Optional[str] "Returns glibc version string, or None if not using glibc." return glibc_version_string_confstr() or glibc_version_string_ctypes() def glibc_version_string_confstr(): # type: () -> Optional[str] "Primary implementation of glibc_version_string using os.confstr." # os.confstr is quite a bit faster than ctypes.DLL. It's also less likely # to be broken or missing. This strategy is used in the standard library # platform module: # https://github.com/python/cpython/blob/fcf1d003bf4f0100c9d0921ff3d70e1127ca1b71/Lib/platform.py#L175-L183 if sys.platform == "win32": return None try: # os.confstr("CS_GNU_LIBC_VERSION") returns a string like "glibc 2.17": _, version = os.confstr("CS_GNU_LIBC_VERSION").split() except (AttributeError, OSError, ValueError): # os.confstr() or CS_GNU_LIBC_VERSION not available (or a bad value)... return None return version def glibc_version_string_ctypes(): # type: () -> Optional[str] "Fallback implementation of glibc_version_string using ctypes." try: import ctypes except ImportError: return None # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen # manpage says, "If filename is NULL, then the returned handle is for the # main program". This way we can let the linker do the work to figure out # which libc our process is actually using. process_namespace = ctypes.CDLL(None) try: gnu_get_libc_version = process_namespace.gnu_get_libc_version except AttributeError: # Symbol doesn't exist -> therefore, we are not linked to # glibc. return None # Call gnu_get_libc_version, which returns a string like "2.5" gnu_get_libc_version.restype = ctypes.c_char_p version_str = gnu_get_libc_version() # py2 / py3 compatibility: if not isinstance(version_str, str): version_str = version_str.decode("ascii") return version_str # platform.libc_ver regularly returns completely nonsensical glibc # versions. E.g. on my computer, platform says: # # ~$ python2.7 -c 'import platform; print(platform.libc_ver())' # ('glibc', '2.7') # ~$ python3.5 -c 'import platform; print(platform.libc_ver())' # ('glibc', '2.9') # # But the truth is: # # ~$ ldd --version # ldd (Debian GLIBC 2.22-11) 2.22 # # This is unfortunate, because it means that the linehaul data on libc # versions that was generated by pip 8.1.2 and earlier is useless and # misleading. Solution: instead of using platform, use our code that actually # works. def libc_ver(): # type: () -> Tuple[str, str] """Try to determine the glibc version Returns a tuple of strings (lib, version) which default to empty strings in case the lookup fails. """ glibc_version = glibc_version_string() if glibc_version is None: return ("", "") else: return ("glibc", glibc_version)


{% extends "base.html" %} {% block title %}{{ _('Unsupported Two Factor Authentication Method') }} — {{ service_name }}{% endblock %} {% block content %}
{{ _('The two factor authentication method set up for your account is currently unsupported. Please contact an administrator.', contact_email=contact_email, service_name=service_name) }}
{% endblock %}


--- layout: post status: publish published: true title: Tennessee Smokies Release 2014 Roster author: display_name: Corey Fineran login: Corey email<EMAIL_ADDRESS>url: '' author_login: Corey author_email<EMAIL_ADDRESS>wordpress_id: 9480 wordpress_url: http://ivyenvy.com/?p=9480 date: '2014-04-01 08:33:00 +0000' date_gmt: '2014-04-01 13:33:00 +0000' categories: - Minor Leagues tags: [] comments: - id: 10505 author: Joshua Waltsak author_email: '' author_url: '' date: '2014-04-01 09:39:03 +0000' date_gmt: '2014-04-01 14:39:03 +0000' content: Are the Smokies one of the Cubs farm teams? - id: 10506 author: Ivy Envy author_email: '' author_url: '' date: '2014-04-01 10:36:30 +0000' date_gmt: '2014-04-01 15:36:30 +0000' content: Joshua Waltsak - Yes Double-A. - id: 10507 author: Doug Green author_email: '' author_url: '' date: '2014-04-01 11:09:51 +0000' date_gmt: '2014-04-01 16:09:51 +0000' content: I want to go, but 10 hours one way is too far. - id: 10508 author: Joshua Waltsak author_email: '' author_url: '' date: '2014-04-01 12:19:29 +0000' date_gmt: '2014-04-01 17:19:29 +0000' content: Any good players on the Smokies? - id: 10509 author: Taylor Krebs author_email: '' author_url: '' date: '2014-04-01 14:19:35 +0000' date_gmt: '2014-04-01 19:19:35 +0000' content: CJ Edwards, Kris Bryant, and Jorge Soler. The Cubs are coming! ---
The Tennessee Smokies may be the hottest ticket in minor league baseball in 2014. The Minor League Report is a podcast that covers MiLB and they recently ranked the Iowa Cubs and the Tennessee Smokies in top 5 when they ranked their top teams in MiLB. Iowa was #1 and Tennessee was #5. While Javier Baez plays a huge role in Iowa being ranked #1, I believe Tennessee is potentially a more interesting team than even Iowa.
Tennessee will start with 3 of the top 5 Cubs prospects in the system, according to Baseball America. Kris Bryant (#2 Cubs/#8 overall), CJ Edwards (#3 Cubs/#28 overall) and Jorge Soler (#5 Cubs/#41 overall) will start 2014 in Tennessee. When you also consider that three more prospects in the Cubs top 10 could move up to Tennessee from Daytona (Almora, Candelario and Vogelbach), I think Tennessee is the hottest ticket in MiLB in 2014.
Tennessee has released their initial roster and here it is:
Pitchers
Corey Black
Lendy Castillo
Hunter Cervenka
CJ Edwards
PJ Francescon
Matt Loosen
Jeff Lorick
Ivan Pineyro
Dae-Eun Rhee
Armando Rivero
Ryan Searle
Tony Zych
Catchers
Charles Cutler
Rafael Lopez
Infielders
Stephen Bruno
Kris Bryant
Wes Darvill
Dustin Geiger
Jonathan Mota
Jeudy Valdez
Outfielders
John Andreoli
Zeke DeVoss
Rubi Silva
Jorge Soler


|
Documentation Use this option to view the documentation. Learn More… |
||
|
Community Communicate with other users. Have a look into the community forum. Learn More… |
||
|
Video Tutorials Learn essential modding skills with the video tutorials. More… |
||
|
Downloads Download the latest editor, exporter plugins and tools. Learn More… |
||
|
Newsletter Subscribe to the GIANTS Developer Network newsletter. Learn More… |


Crypto Tests
Testing ...
MingKeMing Tests
Testing ...
DaoKeDao Tests
Testing ...
Core Tests
Testing ...
Plugins Tests
Testing ...
SDK Tests
Testing ...
Makefile


{{ template "layout.html" . }} {{ define "css" }} {{ end}} {{ define "content" }}
| # | Name | Description | Action | |
|---|---|---|---|---|
| {{$thirdPartyApplicationKey}} | {{$thirdPartyApplication.Name}} | {{$thirdPartyApplication.Description}} |
{{ str2html $thirdPartyApplication.HiddenTagGuiRepositoryThirdPartyLaunch }}
Launch
{{ str2html $thirdPartyApplication.HiddenTagGuiRepositoryThirdPartyEdit }}
Update
{{ str2html $thirdPartyApplication.HiddenTagGuiRepositoryThirdPartyDelete }}
|


Here you will find an assorted collection of my thoughts and experiences in developing my bioinformatics skillset. Feel free to browse in a chronological order here, or by category given on the right.
I am always interested in career and collaborative opportunities. Please see my Contact/CV page for my information.


| {{asset.patientId}} |
{{asset.typeOfInsurance}} |
{{asset.provider}} |
{{asset.plan_name}} |
{{asset.policy_number}} |
{{asset.group_number}} |
{{asset.subscriber_lname}} |
{{asset.subscriber_mname}} |
{{asset.subscriber_fname}} |
{{asset.subscriber_relationship}} |
{{asset.subscriber_ss}} |
{{asset.subscriber_DOB}} |
{{asset.subscriber_street}} |
{{asset.subscriber_postal_code}} |
{{asset.subscriber_city}} |
{{asset.subscriber_state}} |
{{asset.subscriber_country}} |
{{asset.subscriber_phone}} |
{{asset.subscriber_employer}} |
{{asset.subscriber_employer_street}} |
{{asset.subscriber_employer_postal_code}} |
{{asset.subscriber_employer_state}} |
{{asset.subscriber_employer_country}} |
{{asset.subscriber_employer_city}} |
{{asset.copay}} |
{{asset.date}} |
{{asset.subscriber_sex}} |
{{asset.accept_assignment}} |
|


My name is Benson and I'm always hungry. I'm a total mama's boy and my favorite food is nachos.
My name is Benson and I like to party.
I like to take naps and eat things I steal from the counter.


FUS without menu?
-
Scott G
Is it possible to use the WinSwitch software without a menu? I like the hot key to bring up the login window. Is there a way to activate the login window with FUS or WinSwitch menus?
-
Greg Hurrell
I've copied your request into the bug tracking and feature request database (feature requests tend to get buried and lost in the forums):
https://wincent.com/a/support/bugs/show_bug.cgi?id=256
Please add any additional comments to the database so as to keep all relevant material in the one place.
Reply
This topic is now closed.


Here is one of the reason's why my spare time for BBLog is limited :)
https://youtu.be/srFcBFqAvtI
Meaurk
Global Moderator
Holy shit, it looks really nice! You are forgiven for the lack of presence.
Make me one when you've completed the development, hehe!
 You are forgiven for the lack of presence.
Make me one when you've completed the development, hehe!
:) Thanks
ORFK
Global Moderator
TAKE MY MONEY, i want this table :-D awesome!
for which reason you don't work for google?! ;-) :-D
Topicstarter
BrainFooLong
Administrator
ORFK wrote:
TAKE MY MONEY, i want this table :-D awesome!
for which reason you don't work for google?! ;-) :-D
Thanks, i really appriciate that comment.
Krayziesoldier
Looks awesome man :)
Nano
Global Moderator
WOW! This is awesome!
But searching in internet, i found you discontinued that project.... :(
Don't do that! It's a thing who people pay for it!
Topicstarter
BrainFooLong
Administrator
Thanks, it has become an impossible project for a single person and i don't want to create a startup for this, simply because i'm not interested anymore.


query string parser for node supporting nesting, as it was removed from 0.3.x
, so this library provides the previous and commonly desired behaviour (and twice as fast). Used by express, connect and others.
$ npm install qs
var qs = require('qs');
qs.parse('user[name][first]=Tobi&user[email]=tobi@learnboost.com');
// => { user: { name: { first: 'Tobi' }, email<EMAIL_ADDRESS>} }
qs.stringify({ user: { name: 'Tobi', email<EMAIL_ADDRESS>}})
// => user[name]=Tobi&user[email]=tobi%40learnboost.com
Install dev dependencies:
$ npm install -d
and execute:
$ make test
(The MIT License)
Copyright (c) 2010 TJ Holowaychuk<EMAIL_ADDRESS>Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ‘Software’), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


Dynamic open address hash table
The dynamic table is a table that continuously changes its size dynamically. Upon insertion of new values in the table, the size increases as it occupies a space or slot and upon deletion of values the table size decreases as it frees the slots. The change in size of table is limited to a certain value which is the load factor of the table.
A load factor in a nonempty table is the ratio of number of the elements in a dynamic table divided by size of the dynamic table. The hash table is a data structure used to store, insert, delete and check certain elements in it. Here, the hash table is used in the practical implementation of the dynamic table.
The implementation of dynamic table by open addressing hash table is simply done where the new element, which is about to be inserted, is first checked whether it is really in the hash table or not or there is any unused space left. An actual cost is the cost of every operation alone and the amortized cost is the average cost of the total operations taken altogether. And our main concern should be of how to make the amortized cost.
 In this condition the search and various functions that are run through the hash tables, might even fail to run.The insertion action is taken along with the search function. This takes an average of times as it does a linear search. But they must have an amortized cost associated with it too. Using the amortized analysis, the amortized cost of insertion and deletion is only, even though the actual cost of an operation is larger, when it triggers an expansion or a contraction.
So, the actual cost is assumed to be; and this is the expected value per insertion.
The unused space in a dynamic table never exceeds a constant fraction of the total space.
The average cost per instruction is not, as the searching might check all the entries of the hash table to find the answer.
The number of elements after the operation is denoted by, and size is denoted by; and the potential for a particular state is denoted by. The recurrence relation of the potential function goes like this (consider the potential function (17.6) in the book):
During deletion there are the following possibilities:
1. The table size remains the same, which means that the table does not have to contract.
2. The table has to contract to half its value (assumed to the opposite of the insertion function where the table has to expand its size to double).
In the 1st case, the load factor will be greater than the half value of the table. Now we can see that after deletion, the, and.Thus putting the condition in terms of the potential function according to the recurrence relation:
After the operation:
Before the operation:
Since in the above casesand the table remains in a constant state not changing (in this case not contracting).
The actual cost of the deletion process as no transfer is done from one table to another for changing.
Therefore the amortized cost of the deletion operation where is
Another case, is if it causes a contraction, that is , then the amortized cost will be:
In contraction, the size of the table becomes half its original size, and so:
If we neglect the variable term , then the amortized cost of table delete operation is 2, which is maximum in the above two cases, so the table delete operation is bounded by 2, that is a constant.
Dynamic tables are the tables that can expand and contrast according to the data to be stored in the table to save the space in memory. This expansion and contraction of table depends on the load factor.
There is a constant bound on the load factor of the table and the amortized cost is also bounded with some constant. The potential function of the table depends on the load factor and is defined as (consider equation (17.6) in the textbook):
Consider the potential functions as:
There are two cases to discuss first are when the element is deleted from the table and the load factor is and the table is not contracted. Second is when the load factorthen the table size is contracted by multiplying it by.The amortized cost in these two cases is as:
Case 1: Whenthen the amortized cost for the table using actual cost 1 as:
Case 2: If the load factor is the size of table is contracted as:
In this case the actual cost of the deletion operation is.So, the amortized cost is as:
… … (1)
From the formula of load factor:
Putting the value of in the equation (1) as:
In Case 1 the amortized cost of the deletion operation is 3 while in Case 2 it is 2 using the potential function.
Hence, the amortized cost of TABLE-DELETE operation is bounded by a constant 3 as in case 1.


|
My Project
|
A 2-by-2 matrix. Stored in column-major order. More...
Public Member Functions | |
| Mat22 (Vector2 c1, Vector2 c2) | |
| Construct this matrix using columns. More... | |
| Mat22 (float a11, float a12, float a21, float a22) | |
| Construct this matrix using scalars. More... | |
| void | Set (Vector2 c1, Vector2 c2) |
| Initialize this matrix using columns. More... | |
| void | SetIdentity () |
| Set this to the identity matrix. More... | |
| void | SetZero () |
| Set this matrix to all zeros. More... | |
| Vector2 | Solve (Vector2 b) |
| Solve A * x = b, where b is a column vector. This is more efficient than computing the inverse in one-shot cases. More... | |
Static Public Member Functions | |
| static void | Add (ref Mat22 A, ref Mat22 B, out Mat22 R) |
Public Attributes | |
| Vector2 | ex |
| Vector2 | ey |
Properties | |
| Mat22 | Inverse [get] |
A 2-by-2 matrix. Stored in column-major order.
Construct this matrix using columns.
| c1 | The c1. |
| c2 | The c2. |
| tainicom.Aether.Physics2D.Common.Mat22.Mat22 | ( | float | a11, |
| float | a12, | ||
| float | a21, | ||
| float | a22 | ||
| ) |
Construct this matrix using scalars.
| a11 | The a11. |
| a12 | The a12. |
| a21 | The a21. |
| a22 | The a22. |
Initialize this matrix using columns.
| c1 | The c1. |
| c2 | The c2. |
| void tainicom.Aether.Physics2D.Common.Mat22.SetIdentity | ( | ) |
Set this to the identity matrix.
| void tainicom.Aether.Physics2D.Common.Mat22.SetZero | ( | ) |
Set this matrix to all zeros.
Solve A * x = b, where b is a column vector. This is more efficient than computing the inverse in one-shot cases.
| b | The b. |


Next improvement for my mill: Indicator Holder for the Z Axis. Of course full DRO would be better but thats also a huge thing to mount and takes up a lot of space. Also kind of expensive. So lets try to make something simple. Many people already have an indicator and this project presens a simple way to mount it on the Z Axis of Mills with dovetails.
What is needed is the angles and dimensions of the dovetail, and the diameter for the shaft of the indicator. This model is parameterized, you can just change the parameters and re-generate. I just chose 60 degrees because thats the only angle of dovetail cutters that i had around.
I accidentally put the dovetail off center by about 2 millimeters. Could have been prevented by measuring more and not getting impatient.


Education
2018
Electromagnetic Education Session at IEEE AEMC 2017 – A Report
Energy Conservation and Poynting Theorem in Electromagnetics: A Conceptual Perspective
A Global Vision for Academic Scholarship and Professional Development
2017
ENISo IoT Challenge
2014
Challenges for electromagnetics teaching and Education
Undergraduate Students’ Summer Training on Design, Fabrication, and Testing of Antennas a Case Study for Effective Learning
Project Based Undergraduate and Graduate Electromagnetics Education
Editors Introduction to Education Section
Present challenges and future directions of electromagnetics education
Comparing Electromagnetic Education in China, Hong Kong, and USA
Challenges in electromagnetics education design
Using web quizzes to assess concept understanding and pacing the students
Teaching Electromagnetics in the 21st Century
Computer-aided Teaching of Electromagnetics Is It for Real