This document is a preliminary draft of a specification for the Selection API and selection related functionality. It replaces a couple of old sections of the HTML specification, the selection part of the old DOM Range specification.
This document defines APIs for selection, which allows users and authors to select a portion of a document or specify a point of interest for copy, paste, and other editing operations.
This document was published by the Web Applications Working Group, any feedback or discussion of this specification should be posted to public-webapps mailing list with "[selection-api]" in the subject (archive).
This specification is based on the HTML Editing API specification edited by Aryeh Gregor and published by the W3C Editing APIs Community Group. Copyright © 2011-2014 the Contributors to the HTML Editing APIs Specification, published by the W3C Editing APIs Community Group under the W3C Community Contributor License Agreement (CLA).
IE9 and Firefox 6.0a2 allow arbitrary ranges in the selection, which follows what this spec originally said. However, this leads to unpleasant corner cases that authors, implementers, and spec writers all have to deal with, and they don't make any real sense. Chrome 14 dev and Opera 11.11 aggressively normalize selections, like not letting them lie inside empty elements and things like that, but this is also viewed as a bad idea, because it takes flexibility away from authors.
So I changed the spec to a made-up compromise that allows some simplification but doesn't constrain authors much. See discussion. Basically it would throw exceptions in some places to try to stop the selection from containing a range that had a boundary point other than an Element or Text node, or a boundary point that didn't descend from a Document.
But this meant getRangeAt() had to start returning a copy, not a reference. Also, it would be prone to things failing weirdly in corner cases. Perhaps most significantly, all sorts of problems might arise when DOM mutations transpire, like if a boundary point's node is removed from its parent and the mutation rules would place the new boundary point inside a non-Text/Element node. And finally, the previously-specified behavior had the advantage of matching two major implementations, while the new behavior matched no one. So I changed it back.
See bug 15470. IE9, Firefox 12.0a1, Chrome 17 dev, and Opera Next 12.00 alpha all make the range initially null.
Every document ([[DOM4]]) with
a browsing context ([[HTML5]])
has a unique Selection
object associated with it.
Selection objects are known as selections.
This is a requirement of the HTML spec. IE9 and Opera Next 12.00 alpha seem to follow it, while Firefox 12.0a1 and Chrome 17 dev seem not to. See Mozilla bug, WebKit bug.
This one selection must be shared by all the content of the document (though not by nested documents), including any editing hosts in the document. Editing hosts (defined in [[HTML5]]) that are not inside a document cannot have a selection
Each selection can be associated with a single range (defined in [[DOM4]]). When there is no range associated with the selection, the selection is empty. The selection must be initially empty.
A document's selection is a singleton object associated with that document,
so it gets replaced with a new object when Document.open()
is called.
See bug 15470.
IE9 and Opera Next 12.00 alpha allow the user to reset the range to null after the fact by clicking somewhere;
Firefox 12.0a1 and Chrome 17 dev do not.
We follow Gecko/WebKit, because it lessens the chance of getRangeAt(0) throwing.
Once a selection is associated with a given range, it must continue to be associated with that same range until this specification requires otherwise.
For instance, if the DOM changes in a way that changes the range's boundary points,
or a script modifies the boundary points of the range, the same range object must continue to be associated with the selection.
However, if the user changes the selection or a script calls addRange()
,
the selection must be associated with a new range object, as required elsewhere in this specification.
If the selection's range is not null and is collapsed ([[DOM4]]), then the caret position must be at that range's boundary point. When the selection is not empty, this specification does not define the caret position; user agents should follow platform conventions in deciding whether the caret is at the start of the selection, the end of the selection, or somewhere else.
This short-changes Mac users. See bug 13909.
Each selection has a direction, forwards, backwards, or directionless. If the user creates a selection by indicating first one boundary point of the range and then the other (such as by clicking on one point and dragging to another), and the first indicated boundary point is after ([[DOM4]]) the second, then the corresponding selection must initially be backwards. If the first indicated boundary point is before ([[DOM4]]) the second, then the corresponding selection must initially be forwards. Otherwise, it must be directionless.
Selections also have an anchor and a focus. If the selection's range is null, its anchor and focus are both null. If the selection's range is not null and its direction is forwards, its anchor is the range's start, and its focus is the end. Otherwise, its focus is the start and its anchor is the end.
The attribute must return the anchor node ([[DOM4]])
of the context object ([[DOM4]]),
or null
if the anchor is null.
The attribute must return the anchor offset ([[DOM4]])
of the context object, or 0
if the anchor is null.
The attribute must return the focus node of the context object,
or null
if the anchor is null.
The attribute must return the focus offset of the context object,
or 0
if the focus is null.
The attribute must return true if and only if the anchor and focus are the same (including if both are null). Otherwise it must return false.
The attribute must return 0
if the context object is empty,
and must return 1
otherwise.
The attribute must return "None"
if the context object is empty,
"Caret"
if the context object's range is collapsed,
and "Range"
otherwise.
The method must throw an IndexSizeError
([[DOM4]]) exception
if index is not 0
, or if the context object is empty.
Otherwise, it must return a reference to (not a copy of) the context object's range.
Thus subsequent calls of this method returns the same range object
if nothing has removed the context object's range in the meantime.
In particular, getSelection().getRangeAt(0) === getSelection().getRangeAt(0)
evaluates to true
if the selection is not empty.
IE9 and Firefox 4.0 return the same object every time, as the spec says. Chrome 12 dev and Opera 11.10 return a different object every time.
The method must set the context object's range to range by a strong reference (not by making a copy) if the root ([[DOM4]]) of the range's boundary points are the document associated with context object. Otherwise, this method must do nothing.
Since range is added by reference, subsequent calls to getRangeAt(0)
returns the same object,
and any changes that a script makes to range after it is added must be reflected in the selection,
until something else removes or replaces the context object's range.
In particular, the selection will contain b as opposed to a after running the following code:
var r = document.createRange(); r.selectNode(a); getSelection().addRange(r); r.selectNode(b);
IE9 and Firefox 4.0 store a reference, as described here. Chrome 12 dev and Opera 11.10 appear to store a copy, so changes don't affect the selection.
Chrome 15 dev seems to ignore addRange() if there's already a range. IE9 replaces the existing range. Firefox 9.0a2, of course, just gives you a multi-range selection. IE is likely to behave closest to Firefox, and is also more useful than silent failure, so the spec goes with that.
The method must make the context object empty by disassociating its range if the context object's range is range. Otherwise, it must do nothing.
The method must make the context object empty by disassociating its range if the context object has an associated range.
The method must be an alias, and behave identically, to removeAllRanges()
.
The method must follow these steps:
IndexSizeError
exception if offset is negative or longer than node's
length ([[DOM4]]) and abort these steps.The method must be an alias, and behave identically, to collapse()
.
The method must throw InvalidStateError
([[DOM4]]) exception
if the context object is empty.
Otherwise, it must create a new range, set both its start and end
to the start of the context object's range,
and then set the context object's range to the newly-created range.
For collapseToStart/End, IE9 mutates the existing range, while Firefox 9.0a2 and Chrome 15 dev replace it with a new one. The spec follows the majority and replaces it with a new one, leaving the old Range object unchanged.
The method must throw InvalidStateError
exception if the context object is empty.
Otherwise, it must create a new range, set both its start and end
to the end of the context object's range,
and then set the context object's range to the newly-created range.
The method must follow these steps:
InvalidStateError
exception and abort these steps.Reverse-engineered circa January 2011. IE doesn't support it, so I'm relying on Firefox (implemented extend() sometime before 2000) and WebKit (implemented extend() in 2007). I'm mostly ignoring Opera, because gsnedders tells me its implementation isn't compatible. Firefox 12.0a1 seems to mutate the existing range. IE9 doesn't support extend(), and it's impossible to tell whether Chrome 17 dev or Opera Next 12.00 alpha mutate or replace, because getRangeAt() returns a copy anyway. Nevertheless, I go against Gecko here, to be consistent with collapse().
The method must follow these steps:
IndexSizeError
exception and abort these steps.The method must follow these steps:
0
).Based mostly on Firefox 9.0a2. It has a bug that I didn't reproduce, namely that if you pass a Document as the argument, the end offset becomes 1 instead of the number of children it has. It also throws a RangeException instead of DOMException, because its implementation predated their merging.
IE9 behaves similarly but with glitches. It throws "Unspecified error." if the node is detached or display:none, and apparently in some random other cases too. It throws "Invalid argument." for detached comments (only!). Finally, if you pass it a comment, it seems to select the whole comment, unlike with text nodes.
Chrome 16 dev behaves as you'd expect given its Selection implementation. It refuses to select anything that's not visible, so it's almost always wrong. Opera 11.50 just does nothing in all my tests, as usual.
The new range replaces any existing one, doesn't mutate it. This matches IE9 and Firefox 12.0a1. (Chrome 17 dev and Opera Next 12.00 alpha can't be tested, because getRangeAt() returns a copy anyway.)
The method must invoke deleteContents()
([[DOM4]])
on the context object's range if the context object is not empty.
Otherwise the method must do nothing.
This is the one method that actually mutates the range instead of replacing it. This matches IE9 and Firefox 12.0a1. (Chrome 17 dev and Opera Next 12.00 alpha can't be tested, because getRangeAt() returns a copy anyway.)
The method must return false
if the context object is empty
or if node's root is not the document associated with the context object.
Otherwise, if allowPartialContainment is false
,
the method must return true
if and only if
start of its range is before or visually equivalent to
the first boundary point in the node
and end of its range is after or visually equivalent to
the last boundary point in the node.
If allowPartialContainment is true
,
the method must return true
if and only if
start of its range is before or visually equivalent to
the first boundary point in the node
or end of its range is after or visually equivalent to
the last boundary point in the node.
See also nsISelection.idl from Gecko. This spec doesn't have everything from there yet, in particular selectionLanguageChange() and containsNode() are missing. They are missing because I couldn't work out how to define them in terms of Ranges.
Originally, the Selection interface was a Netscape feature. The original implementation was carried on into Gecko (Firefox), and the feature was later implemented independently by other browser engines. The Netscape implementation always allowed multiple ranges in a single selection, for instance so the user could select a column of a table However, multi-range selections proved to be an unpleasant corner case that web developers didn't know about and even Gecko developers rarely handled correctly. Other browser engines never implemented the feature, and clamped selections to a single range in various incompatible fashions.
This specification follows non-Gecko engines in restricting selections to at most one range,
but the API was still originally designed for selections with arbitrary numbers of ranges.
This explains oddities like the coexistence of removeRange()
and removeAllRanges()
,
and a getRangeAt()
method that takes an integer argument that must always be zero.
All of the members of the Selection
interface are defined
in terms of operations on the range
object (if any) represented by the object.
These operations can raise exceptions, as defined for the Range
([[DOM4]]) interface;
this can therefore result in the members of the Selection
interface raising exceptions as well,
in addition to any explicitly called out below.
This specification extends several interfaces to provide entry points to the interfaces defined in this specification.
Document
interfaceThe method must return the selection associated with context object
if the context object has an associated browsing context,
and it must return null
otherwise.
If we create a Document object with no browsing context
(say via document.implementation.createHTMLDocument("") and call
getSelection() on it),
IE9 seems to return a different Selection object.
Firefox 12.0a1 and Opera Next 12.00 alpha return the same object as for the current window.
Chrome 17 dev returns null.
See discussion.
There's no meaningful selection associated with such a document, so we follow WebKit and require returning null
.
Window
interfaceThe method must invoke and return the result of getSelection()
on the context object's
document
([[HTML5]]) property.
The user agent should allow the user to change the selection associated with the active document (defined in [[HTML5]]). If the user makes any modification to a selection, the user agent must create a new range with suitable start and end of the range ([[DOM4]]) and associate the selection with this new range (not modify the existing range), and set update selection's direction to forwards if the start is before or equal to the end, backwards if if the end is before the start, or directionless if the start and the end cannot be ordered due to the platform convention.
The user agent must not make a selection empty if it was not already empty in response to any user actions (e.g. clicking on a non-editable region).
See bug 15470. IE9 and Opera Next 12.00 alpha allow the user to reset the range to null after the fact by clicking somewhere; Firefox 12.0a1 and Chrome 17 dev do not. I follow Gecko/WebKit, because it lessens the chance of getRangeAt(0) throwing.
selectstart
eventWhen the user agent is about to associate a new range newRange to the selection in response to a user initiated action,
the user agent must fire ([[DOM4]])
an event with the name selectstart
, which bubbles and is cancelable,
at the node associated with the boundary point of newRange's start
prior to changing the selection if the selection was previously empty
or the previously associated range was collapsed.
If the event is canceled, the user agent must not change the selection.
The user agent must not fire the event when the user agent sets the selection empty.
selectionchange
eventWhen the selection is changed either by the user or the content script,
the user agent must queue a task ([[HTML5]])
to fire an event with the name selectionchange
, which does not bubble and is not cancelable,
at the document associated with the selection.
Many thanks to
Aryeh Gregor, who is the original author of this specification as well as HTML Editing API specification.
Contributors to the HTML Editing API specification - Ehsan Akhgari, Tab Atkins, Mathias Bynens, Tim Down, Markus Ernst, Daniel Glazman, Tali Gregor (née Fuss), Stig Halvorsen, Jeff Harris, Ian Hickson, Cameron Heavon-Jones, Anne van Kesteren, Alfonso Martínez de Lizarrondo, Glenn Maynard, Ms2ger, Robert O'Callahan, Julie Parent, Simon Pieters, Michael A. Puls II, Rich Schwerdtfeger, Jonas Sicking, Henri Sivonen, Smylers, Hallvord R. M. Steen, Roland Steiner, Annie Sullivan, timeless, Ojan Vafai, Brett Zamir, and Boris Zbarsky for their feedback, participation, or other helpful contributions


No Observable Object
David Kanenwisher • May 5, 2020
swiftuiI ran into some trouble after I opened up the app I've been toying with in Xcode. The SwiftUI preview wouldn't render. I clicked "Diagnostics" and it said:
| Error Domain=com.apple.dt.ultraviolet.service Code=12 "Rendering service was interrupted" UserInfo={NSLocalizedDescription=Rendering service was interrupted}
I have no idea what the ultraviolet service is, what it means that the code is 12, and it seems pretty clear the "Rendering service was interrupted". I did manage to find some more information by looking real close.
Depending on the size of your screen, on mine it was rather small, there's a little "i" with a circle around after the crashed message. I clicked that then clicked "Show Crash Logs".
 I saw something I could understand:
Fatal error: No ObservableObject of type AppData found. A View.environmentObject(_:) for AppData may be missing as an ancestor of this view.: file SwiftUI, line 0
Thankfully, I'd recently gained a higher understanding of ObservableObjects plus AppData is a name of a variable in my project. Thankfully and reasonably, AppData is an ObservableObject. How do I know it's an ObservableObject? Why I made it implement ObservableObject protocol:
import SwiftUI
class AppData: ObservableObject {
@Published var imageCache = ImageCache()
}
So the fatal error seems to be telling me that AppData is missing from the current view. This was the preview for my ContentView so the first place I go is the SceneDelegate. It looks like that's passing AppData:
window.rootViewController = UIHostingController(rootView: contentView.environmentObject(appData))
"Ah but this is the preview!", I cry with a finger pointed firmly and vertically in the air.
I take a look at PreviewProvider in ContentView.
struct ContentView_Previews: PreviewProvider {
static var previews: some View {
ContentView()
}
}
"Well there's your problem" points out the surly mechanic in my head.
If you are like the surly mechanic in my head then you likely noticed that ContentView()
is bereft of a call to "environmentObject". This is the source of the fatal error reported earlier. A quick touch up and it's good to go:
struct ContentView_Previews: PreviewProvider {
static var previews: some View {
ContentView().environmentObject(AppData())
}
}
That did the trick! I can see my exceptional preview.
What hard to decipher error messages are you getting from SwiftUI? Let me know by dropping me a line on the contact page.


Scan this barcode with your Authenticator app.
Help protect your account. Use an app such as Google Authenticator to generate verification codes. Scan the image above with the two-factor authentication app on your phone. After scanning the barcode image, the app will display a six-digit code that you can enter below.


Home
Products
Accessories
Breadcrumbs 1 (6 elements)
...
label 1
label 2. A very very long one to truncate
label 3
label 4
label 5
label 6. A very very long one to truncate
Breadcrumbs 2 (8 elements)
...
label 1. A very very long one to truncate
label 2
label 3
label 4
label 5. A very very long one to truncate
label 6
label 7
label 8
Phone (2 elements, max-size:60px)
Tablet (4 elements, max-size:100px)
Desktop (6 elements, max-size:160px)
Breadcrumbs 1 (6 elements)
...
label 1
label 2. A very very long one to truncate
label 3
label 4
label 5
label 6. A very very long one to truncate
Breadcrumbs 2 (8 elements)
...
label 1. A very very long one to truncate
label 2
label 3
label 4
label 5. A very very long one to truncate
label 6
label 7
label 8
Phone (2 elements, max-size:60px)
Tablet (4 elements, max-size:100px)
Desktop (6 elements, max-size:160px)


Crayfish boat run aground near Kaikōura
by Environment CanterburyMEDIA STATEMENT
Crayfish boat run aground near Kaikōura
A small crayfish boat called the Ruff-Enuff has run aground near Goose Bay. The skipper and crew are on shore and safe.
The boat had about 600L of diesel on board and there is some in the water, however exact quantities are unknown. No affected wildlife has been observed. Oil spill responders from Kaikōura and Christchurch, along with the crew, salvors and insurance assessor, are on site and assessing the situation. Attempts will be made with a large excavator to remove the remaining fuel from the boat, as well as removing the boat entirely, at low tide this evening.
Environment Canterbury regional on-scene commander for oil spill response, Richard Purdon said, “The situation is under control, we have trained people onsite dealing with it and, given it is a very warm day and the light nature of the fuel, we are expecting it to evaporate quickly. Hopefully we can get the vessel out of the water this evening. We will remain onsite for a couple of days until it is all sorted.”
ENDS


--- layout: page title: About header-img: "img/about-bg.png" ---
I'm 34 years old. I usually like to work on a career which can satisfy my passion for learning and success


YAML Lint
Paste in your YAML and click "Go" - we'll tell you if it's valid or not, and give you a nice clean UTF-8 version of it. Optimized for Ruby.
Paste in your YAML and click "Go" - we'll tell you if it's valid or not, and give you a nice clean UTF-8 version of it. Optimized for Ruby.


ctags Internal API¶
Input text stream¶
Function prototypes for handling input text stream are declared in
main/read.h. The file exists in exuberant ctags, too. However, the
names functions are changed when overhauling --line-directive
option. (In addition macros were converted to functions for making
data structures for the input text stream opaque.)
Ctags has 3 groups of functions for handling input: input, bypass, and raw. Parser developers should use input group. The rest of two are for ctags main part.
inputFile type and the functions of input group¶
- (The original version of this sub sub sub section was written
before inputFile type and File variable are made private. )
inputFile is the type for representing the input file and stream for a parser. It was declared in main/read.h but now it is defined in main/read.c.
Ctags uses a file static variable File having type inputFile for maintaining the input file and stream. File is also defined in main/read.c as inputFile is.
fp and line are the essential fields of File. fp having type well known MIO declared in main/mio.h. By calling functions of input group (getcFromInputFile and readLineFromInputFile), a parser gets input text from fp.
The functions of input group updates fields input and source of File These two fields has type inputFileInfo. These two fields are for mainly tracking the name of file and the current line number. Usually ctags uses only input field. source is used only when #line directive is found in the current input text stream.
A case when a tool generates the input file from another file, a tool can record the original source file to the generated file with using the #line directive. source is used for tracking/recording the information appeared on #line directives.
Regex pattern matching are also done behind calling the functions of this group.
The functions of bypass group¶
The functions of bypass group (readLineFromBypass and readLineFromBypassSlow) are used for reading text from fp field of File static variable without updating input and source fields of File.
Parsers may not need the functions of this group. The functions are used in ctags main part. The functions are used to make pattern fields of tags file, for example.
The functions of raw group¶
The functions of this group(readLineRaw and readLineRawWithNoSeek) take a parameter having type MIO; and don’t touch File static variable.
Parsers may not need the functions of this group. The functions are used in ctags main part. The functions are used to load option files, for example.
promise API¶
(Currently the tagging via promise API is disabled by default. Use --extras=+g option for enabling it.)
Background and Idea¶
More than one programming languages can be used in one input text stream. promise API allows a host parser running a guest parser in the specified area of input text stream.
e.g. Code written in c language (C code) is embedded in code written in Yacc language (Yacc code). Let’s think about this input stream.
/* foo.y */
%token
END_OF_FILE 0
ERROR 255
BELL 1
%{
/* C language */
int counter;
%}
%right EQUALS
%left PLUS MINUS
...
%%
CfgFile : CfgEntryList
{ InterpretConfigs($1); }
;
...
%%
int
yyerror(char *s)
{
(void)fprintf(stderr,"%s: line %d of %s\n",s,lineNum,
(scanFile?scanFile:"(unknown)"));
if (scanStr)
(void)fprintf(stderr,"last scanned symbol is: %s\n",scanStr);
return 1;
}
In the input the area started from %{ to %} and the area started from the second %% to the end of file are written in C. Yacc can be called host language, and C can be called guest language.
Ctags may choose the Yacc parser for the input. However, the parser doesn’t know about C syntax. Implementing C parser in the Yacc parser is one of approach. However, ctags has already C parser. The Yacc parser should utilize the existing C parser. The promise API allows this.
More examples are in Applying a parser to specified areas of input file.
Usage¶
See a commit titled with “Yacc: run C parser in the areas where code is written in C”. I applied promise API to the Yacc parser.
The parser for host language must track and record the start and the end of a guest language. Pairs of line number and byte offset represents the start and end. When the start and end are fixed, call makePromise with (1) the guest parser name, (2) start, and (3) end. (This description is a bit simplified the real usage.)
Let’s see the actual code from parsers/yacc.c.
struct cStart {
unsigned long input;
unsigned long source;
};
Both fields are for recording start. input field is for recording the value returned from getInputLineNumber. source is for getSourceLineNumber. See inputFile for the difference of the two.
enter_c_prologue shown in the next is a function called when %{ is found in the current input text stream. Remember, in yacc syntax, %{ is a marker of C code area.
static void enter_c_prologue (const char *line CTAGS_ATTR_UNUSED,
const regexMatch *matches CTAGS_ATTR_UNUSED,
unsigned int count CTAGS_ATTR_UNUSED,
void *data)
{
struct cStart *cstart = data;
readLineFromInputFile ();
cstart->input = getInputLineNumber ();
cstart->source = getSourceLineNumber ();
}
The function just records the start line. It calls readLineFromInputFile because the C code may start the next line of the line where the marker is.
leave_c_prologue shown in the next is a function called when %}, the end marker of C code area is found in the current input text stream.
static void leave_c_prologue (const char *line CTAGS_ATTR_UNUSED,
const regexMatch *matches CTAGS_ATTR_UNUSED,
unsigned int count CTAGS_ATTR_UNUSED,
void *data)
{
struct cStart *cstart = data;
unsigned long c_end;
c_end = getInputLineNumber ();
makePromise ("C", cstart->input, 0, c_end, 0, cstart->source);
}
After recording the line number of the end of the C code area, leave_c_prologue calls makePromise.
Of course “C” stands for C language, the name of guest parser. Available parser names can be listed by running ctags with --list-languages option. In this example two 0 characters are provided as the 3rd and 5th argument. They are byte offsets of the start and the end of the C language area from the beginning of the line which is 0 in this case. In general, the guest language’s section does not have to start at the beginning of the line in which case the two offsets have to be provided. Compilers reading the input character by character can obtain the current offset by calling getInputLineOffset().
Internal design¶
A host parser cannot run a guest parser directly. What the host parser can do is just asking the ctags main part scheduling of running the guest parser for specified area which defined with the start and end. These scheduling requests are called promises.
After running the host parser, before closing the input stream, the ctags main part checks the existence of promise(s). If there is, the main part makes a sub input stream and run the guest parser specified in the promise. The sub input stream is made from the original input stream by narrowing as requested in the promise. The main part iterates the above process till there is no promise.
Theoretically a guest parser can be nested; it can make a promise. The level 2 guest is also just scheduled. (However, I have never tested such a nested guest parser).
Why not running the guest parser directly from the context of the host parser? Remember many parsers have their own file static variables. If a parser is called from the parser, the variables may be crashed.
Automatic parser guessing¶
Managing regular expression parsers¶
Parser written in C¶
tokenInfo API¶
In Exuberant-ctags, a developer can write a parser anyway; only input stream and tagEntryInfo data structure is given.
However, while maintaining Universal-ctags I (Masatake YAMATO) think we should have a framework for writing parser. Of course the framework is optional; you can still write a parser without the framework.
To design a framework, I have studied how @b4n (Colomban Wendling) writes parsers. tokenInfo API is the first fruit of my study.
TBW
Output tag stream¶
Ctags provides makeTagEntry to parsers as an entry point for writing tag information to MIO. makeTagEntry calls writeTagEntry if the parser does not set useCork field. writeTagEntry calls writerWriteTag. writerWriteTag just calls writeEntry of writer backends. writerTable variable holds the four backends: ctagsWriter, etagsWriter, xrefWriter, and jsonWriter. One of them is chosen depending on the arguments passed to ctags.
If useCork is set, the tag information goes to a queue on memory. The queue is flushed when useCork in unset. See cork API for more details.
cork API¶
Background and Idea¶
cork API is introduced for recording scope information easier.
Before introducing cork, a scope information must be recorded as strings. It is flexible but memory management is required. Following code is taken from clojure.c(with modifications).
if (vStringLength (parent) > 0)
{
current.extensionFields.scope[0] = ClojureKinds[K_NAMESPACE].name;
current.extensionFields.scope[1] = vStringValue (parent);
}
makeTagEntry (¤t);
parent, values stored to scope [0] and scope [1] are all kind of strings.
cork API provides more solid way to hold scope information. cork API expects parent, which represents scope of a tag(current) currently parser dealing, is recorded to a tags file before recording the current tag via makeTagEntry function.
For passing the information about parent to makeTagEntry, tagEntryInfo object was created. It was used just for recording; and freed after recording. In cork API, it is not freed after recording; a parser can reused it as scope information.
How to use¶
See a commit titled with “clojure: use cork”. I applied cork API to the clojure parser.
cork can be enabled and disabled per parser. cork is disabled by default. So there is no impact till you enables it in your parser.
useCork field is introduced in parserDefinition type:
typedef struct {
...
unsigned int useCork;
...
} parserDefinition;
Set CORK_QUEUE to useCork like:
extern parserDefinition *ClojureParser (void)
{
...
parserDefinition *def = parserNew ("Clojure");
...
def->useCork = CORK_QUEUE;
return def;
}
When ctags running a parser with useCork being CORK_QUEUE, all output requested via makeTagEntry function calling is stored to an internal queue, not to tags file. When parsing an input file is done, the tag information stored automatically to the queue are flushed to tags file in batch.
When calling makeTagEntry with a tagEntryInfo object(parent), it returns an integer. The integer can be used as handle for referring the object after calling.
static int parent = CORK_NIL;
...
parent = makeTagEntry (&e);
The handle can be used by setting to a scopeIndex field of current tag, which is in the scope of parent.
current.extensionFields.scopeIndex = parent;
When passing current to makeTagEntry, the scopeIndex is refereed for emitting the scope information of current.
scopeIndex must be set to CORK_NIL if a tag is not in any scope. When using scopeIndex of current, NULL must be assigned to both current.extensionFields.scope[0] and current.extensionFields.scope[1]. initTagEntry function does this initialization internally, so you generally you don’t have to write the initialization explicitly.
Automatic full qualified tag generation¶
If a parser uses the cork for recording and emitting scope information, ctags can reuse it for generating full qualified(FQ) tags. Set requestAutomaticFQTag field of parserDefinition to TRUE then the main part of ctags emits FQ tags on behalf of the parser if --extras=+q is given.
An example can be found in DTS parser:
extern parserDefinition* DTSParser (void)
{
static const char *const extensions [] = { "dts", "dtsi", NULL };
parserDefinition* const def = parserNew ("DTS");
...
def->requestAutomaticFQTag = TRUE;
return def;
}
Setting requestAutomaticFQTag to TRUE implies setting useCork to CORK_QUEUE.


About Me
Hi there!
I am currently a Ph.D. student in Computer Science at the University of Alicante. I am broadly interested in building the next generation of deep learning-based video prediction systems. My research interests span topics mainly in:
- Deep Learning
- Computer Vision
- Virtual/Augmented Reality
I am also passionated about CUDA programming, 3D computer graphics and AI.
By the way, I am really proud of my latest work done in Unreal Engine 4 about realistic hand interaction in VR. Take a look to UnrealGrasp.
Projects
UnrealGrasp is a flexible and visually realistic grasping system designed to enable natural and real-time interactions in virtual reality applications.
Description about the work on/with the project
- Garcia-Garcia, A., Martinez-Gonzalez, P., Oprea, S., Castro-Vargas, J. A., Orts-Escolano, S., Garcia-Rodriguez, J., & Jover-Alvarez, A. (2018). The RobotriX: An Extremely Photorealistic and Very-Large-Scale Indoor Dataset of Sequences with Robot Trajectories and Interactions. In 2018 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS) (pp. 6790–6797). https://doi.org/10.1109/IROS.2018.8594495
UnrealGrasp is a flexible and visually realistic grasping system designed to enable natural and real-time interactions in virtual reality applications.
Description about the work on/with the project
- Garcia-Garcia, A., Martinez-Gonzalez, P., Oprea, S., Castro-Vargas, J. A., Orts-Escolano, S., Garcia-Rodriguez, J., & Jover-Alvarez, A. (2018). The RobotriX: An Extremely Photorealistic and Very-Large-Scale Indoor Dataset of Sequences with Robot Trajectories and Interactions. In 2018 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS) (pp. 6790–6797). https://doi.org/10.1109/IROS.2018.8594495
Experience
Short description of the company (optional)
Description of role
Education
Institution name
Qualifications (eg. BA Performing Arts)
Date Range (eg. 2016 - 2019)
Short institution or course description (optional)
Description of qualification
A Little More About Me
Unconditional love for cycling, sailing and good food!


Type something in the input field to search the table for Books names, Author or Publisher:
| No. | Book Name | Author | Publisher | Category | Cover |
|---|---|---|---|---|---|
| 1 | The Web Application Hacker’s Handbook (Second Edition) | Dafydd Stuttard, Marcus Pinto | Wiley | Security (Web) | |
| 2 | Learning Malware Analysis | Monnappa K A | Packt Publishing | Security (Web) | |
| 3 | Real-World Bug Hunting: A Field Guide to Web Hacking | Peter Yaworski | No Starch Press | Security (Web) | |
| 4 | Android Hacker's Handbook | Joshua J. Drake, Pau Oliva Fora | WILEY | Security (Android) | |
| 5 | Cybersecurity and Privacy in Cyber Physical Systems | Yassine Maleh, Mohammad Shojafar | CRC Press | Security (Network) |
Note that we start the search in tbody, to prevent filtering the table headers.


| (A) | ---- no text ---- | |
| 355 | (C) | And sey vnbuxum we be . his byddynge to kepe |
| 356 | (D) | And sey vnbuxum we be his biddyng to kepe |
| 357 | (E) | ¶ Seyȝt vnbuxum we be . his byddyng to kepe |
| (Ex) | ---- no text ---- | |
| 365 | (L) | sayþ vnbuxum we beþ his biddyng to ȝete |
| 350 | (P) | Say vnbuxom haf we bene at his byddyng ȝitt |
| 349 | (U) | And say vnbuxum we be / his biddyng to kepe |
| (V) | ---- no text ---- |


Mississippi Blues Marathon
Jackson MS/USA
Website: www.msbluesmarathon.com
Race Winners
(42 runnings)
05 Jan
2008
2:25:01
2:48:37
13 Jan
2007
2:52:11
3:30:01
14 Jan
2006
2:41:30
3:10:50
15 Jan
2005
2:45:17
3:23:16
10 Jan
2004
2:57:52
3:38:02
11 Jan
2003
2:42:43
3:40:17
12 Jan
2002
2:37:54
3:27:34
13 Jan
2001
2:37:59
3:36:01
15 Jan
2000
2:49:18
3:30:39
12 Dec
1998
2:43:39
3:38:32
13 Dec
1997
2:50:47
2:59:18
08 Dec
1996
2:50:50
3:04:14
09 Dec
1995
2:40:06
3:18:24
10 Dec
1994
2:42:54
3:27:19
11 Dec
1993
2:38:12
3:38:07
12 Dec
1992
2:25:28
3:21:04
14 Dec
1991
2:28:31
3:07:27
08 Dec
1990
2:35:25
3:19:44
09 Dec
1989
2:36:39
3:16:38
12 Nov
1988
2:36:59
3:22:56
14 Nov
1987
2:35:26
3:21:13
15 Nov
1986
2:31:11
3:10:22
14 Dec
1985
2:28:44
3:19:57
08 Dec
1984
2:25:30
3:13:32
03 Dec
1983
2:25:38
3:04:02
04 Dec
1982
2:23:44
3:12:22
12 Dec
1981
2:28:20
3:11:34
13 Dec
1980
2:28:09
3:16:28
08 Dec
1979
2:33:51
3:17:23
09 Dec
1978
2:29:20
3:56:18
17 Dec
1977
2:41:57
5:02:14
11 Dec
1976
2:38:45
Notes: This event was known the Pepsi Marathon for 1986 and was the RRCA Championships.
It was known as the Trustmark Phidippides Marathon from 1988 thru 1990 and as the Mississippi Marathon for all
other years prior to 2008.. For 1978-1980, the race started in Natchez Trace and finished in Clinton; for 1981-1984,
the race was held in Jackson; for 1985-87 and 1991-2007 the race was held in Clinton; for 1988-1990 the race was
held in Madison. The 2011 race was the RRCA championships. The 2017 race was cancelled due to dangerous weather conditions
26 Jan
2019
2:33:53
Christoper Rayder (TN/USA)
3:17:18
Sarah Getty (MN/USA)
27 Jan
2018
2:38:39
Pete Kazery (MS/USA)
3:14:37
Jeanne-Claire White (LA/USA)
09 Jan
2016
2:35:13
Bryan Morseman (NY/USA)
3:15:47
Shandra Moore (TX/USA)
10 Jan
2015
2:41:39
Jay List (NY/USA)
2:57:40
Kari Elliott (AB/CAN)
11 Jan
2013
2:43:27
Ryan Henderson (MS/USA)
3:15:31
Lindsey Pierret (CT/USA)
05 Jan
2013
2:16:48
Craig Leon (OR/USA)
2:36:30
Truphena Chemeli Tarus-2
07 Jan
2012
2:20:28
Richard Tirop Kessio (KEN)
2:43:56
Malika Mejdoub (MAR)
08 Jan
2011
2:19:47
Peter Kemboi Chemaoy (KEN)
2:40:18
Truphena Chemeli Tarus (KEN)
09 Jan
2010
2:19:16
Jaynocel Basweti (KEN)
2:37:44
Janet
(Bawcom) Cherobon Kogo-2
03 Jan
2009
2:18:53
Edward Tabut (KEN)
2:46:29
Davina Chepkosgei (KEN)
Alene Reta (ETH)
Janet (Bawcom)
Cherobon Kogo (KEN)
Jim George (MS/USA)
Yukiko Nishide (NY/USA)
Chuck Engle-2
Tracy Stewart (CO/USA)
Leonard Vergunst (MS/USA)
Kimberly Whitman (USA)
Greg Gearhart-6
Yvonne Mayberry (TX/USA)
Chuck Engle (MS/USA)
Christie Barber-2
Kevin Phillips-2
Laurie Kearney (CA/USA)
Bryan Smith (LA/USA)
Christie Barber (MS/USA)
Chris Erchbach (USA)
Becky Chastain (USA)
David Audet (NH/USA)
April Kaper (USA)
Rex Lyon (USA)
Stephanie Black (MS/USA)
Kevin Phillips (MS/USA)
Becky Wall (USA)
Tony Huffman (USA)
Kathy Armstrong (USA)
Rodney Pearson-4
Marion Nooe (USA)
John Collins (USA)
Teresa Day (USA)
Rodney Pearson-3
Amelia Ingenot (USA)
Greg Gearhart-5
Ann Ringlein (NE/USA)
Jeff Keady-2
Karen Geraci (USA)
Greg Gearhart-4
Linda Owen-2
Greg Gearhart-3
Linda Owen (USA)
Cullen Crothers (USA)
Deborah Ethredge-2
Greg Gearhart-2
Ann Hawkins (USA)
Rodney Pearson-2
Pam Bowen-2
Todd Smoat (USA)
Pam Bowen (USA)
Greg Gearhart (USA)
Ginny Hornberger-2
Rodney Pearson (MS/USA)
Ginny Hornberger (MS/USA)
Jeff Keady (MS/USA)
Deborah Ethredge (USA)
Tom Leach (TN/USA)
Linda Nesbit (USA)
John Decker (USA)
Joyce Urish (USA)
Jim Ewing (MS/USA)
Kathy Ryan (MS/USA)
Joel Longerin (USA)
Nancy Alexander (USA)
Tom English (USA)
.
Most Wins
(1976-date)
Men
6
Greg Gearhart (MS/USA)
1983,1986,1988-89,1991,2004
Women
2
Ginny Hornberger (MS/USA)
1982-83
.
Pam Bowen (USA)
1984-85
.
Deborah Ethredge (USA)
1981,1987
.
Linda Owen (USA)
1988-89
.
Christie Barber (MS/USA)
2001,2003
Janet
(Bawcom) Cherobon Kogo (KEN)
2008,2010
Truphena Chemeli Tarus (KEN)
2011,2013
Prize Money
(ADR qualified runners)
Year Men Women Total 2014=> none none none 2013 $14,700 $14,700 $29,400 2012 11,500 11,500 23,000 2011 13,700 13,700 27,400 2010 13,700 14,700 28,400 2009 12,500 12,500 25,000 2008 11,500 12,500 24,000 Sums $77,600 $79,600 $157,200
Race Time Bias (sec/km) Year Men Women 2011 +4.2 n/c
Competitive Level (1990-date)
Year Men Women 2013 152 91 .... 2011 161 27 .... 2009 317 66
Quality Performances
Men <2:17 1 <2:18 2 <2:19 4 <2:20 9 Women <2:38 2 <2:40 2 <2:42 4 <2:44 6 <2:46 8 <2:48 11 <2:50 14
Last Updated on 19 Apr 2019 mp
Contributors: Jim & Judy Myrich, Jack Leydig (1)


Thalia:
I doubt that the Dark Elves will easily tell their secrets... But what is the alternative? We must obtain the Stardust at all costs.


An example of using a webcam for upscaling with UpscalerJS.
Click the upscale button to upscale a frame of video.


TEAMNAME (TEAMABBR)
INSERTOWNER (INSERTRECORD)
| Acquisitions | Trades | Waiver Tie Breaker Order |
| INSERTACQUISITIONS | INSERTTRADES | INSERTWAIVER |
OVERALLRANK Overall Rank |
POWERRANK Power Rank |
AGGREGATEPCT Aggregate Record |
Stats
Game Log
INSERTTABLEBODY
Metrics
| AWP | Aggregate winning percentage, record if you played every team every week |
| SOS | Strength of schedule, relative difficulty of schedule based on opponents' power ranking score |
| PPG | Points per game, total points for divided by number of games |
| MOV | Average margin of victory, average of difference between your score and opponent's score |


Randomized response is a technique, introduced in the mid-1960s, to survey people about sensitive topics. Suppose a teacher decides to survey his students on whether they cheat. Rather than directly asking each student “Have you cheated?,” a question cheaters are unlikely to answer truthfully, the teacher can employ randomized response. Rando... Read more 13 Apr 2018 - 1 minute read
In hypothesis testing, rejecting the null hypothesis typically means we found something interesting — a drug performs better than the placebo, there is a difference between two fertilizers, the new textbook helps students achieve better test scores than the current one, etc. Rejecting the null hypothesis when it is true amounts to a false discov... Read more 13 Apr 2018 - 2 minute read
Suppose we regress a response on covariates for . In linear regression, we get the model How do we interpret ? Does it mean that the th covariate is uncorrelated with the response? The answer is no! It means the th covariate is uncorrelated with the response after we control for the effects of the other covariates. A neat way to see thi... Read more 13 Apr 2018 - 1 minute read
In this post, I want to discuss the number of GPS satellites you need to determine your location. I illustrate with an example. Suppose Joe is lost in London, but knows where certain landmarks are, e.g., he knows where the library is, and where the museum and Buckingham palace are. Joe stops me in the street to find his bearings. I tell him,... Read more 13 Apr 2018 - 1 minute read
Suppose I conduct an experiment to determine whether to use font A or font B in an online ad. After running the experiment, I find that there is a 1% chance that a user clicks on the font A ad, and a 0.8% chance that the user clicks on the font B ad. We can can compare these click rates on an absolute scale (font A increases the click rate by ... Read more 13 Apr 2018 - 2 minute read


EVO HTML to PDF Converter allows you create text notes marked by appropriate icons in the generated PDF document.
In this demo some of the HTML elements from converted HTML document are marked to become icons for text notes in the generated PDF document.
The following options are available in this demo:
-
HTML String with Markers for Text Notes. When you convert a HTML string you also have the option to specify a base URL that will be used
by converter to resolve the relative URLs found in the HTML string to fully qualified URLs. If your HTML string uses only fully qualified URLs then this parameter is not necessary


Oga Mechanic apart from providing an online network for service providers and end users, also has a one-stop shop for the sale of genuine car spare parts sourced from reputable and trusted wholesalers at a fairly stable prices 90% of the time with only a 10% rate of variation when prices are marginally determined by subjective market operators.


--- layout: page title: "Applications" permalink: /apps/ --- {%- assign apps = site.data.apps.links -%}
{{ app.headline }}


others
territory
change in interstate borders
secession
separation of a part of a state's territory
autonomy
acquirement or expansion of political autonomy
system/ideology
changes in ideological, religious, socio-economic or juridical agenda of a political system – or change of the type of a regime
national power
political authority in a state
international power
change in the constellation of power in an international or regional system
subnational predominance
de facto control of a government, a non-governmental organization, or a population over a region or a population
resources
ownership of natural resources and resulting profit


Angular directive for slick carousel.
Current index: {{ index }}
Change index to 4
Information about all settings you can find at original slick site.


{%extends 'base2.html'%} {% load bootstrap3 %}
{{ neighbourhood.neighbourhood_name }}
{{neighbourhood.location}}
{{neighbourhood.occupants}} occupants


Time & date from minute.js here
Looking For Your Desire
Specialist Doctor ?
Dr. Salina Zaman
Medicine & Heart Spelist
Good Health Clinic
Looking For Your Desire
Specialist Doctor ?
Dr. Salina Zaman
Medicine & Heart Spelist
Good Health Clinic
Looking For Your Desire
Specialist Doctor ?
Dr. Salina Zaman
Medicine & Heart Spelist
Good Health Clinic
Looking For Your Desire
Specialist Doctor ?
Dr. Salina Zaman
Medicine & Heart Spelist
Good Health Clinic
Categories
See All
Pediatrician
Neurosurgeon
Cardiologist
Psychiatrist
Available Doctor
See All
Dr. Serena Gome
Medicine Specialist
Experience
8 Years
Patients
1.08K
Dr. Farid Raihan
Medicine Specialist
Experience
8 Years
Patients
1.08K
Dr. Kiran Shakia
Medicine Specialist
Experience
8 Years
Patients
1.08K
Dr. Masuda Khan
Medicine Specialist
Experience
8 Years
Patients
1.08K
Dr. Johir Raihan
Medicine Specialist
Experience
8 Years
Patients
1.08K
Dr. Saima Khan
Medicine Specialist
Experience
8 Years
Patients
1.08K
Home
Doctors
Notification
Menu
My Appointment
Profile
Settings
Log Out


|
UTF-8 Simple Library for Internationalization
|
A simple buffer for caching values returned by Windows API. More...
#include <winutf8.h>
Public Member Functions | |
| buffer (size_t size_) | |
| ~buffer () | |
| Destructor. | |
| buffer (const buffer &other) | |
| Copy constructor. | |
| buffer & | operator= (const buffer &rhs) |
| Principal assignment operator. | |
| buffer & | operator= (const std::string &rhs) |
| String assignment operator. | |
| operator wchar_t * () | |
| Return a pointer to buffer. | |
| operator std::string () const | |
| Convert buffer to an UTF-8 encoded string. | |
| DWORD | size () const |
| Return buffer size. | |
A simple buffer for caching values returned by Windows API.
Many Windows API function return output strings as UTF-16 encoded strings.
This class provides conversion operators that make it easier to go back to UTF-8 encoded strings.
Here is a simple usage example:
Without this class, the equivalent code would be something like:
| utf8::buffer::buffer | ( | size_t | size_ | ) |
Constructor
| size_ | buffer size in characters (not bytes) |


[gecode-users] Custom constraint to external progam
Mikael Zayenz Lagerkvist
zayenz at gmail.com
Thu Nov 13 12:05:07 CET 2008
Hi,
There are no examples currently in Gecode that implement custom propagators.
There is an old post in the mailinglist with a custom
propagator-example [1]. Note that there is a bug in the logic, the
line
GECODE_ME_CHECK(x1.inter_r(home, u12, false));
should be
GECODE_ME_CHECK(x0.inter_r(home, u12, false));
I missed that on a variable-renaming before posting it.
Hope that helps,
Mikael
[1] http://article.gmane.org/gmane.comp.lib.gecode.user/1276/
On Thu, Nov 13, 2008 at 11:51 AM, Pedro Salgueiro <pds at di.uevora.pt> wrote:
> Ok, I think thats what I want to do.
>
> Is there any examples in Gecode that implement a custom propagator?
>
> Pedro Salgueiro
>
> On Thu, 2008-11-13 at 11:10 +0100, Mauricio Toro wrote:
>> Hello,
>>
>>
>> I made something similar once.
>> My approach was writting a propagator
>> that waits until cvars[0] and cvars[1]
>> are assigned. Once they are assigned
>> it calls run_something.
>>
>>
>> I hope that helps,
>>
>>
>> Mauricio
>>
>> 2008/11/13 Pedro Salgueiro <pds at di.uevora.pt>
>> Hi!
>>
>> I have been experimenting Gecode for a while, and now I want
>> to make
>> something wich I don't know if its possible:
>>
>> I want to create a new "custom" constraint that allows to
>> relate/constraint a variable with a function that receives two
>> other
>> gecode variables as parameters. This function will be
>> something
>> completely external to gecode, and evan c++, so, by the the
>> this
>> function is called the gecode variables that are used on it
>> should
>> already have some values assigned to it.
>>
>> Here's how it would look:
>>
>> post(this, cvars[0] < 5)
>> post(this, cvars[1] < cvars[0] + 2)
>> post(this, new_constraint(cvars[2], run_something(cvars[0],
>> cvars[1])
>>
>> In this example, we could just assume that the
>> "new_constraint" is used
>> to make sure that cvars[2] "<"
>> run_something(cvars[0],cvars[1]).
>>
>> Is this possible to do? If so, where should I start?
>>
>> Thank you all
>> Pedro Salgueiro
>>
>>
>> _______________________________________________
>> Gecode users mailing list
>> users at gecode.org
>> https://www.gecode.org/mailman/listinfo/gecode-users
>>
>>
>>
>> --
>> Mauricio Toro Bermudez
>> Estudiante de Ingeniería de Sistemas
>> Pontificia Universidad Javeriana, Colombia
>>
>> Stagiare à l'Ircam
>> 1, place Igor-Stravinsky 75004 Paris,
>> France de 2008 à 2009
>>
>
>
> _______________________________________________
> Gecode users mailing list
> users at gecode.org
> https://www.gecode.org/mailman/listinfo/gecode-users
>
--
Mikael Zayenz Lagerkvist, http://www.ict.kth.se/~zayenz/
More information about the gecode-users
mailing list


Toggle navigation
I Wonder?
Login/Register
My Profile
My Questions
Name:
Date of Birth:
Email:
Update Profile
Change Password
Warning!
When you delete this question, it will delete all of the answers associated with it!
This can not be undone.


Herein, the main investigational problem is learning. This project focus on how a system based on a hybrid attitude between total competition and total cooperation, might be able to extract knowledge in order to improve its own performance over a specific working problem: Learn how to play a given game well. Why games?
Games are noise-free, cheap and easily replicable environments where the concepts of tactics, strategy, searching, learning and other relevant features of Artificial Intelligence (AI) can be tested in their purest state. Games, due to their conceptual flexibility, allow an open testing field for many different ideas.
Games are also fun. They are spread by all cultures, regions and epochs, and might have been (and continue to be) very important to our evolution, since they provided an entertainment dimension over intellectual and rational assignments. A game may be a tool for learning how to think properly.
What games?
Games embark on an ocean of ideas, concepts, strategies and attention from many different people. In fact, anybody trying to collect all available games, is rapidly overwhelmed by their number and variety. Here, when the word game is used, it refers to games without chance (no dice or whatever stochastic gadget) and with no hidden information (everybody knows the same thing about the game at any time). Games of this type are usually called perfect-information games. To restrict even more this still huge set of possible games, we should deal with games just for 2 players (without the interesting, but complex problems of Diplomacy, Bluffing, Politics, Alliances, ...), played on regular discrete grids (namely, square and hexagonal grids) and that are turn-based (this is a direct implication of perfect-information). More, the game theme (if any) is of no concern, and so this set of games also fit into the abstract games category.
From all these, we shall focus on games with only one or two types of pieces; this will exclude Chess (the Drosophila of AI, as Alexander Kronrod said once) but still including Checkers, Othello, Go, Tic-Tac-Toe and many dozens more (for a extensive list of such games, go to The World of Abstract Games). However, this will not imply a severe restriction on the project (the maximum number of piece types will easily be extended to more than just 2) but rather to keep the project goals as focused as possible in the fundamental problem of learning, that we intend to study.
The actual field of investigation on board game software players includes several different approaches. Some of them are reviewed here (also check an extensive list of papers from the Machine Learning in Games):
The specific knowledge-based approach has had great achievements in some games, the most famous case being IBM's Deep Blue victory against Kasparov on the game of Chess. The GAMES group of the University of Alberta works on several world-class software's like Checkers, Hex or Lines-of-Action. Victor Allis' work solved Gomoku, Connect4 and Qubic. John Romein's Multigame is a program using a rule-oriented language to define how to play, but still requires an human coded evaluation for each given game.
The meta-player approach tries to find known patterns from the rules of a given game, and applies them by tuning the set of features that defines the evaluation function. Barney Pell's Metagame is a program that analyses the rules stated on a specific language, and automatically creates a proper evaluation for each game position. The most successful system using this approach is the commercial application Zillions of Games. These two systems do have very distinct performances, they may have very good results for games that are fit for their meta-evaluation function, and play very poorly for other cases.
The learning approach gives the least possible amount of specific knowledge for a certain game, and uses mechanisms of optimization to improve game play. Some of them insert a lot of knowledge into the set of features, and the learning is reduced to the optimization of relative weights for those features. Examples of this approach are Samuel's self-learning player of the 50's and 60's dealing with Checkers, and Michael Gherrity's SAL [thesis].
Another possibility is to leave that task to the program, instead of inserting an expertise account of good features (even if the relevance of each feature is left undefined). A consequence is that unexpected features for a given game may appear, providing an extra dimension of knowledge acquisition. Related work can be found in Levinson's Morph II, Utgoff's ELF, Buro's GLEM, and Fawcett's Zenith [thesis].
Yet another approach was given by Susan Epstein's HOYLE, a program that decides its next move based on a previous agreement among several heuristics, each one with a certain concern in mind (each heuristic may have different ways to compute its knowledge).
The evolutionary or A-Life approach attacks the problem by using the genetic paradigm to evolve decisional structures, which from generation to generation, hopefully improve their way to play a game. A good example is David Fogel's work on evolving neural networks for playing Checkers. Another related work (using a special neural network architecture) is SANE, where two different populations co-exist, the hosts trying to improve their game strength while a population of parasites improve in order to defeat the hosts, providing a constant "aggressive" background from where the hosts must evolve. Another game tried with evolving networks is Dots'n'Boxes.
General information can be found in the next links [1, 2]. Check also the Computer Games Group, in the Maastricht Univ. - Netherlands, and the Computer Games Research Institute at Shizuoka Univ. - Japan.
A scientist would rather use someone else's toothbrush
than another's scientist's nomenclature.
old sayingInside LUD∆, there will be a set of agents, called players, able to perform several contests of a given game. A tournament is a set of contests between a set of players, where all players play against the others.
A game consists of a set of gaming material (the board and the piece set), the rule set, i.e., a set of rules (which defines the set of valid moves for a given game state), the endgame function (a function that defines when the game ends) and an initial setup (i.e., the initial state for every contest). A game state is defined by a certain board position, the next player and some extra information (e.g., the number of off-board pieces, the actual game phase, number of captured pieces, ...) visible to both players. More formally:
- The board is a set of labels, or cells, and a set of ordered pairs of cells, or links
- Each cell is associated with a value, which defines if it's empty or occupied by a certain piece (white/black soldier/king)
- A board may, optionally, have labels associated with set of cells, called sectors.
- A position is a board with a set of values associated for each cell
- A state consists of:
- A board position
- Which is the next player
- An optional set of registers defining extra information.
- The set S is the set of all states for game G.
- S0 is a special state called the game setup
- The rule set R is a relation SxS
- Each pair (Si, Sj) in R is called a legal move
- S is a valid state iff S = Rn(S0), i.e., if there is a set of n>=0 legal moves that reaches S from the setup
- All valid states SF from which there are no (SF, S) in R are called final states.
- A game allows passes if R is reflexive
- A game is invertible if R is symmetric
- A game has a super-KO rule if R is transitive
- The endgame function: S -> NxN is defined has:
- endgame( S ) = <0,0> if S is not a final state
- endgame( S ) = <1,1> if S is a final state and a win for the first player
- endgame( S ) = <1,0> if S is a final state and a draw for both player
- endgame( S ) = <1,-1> if S is a final state and a win for the second player
- The rule set R is also called the game tree
- The set of legal moves starting at S0 which are known and considered as good or bad moves, is called the opening theory of the game
- The set of valid states from which it is known all legal moves until some final state is reached, is called the endgame theory of the game
- The set of all other valid states is called the middlegame.
- An action is a function S->S.
- An action is an atomic change on the game board (e.g., insert/remove a piece or cell, change a game register, ...).
- A set of actions A1, A2, ..., An define a legal move for a given state S, iff (S, A1oA2o...oAn(S)) belongs to R
- A game policy is a function P:S->An that decides for each valid state, what should be the next actions.
- A tactic is an utility function returning a real for each valid state.
- A strategy is a weighted sequence of tactics.
- The policy then uses one or more strategies to maximize the expected value of the next state, and so to decide which will be the next move, i.e., P(state) = arg maxactions (strategy(actions(state)))
In most games, the rule set R cannot be stated explicitly (the game tree may be infinite or extremely large), so there must be a implicit description to define R. A low-level description focuses on coding the procedure validMoves(state), which gives the set of valid moves from a given legal state. A high-level description focuses on defining a language to represent rules (Zillions' ZRF is the most used and successful example).
LUD∆ is a system which tries to produce knowledge between cooperation and competition. This is the basis for the two main structures, the Arena and the Academy. The Arena is where all tournaments occur; the Academy is where all knowledge collected by all previous tournaments is kept and made accessible to all existing players for learning and improvement.
Inside the Arena, at each tournament, there is a set of players. These players may have different ways of decision making (decide which is the best move among all possible options) and learning (update the parameters of the decision structure). This plethora of different attitudes of playing a game seems useful to enhance the global performance of the system. In any optimization problem, the avoidance of local minima is a main concern to achieve better results. With the use of different searching strategies, some local minima may be easier to escape by some players than others, who will, eventually, be able to send out that information to others, via the Academy.
After a fixed number of tournaments (or just one tournament, if there is no learning involved), the Arena activates a selection mechanism, favoring statistically the best performances. The next generation of players will be found among those best entries of the previous tournament, plus some new players that are genetic combinations and mutations of them (at least, for those players to whom the combination or mutation of their internal structures makes sense).
The Academy is populated with knowledge gathered by those players. There are many open questions in this subject:
- What should be the criteria to insert/remove knowledge?
- Drastic increase/decrease of performance after some change in the player's control structure
- How to quantify the quality of each piece of knowledge? (the number of uses, the number of successes, in this case, the value of a new tactic should be proportional to victory increment)
- A forgetting value for unused knowledge, updated on each generation
- What type of knowledge can be kept?
- The opening theory, or Fuseki
- The endgame theory
- Know patterns should be merged if possible, to achieve more generalized ones.
- Local/middle game pattern moves (tactics), or Tesujis
- Use patterns to represent them?
- Does it make sense to search for regular piece patterns when analyzing a contest? (e.g., is it good to have a T pentomino on game G?)
- How to extract Tesujis from expert games?
- How to generalize two similar Tesujis?
- Feature evaluators (heuristics) and decision mechanisms (strategies)
- All players for historical or even genetic purposes (?)
- What is the representational language used?
- A language able to be translated to and from the players own languages (an Esperanto)
- All knowledge is the same, or is different?
- Can expert Human knowledge be added online?
- Can knowledge be mixed? How?
A player is able to perform a set of contests for a certain game. It is made of:
- A communication module to talk with the Arena (and thus, with other players)
- A communication module to talk with the Academy (to send/receive commands)
- Needs to know how to translate his knowledge to the Academy language
- A search mechanism over the game tree (alpha-beta, ...)
- A game policy
- The policy internal structure is defined by the player's type (it may use genes, neural nets, expert features, ...)
A player should:
- know the game rules in order to create the set of valid moves for a given state (i.e., it must be able to create the game tree if given sufficient time)
- be able to decide between the options he has.
- (optionally) be able to learn, so that it can (hopefully) improve its own ability to decide
- (optionally) be able to analyze the game tree, independently of actual game experience.
The last two points refer to opposite ways to gather data. Analysis is an active exploration of the game tree, which produces knowledge without any experience, in response to eventual game states. Learning is passive exploration of the game tree, which produces knowledge in response to occurring game states. In principle, both methods could gather the same information if sufficient resources were allocated, but each has its weaknesses. Even a deep analysis of the game tree may not be sufficient to find specific problems that only learning experience against an expert can come upon. On the other hand, learning by making a bad move that cannot be reverted is worse, if the player would have been able to predict it and avoid it in the first place. Analysis can create useless knowledge about situations that will only occur very rarely in real gaming. Learning only from games against novice players, could be bad in the long term.
When speaking of learning, the first two points above are included in what is called the weak theory of game domains (check Epstein's work for more details). In principle, a learning player would not even have to know the rules, it could play randomly at the beginning and learn the game tree (i.e., the set of legal moves) by experience. However, this is a major waste of computer resources and a questionable way to learn a game (no human learn a game this way). A more relevant point is to decide what else a player should know. Should it know some "general" heuristics (like mobility, capturing potential to compute piece value)? And Alpha-Beta? Specific game heuristics (e.g., corner cells are good in Othello)?
In principle, a weak theory should give the minimum and most general knowledge in order to support the acquisition of valuable and specific knowledge. Learning should be helped by this information, but not directed by it. In this framework, the player should learn how to use the given weak theory of meta-games for the specific game it plays. But computational resources are bounded (too bounded for most cases) and a compromise must be achieved between the minimum theoretical information (i.e., no information at all) and the minimum possible without destroying the player abilities. [This is still a very open question, at the present initial stage of LUD∆]
An important point is the following. Until now, the related works (mentioned early) have not mixed active and passive game tree exploration; analysis and learning do not cooperate in building the player's game strength. If a high-level description of the rules is available (even if it is harder to implement and has slower execution), it gives the player the possibility to check some game properties (e.g., piece power or goal type), and this knowledge can be used to adapt the learning structure, before the learning even begins! This attitude of planning before start playing, probably implies a more effective information acquisition. How much pre-built knowledge should be inserted on the making of this planning structure is a very relevant and (as far as I know) a new question (the answer should on the minimum possible expert information, without seriously compromising performance).
If a high level description is not available, the player can even so, be able to analyze the next features:
- The board topology (number of cells, average links per cell, ...).
- The average number of moves for each piece type; this will give an expected piece value.
- Is the game symmetric? By analyzing the setup and random positions while applying validMoves(), it would be possible to achieve a high degree of certainty about this feature. But this should be a part of the weak theory domain.
- In this case, the player should use two distinct evaluation functions (one for each color).
The player decision mechanism, also called policy, is based on strategies, i.e., a weighted sequences of tactical evaluations (or just tactics). The better player has a better policy, even if it may have the same tactical knowledge of a worse player (it is the way he chooses from them, that's better). An optimal policy identifies a path from the initial game state to the maximum final state value achievable, taken a certain opponent's behavior. A possible relevant point is that, even in symmetric games, it is known that perfect play leads to the victory of first or second player (or ending in a draw). Does this mean that players should have two different strategies, one when playing first, and another when playing second?
Mark Thomson's comment: In a losing game, the player should, ideally, play in such a way that its opponent has the greatest possible chance of making a mistake and losing his advantage. That would involve inferring the other playerís strategy, and setting up a situation where it would lead the other player astray. Alternatively, and more simply, the losing player could choose the move that delays loss for the longest time, on the assumption that this would tend to give the other player many chances to make a mistake
Playing Strength
Each player's strength in a given game, is directly based on the performance of its strategy to play that game. How are we to compare different players' strengths? International game federations use established ratings to classify players by their compared performance in actual contests. For example, FIDE Chess ELO (proposed by Prof. Arpad Elo), uses a normal distribution and a formula. After a contest, the new ELO for the player is calculated by:
New ELO = Old ELO + C . (Score of the Game - Expected Score)
where C is a constant that decreases when the player's strength increases. Namely, C = 30 for players with ELO less than 2000, C = 10 for ELO > 2400, or otherwise C = 130 - (opponent's rating)/20.
The score is, as usual, 0 for a loss, 0.5 for a draw and 1.0 for a win. The expected score of a game is given by the normal distribution, with mean 0.5 (the value for the draw) and variance of 200. This means that two players with a difference of 200 points, the stronger will have an expected result of 0.84. A difference of 100 ELO, will result in an expected score of 0.69 for the better player. A difference greater than 426 will not earn ELO points for the better player (after rounding the decimal part). A fast way to compute this expected value is: Excepted Result = 1 / (1 + 10^(-D/400)), where D is the actual ELO difference between players.
The worst player possible is Random, which strategy is to choose randomly one legal move. This player, by definition, has a fixed ELO zero. Notice that a player with a misŤre strategy (i.e., trying to loose) will have eventually a negative ELO.
Let's assume that a strategy S2 is one playing level above strategy S1, when the expected score of S2 against S1 is around 2/3 (wins two out of three games), i.e., their ELO difference is approx. 100. If another strategy S3 is one level above S2, is it possible that the expected score of S3 against S1 is 0.84 (ELO difference is 200)? Is this true? Only if the relation is transitive, which it probably is not. Playing strength only makes sense within a pool of players in a tournament. In this condition, ELO gives an average of the expected score, when compared with the players of that tournament. If the number of players is very big - like in Chess or Go worlds - each player is only able to perform a restricted number of contests, giving an expected value for its ELO.
A strategy is stable if when facing the same pool of players, its ELO is the same within an interval of 50 ELO points; otherwise, it's unstable.
A move is reasonable for a player with ELO E, if it would be chosen by another player with a strategy with ELO > E - 100. A move is good if it would be chosen by another player with a strategy with ELO > E + 100. Otherwise, it is a poor move. Obviously, this refers to a specific tournament's point of view (a good move may be considered bad because of poor analysis or just because they are all bad players).
A tactic, i.e., a weighted feature within a strategy, is essential (harmful), if its removal will decrease (increase) the strategy performance by one level (ELO increase/decrease of 100). It is critical (destructive), if the increase (decrease) is greater than 200 ELO points. A tactic is redundant if its removal does not affect the strategy strength. If a tactic removal changes the overall strategy strength for every tournament, it's structural.
This section presents some proposals for qualitative and quantitative properties to define and classify abstract games.
Quantitative measures
- The dimension of the search space, i.e., the number of possible positions inside the game tree, can be used to define the potential game complexity.
Size( G ) = log10 ( NT )
where NT is the number of nodes of game tree for G.
- The potential number of levels of expertise that can be found by different strategies.
Depth( G ) = E / 100 + 6 / log10( PL )
where E is the ELO of the best known player, and PL is the greater number between 10 or the number of existing human players of G. The use of log is two-fold, a crude approximation of the number of players is sufficient, and the value added to E, slowly decreases as PL increases (the progression of expertise does not seem linear with the number of players). The number 6 points that when we get a population of one million serious players, the best one should be, approximately, one level below the perfect player.
- The branching factor of the game, i.e.,
Width( G ) = The average expected number of legal moves of a valid position
This measure can be statistically approximated by automatic search on actual contests.
- The timing between actual interaction (i.e., the possibility to capture or the entering on territory with direct enemy influence) between reasonable adversaries.
Tempo( G ) = The average number of moves to piece interaction
This measure can be statistically approximated by game analysis of actual contests against players positioned in the top 25% ELO.
- The overall piece mobility
Mobility( G ) = The average (number of moves per piece * percentage of empty cells)
This measure can be statistically approximated by automatic search on positions from actual contests.
- The rules simplicity may also be a measure of a game's quality (especially when judged with the game's depth). We can use Kolmogorov notion of complexity in this measure (for games with random elements, the Shannon notion of entropy should also be useful).
Clearness( G ) = The size of the smallest programs that compute validMoves( ) and endGame( )
In this context, the informal notion of a game overall strategy may be related with the algorithmic size of the (usually not available given bounded resources) function findOptimumMove( ). Another point, the precise number given by this definition of Clearness is uncomputable (!) We are only able to produce an estimation of its true value.
Qualitative measures
These measures deal with the relevance of the overall player's ignorance about the game tree. Their exact values would only be computable if the entire game tree analysis were possible.
- After a positional or material advantage, is it possible to secure that advantage in order to win? Or is easy to reverse it, to achieve a draw?
Decisiveness( G ) = The average percentage of positions with positional advantage for which there is a winning strategy.
A positional advantage is defined by a positive evaluation using the strategy of the best known player. If decisiveness approaches zero, it means that the game tree endgame states are densely covered with draws. This implies that a winning state can just be achieved with the help of both players (i.e., with a bad enemy move), meaning that the game is drawish, and thus, flawed.
A game with good decisiveness should easily be able to reach pre-endgame positions, where the positional or material advantage of those positions are enough to win the game with reasonable playing. Using Go terminology, a sensible sente/gote unbalance should be enough to determine the winning outcome of a contest.
- After a positional advantage, is there any reasonable chance of recovering?
Drama( G ) = The average percentage of reasonable moves that lead to a balanced position, given a positional advantage.
Drama is, in a sense, is the opposite of decisiveness. Poor drama leads to quick and decisive action; high drama should cause unexpected results, despite any positional superiority. But their definitions are not mutually exclusive, games may have excellent decisiveness, even though only very good players can profit from it!
- How easy is it to define a tactical and strategic plan?
Clarity( G ) = the average depth of the sub-tree necessary to find a reasonable move / log10 (the average number of nodes of that sub-tree)
So, clarity tells us about how far a strategy must search down the tree to identify reasonable moves. For the same number of nodes, if the sub-tree is thinner (i.e., deeper), it means better clarity (less lateral analysis is needed). The use of the logarithm is just to avoid numbers very close to zero.
Using some poetic license, the lack of clarity is the fog of war that clouds the abyss of perfect strategies.
Another interesting property is Topologic Invariance (TI) which relates the game playability with the varying size of different boards. Perhaps TI is a factor that should be added to each measure, indicating how they suffer accordingly when the board is changed.
I wish to thank David Ploog for a fruitful discussion on criteria for game classification, and to refer the notions of Tempo and Hardness (another name for Decisiveness). There are some open discussions about these subjects with Claude Chaunier, John Lawson and Jean-Pierre Queille, which contributed a lot to this document. Also a big thanks to Cameron Browne for his insightful thoughts about game tree complexity and to Mark Thomson for his excellent article "Defining the Abstract" and also for reviewing this text. I also wish to acknowledge all the scientific work referred to herein, that helped me with terminology and conceptual tools to elaborate LUD∆.
And I do not want to forget all the seeds ( o o o ) and spiders ( x x x ) that populated thousands of email games in the last 10 years! Finally, long live the Norwegian Blue!
Jo„o Pedro Neto (c) 2002


|
|
|---|
This is a walk-through as to how to clip or split a brush.
Before starting this tutorial you should first get acquainted with the basics of the "Tread3D" editor; the screen and the various commands that are available.
As in the previous tutorials start "Tread3D" and make one very basic brush.
Lets make the brush 256x256x256 units.
Your screen should look like the one below.
Now the first operation we will do is "clip" a brush.
This will cut a section out of a brush and delete the cut section.
Now click once on the "Clip Split" button.
Now highlight the brush.
In any of the three views (In this example we will use the TopX/Y view) draw a line with the pointer that cuts through the brush.
Your screen should now look like the one below.
Now press the "Space Bar" on your keyboard.
Your screen should look like the one below.
You will now notice that the brush has been clipped.
The "Red" lines represent the final brush configuration.
The "Green" lines represent the section of brush that has been removed.
Now click on the "pointer" button and then click on the background grid.
You will now see the final brush configuration.
Your screen should look like the one below.
Thats all there is to it.
Now some important notes:
The "Cut" line must pass through the brush completely.
The plane of the "clip" will be perpendicular the view you draw the "Cut" line in.
The deleted section of a brush will be to the right of the "Cut" line (Relative to the "Start-Stop position).
Now the second operation we will do is "split" a brush.
This will divide a brush in two.
As in the previous tutorials start "Tread3D" and make one very basic brush.
Lets again make the brush 256x256x256 units.
Your screen should again look like the one below.
Now click two times on the "Clip Split" button.
Now highlight the brush.
In any of the three views (In this example we will use the TopX/Y view) draw a line with the pointer that cuts through the brush.
Your screen should now look like the one below.
Now press the "Space Bar" on your keyboard.
Your screen should look like the one below.
You will now notice that the brush has been split in two.
Now click on the "pointer" button.
Highlight one brush and drag it away fron the other.
Your screen should look like the one below.
Now some important notes:
The "Cut" line must pass through the brush completely.
The plane of the "split" will be perpendicular the view you draw the "Cut" line in.
Thats all there is to it.
What you have done is "Clipped and Split" a brush.
Now resave your work.


The problem faced by small farmers is rather unique; the presence of fertile lands and high-quality farm produce doesn’t translate into fair deals on the market. This is due to a market which favors only high volumes. Disaggregated produce in small quantities have logistical issues and small farmers are left out in favor of big plantations which are in turn bad for bio-diversity and soil fertility. aHOPE provides the perfect solution for aggregation by linking the ecosystems of Farmers, Aggregation Agents(Agent) and Buyers (Manufacturers).
Download our app and join our community of farmers by providing relevant details in our easy to use interface.
With transparent price listings for your item, aHOPE lets you choose an agent available in your area, best suited to your needs.
Choose the crop, quantity and convenient date for pick up. You can also choose to drop off the crops yourself!
Once the Agent verifies your crops, get paid directly to your bank account.


{% extends 'catalog/base.html' %} {% load static %} {% block title %}PGS Catalog - FAQ{% endblock %} {% block content %}
PGS Catalog metadata (i.e. traits, authors, methods, performance metrics, cohort, etc...) is available through:
PGS Catalog scoring files (i.e. variants, weights, etc...) are available in the PGS Catalog FTP, however links to these files are available in the web interface and REST API.
The PGS Catalog development is led by Samuel Lambert under the supervision of Michael Inouye (University of Cambridge & Baker Institute) in collaboration with Health Data Research - UK (Laurent Gil) and the NHGRI-EBI GWAS Catalog (Aoife McMahon & Laura Harris).
The Catalog is under active development, and we continue to add new features and curate new data. If you use the Catalog in your research we ask that you cite our recent paper:
{{ pgs_citation.authors }}
{{ pgs_citation.title }}
{{ pgs_citation.journal }}doi: {{ pgs_citation.doi }} ({{ pgs_citation.year }}).
Individual PGS obtained from the database should also be cited appropriately, and used in accordance with any licensing restrictions set by the authors (see our Terms of Use for more information).
Published or preprinted polygenic score data meeting our inclusion criteria can be indexed in the Catalog. Please see the About page for a guide for authors looking to submit their data to the Catalog.
Pre-publication data can also be submitted and embargoed until publication to meet journal requirements.
The PGS Catalog and all its contents are made available through the standard EMBL-EBI terms of use.
Some scores have a known specific license (e.g. Creative Commons or specific non-commercial terms). These licenses are listed in the scoring file header, API/metadata and web display.
Type your query, e.g. “breast carcinoma”, into the search box and hit return or click the search icon . You can type any text you wish into the search bar.
| Data type | Example |
|---|---|
| Ontology identifier | EFO_0001645, EFO:0001645 |
| Ontology term | coronary artery disease |
| Ontology synomym | CAD |
| Ontology mapped terms | ICD10:I25, OMIM:608901 |
| Trait category | Cardiovascular disease |
More information about the Trait data in the PGS Catalog can be found here.
| Data type | Example |
|---|---|
| PGS Catalog Publication identifier (PGP ID) | PGP000007 |
| Publication title | Genomic Risk Prediction of Coronary Artery Disease in 480,000 Adults: Implications for Primary Prevention. |
| Publication authors | Inouye |
| PubMed identifier | 30309464 |
| DOI | 10.1016/j.jacc.2018.07.079 |
More information about the Publication data in the PGS Catalog can be found here.
| Data type | Example |
|---|---|
| PGS Catalog Score identifier (PGP ID) | PGS001530 |
| Score name | GBE_INI4103 |
| Score reported trait | Speed of sound through heel (L) |
More information about the Score data in the PGS Catalog can be found here.
The search then returns any Traits (marked with the letter ), Publications () or Scores () in the Catalog that contain a string match within a number of data fields.
By default all the results are showed. However you can use the buttons at the top of the page results to show only Traits, Publications or Scores, e.g.:
Each result is displayed as a card, with different information whether it is a Trait, a Publication or a Score, e.g.:
The buttons "Show PGS" display the list of Polygenic Score(s) associated with the Trait or the Publication.
| PGS ID | PGS Name | Reported Trait |
|---|---|---|
| PGS000002 | PRS77_ERpos | ER-positive Breast Cancer |
| PGS000005 | PRS313_ERpos | ER-positive Breast Cancer |
| PGS000008 | PRS3820_ERpos | ER-positive Breast Cancer |
| PGS000046 | BCPRS_ER+ | Estrogen receptor [ER]-positive breast cancer |
| PGS000347 | PRS287_ERpos | Estrogen receptor positive breast cancer |
| PGS000774 | PRS179_ERpos | Estrogen receptor positive breast cancer |
| PGS ID | PGS Name | Reported Trait | Developed | Evaluated |
|---|---|---|---|---|
| PGS000004 | PRS313_BC | Breast Cancer | ||
| PGS000007 | PRS3820_BC | Breast Cancer | ||
| PGS000001 | PRS77_BC | Breast Cancer | - | |
| PGS000006 | PRS313_ERneg | ER-negative Breast Cancer | ||
| PGS000009 | PRS3820_ERneg | ER-negative Breast Cancer | ||
| PGS000003 | PRS77_ERneg | ER-negative Breast Cancer | - | |
| PGS000005 | PRS313_ERpos | ER-positive Breast Cancer | ||
| PGS000008 | PRS3820_ERpos | ER-positive Breast Cancer |
For further information about the PGS Catalog scoring files (e.g. file format), please look at the documentation in the Download page.
https://www.pgscatalog.org/rest/score/PGS000001
{... "ftp_scoring_file": "https://ftp.ebi.ac.uk/pub/databases/spot/pgs/scores/PGS000001/ScoringFiles/PGS000001.txt.gz", ...}
We wrote pgsc_calc: a reproducible workflow to calculate both PGS Catalog and custom polygenic scores. The workflow automates PGS downloads from the Catalog, reading custom scoring files, variant matching between scoring files and target genotyping samplesets, and the parallel calculation of multiple PGS. See the full documentation here.
By default the download of the metadata and scoring files uses the protocol HTTPS, e.g.:
https://ftp.ebi.ac.uk/pub/databases/spot/pgs/scores/PGS000001/ScoringFiles/PGS000001.txt.gz
However our FTP server is having some intermittent issues with the HTTPS protocol.
If the downloads don't work with HTTPS, we recommend to replace it by one of the following protocols:
http://ftp.ebi.ac.uk/pub/databases/spot/pgs/scores/PGS000001/ScoringFiles/PGS000001.txt.gz
ftp://ftp.ebi.ac.uk/pub/databases/spot/pgs/scores/PGS000001/ScoringFiles/PGS000001.txt.gz


Preparation time
less than 30 mins
Cooking time
1 to 2 hours
Serves
Serves 4
This chicken dinner party dish is great to make in advance of people coming over.
For the chicken, preheat the oven to 190C/375F/Gas 5. Heat the oil in a large ovenproof frying pan and add all the chicken pieces to the pan. Cook for 10-12 minutes turning frequently until evenly browned. Remove with a slotted spoon and set aside.
Add the chorizo and shallots to the pan and fry, stirring frequently for five minutes, or until softened and the fat is beginning to run from the chorizo. Sprinkle in the flour and stir to coat.
Gradually pour in the cider and stock, stirring continuously until boiling and thickened slightly. Stir in the mustard, season well with salt and pepper and return the chicken to the frying pan.
Cover the frying pan with aluminium foil and cook in the oven for 35-40 minutes, or until the chicken’s juices run clear when pierced with a skewer.
For the celeriac mash, place the celeriac in a saucepan and cover with water and a squeeze of lemon juice. Bring to the boil, then reduce the heat, cover and simmer for about 15 minutes, or until tender.
Drain the celeriac well and tip it back into the pan. Mash over a low heat with the butter and single cream. Season with salt and white pepper.
To serve, stir the double cream into the chicken liquor and serve the chicken and sauce with the celeriac mash and steamed green beans.


We always make sure our customers get their products where and when they need them to be in time.
description = "Production-We Deliver" [viewBag] ==
Deliver
We always make sure our customers get their products where and when they need them to be in time.


Playing sports can make you stronger and healthier, contributing to lower obesity rates. Active people tend to have lower rates of diabetes and high blood pressure. Exercising regularly through sports programs could contribute to better heart and lung function. Learning to play sports as a child might carry over into being a more active adult
People who play sports tend to perform better at school. Student athletes earn higher grades and earn higher test scores on standardized tests.
Sports also play the important role of imparting character values. Playing sports can help teach honesty, teamwork and fair play. Learning to follow rules and respecting teammates and opponents can also be useful. Experiencing the role of a graceful winner and loser teaches people about being humble, and competition in general can teach individuals about self-respect, confidence and managing stress.
 I played football and hurling for Bishopstown and soccer with Wilton. I played half back in football and hurling and midfield in soccer
My first taste of victory was in hurling in 2013 when I captained my team to the premier 2 Championship. I also won the Cork schoolboys league with Lakewood in 2017. However my greatest achievement to date in sport was in 2018 when I won the double in football; winning the league and championship


Broadcaster
Login
Sign Up
Enter a new Password
Password
Comfirm Password
Reset
I remember my password


In this mission your task is to determine the popularity of certain words in the text.
At the input of your function are given 2 arguments: the text and the array of words the popularity of which you need to determine.
When solving this task pay attention to the following points:
Input: The text and the search words array.
Output: The dictionary where the search words are the keys and values are the number of times when those words are occurring in a given text.
Example:
popular_words(''' When I was One I had just begun When I was Two I was nearly new ''', ['i', 'was', 'three', 'near']) == { 'i': 4, 'was': 3, 'three': 0, 'near': 0 }
Precondition:
The input text will consists of English letters in uppercase and lowercase and whitespaces.


World History & Geography
World History & Geography: Modern
World Geography and Cultures
Impact California Social Studies, United...
World History and Geography Student
World Geography: Building a Global
World Geography: Building a Global
United States History and Geography
Geography: The Human and Physical
Florida World History & Geography
CIVICS Economics & Geography (Florida)
World Geography and Cultures
United States History and Geography
TENNESSEE United States History &...


NHS to pay tax bills to get doctors back to work
by Nick TriggleDoctors in England have been promised their tax bills will be covered by the NHS in an attempt to get them back doing overtime shifts.
Doctors have been refusing to do extra work because they were being landed with bills after changes to how much can be accrued in pensions tax-free.
Senior NHS figures and ministers have signed off on the plan amid concern about the impact on waiting times.
Waiting times have hit their worst levels on record.
The data released last week showed delays in A&E and for routine operations were at their highest levels since targets were introduced more than a decade ago.
The row over the pension changes is considered to be just one factor in that.
But NHS leaders have been pushing ministers to agree to a short-term fix with pressure growing ahead of winter.
The proposal will mean doctors can take money out of their pension pots to pay the tax bills they get next year.
The NHS will then top up their pension pots before retirement, meaning the cost of the measure to the health service will be spread out over time while doctors will not be out of pocket.
The emergency measure will only apply for the 2019-20 tax year.
The Treasury is still looking at how the pension changes have been implemented in an attempt to find a long-term solution ahead of the start of the next financial year in April.
How have the pension rules changed?
The amount people can put into pensions tax free has been reduced for all workers.
In 2010-11 it was £255,000, but has now been cut to £40,000 a year - and drops still further for the highest earners.
The changes tends to affect those earning more than £110,000, around a third of senior doctors and GPs.
A number of short-term fixes have already been tried, including allowing staff to temporarily opt out of the scheme and get any pension payments that they would have got put into their pay packet instead.
But these have had a limited impact on the stand-off, prompting NHS England to agree to the latest step.
There are differences to how pensions work elsewhere in the UK, although tax-free allowances have been reduced in each nation.
Currently only the NHS in England has taken this step.


You may have less than 2 minutes to complete this survey.
🚮 🔊 📶 🔥 🔋 🔥
How likely are you to recommend the product to a friend?
What is your favorite part of the Galaxy Note 7?
What is your least favorite part of the Galaxy Note 7?
What activities do you do on/with your Galaxy Note 7 the most? (Check all that apply)
Please include any comments or suggestions here:


HOME
ABOUT
MUSIC
CONTACT
HOME
ABOUT
MUSIC
CONTACT
PORTFOLIO
Fresco
Canvas
3 / 3
Sculpture
❮
❯
MY WORK
Here are some of my latest lorem works ipsum tipsum.
Click on the images to make them bigger
//Slides